From 96ab47c50a04dc8ab1638a1c80eb01753911308c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Nacho=20Cord=C3=B3n?= Date: Tue, 5 Mar 2024 17:21:39 +0000 Subject: [PATCH] Wires semantic analysis for procedures and functions (#175) --- .vscode/launch.json | 4 +- package-lock.json | 8 +- packages/language-server/src/linting.ts | 7 +- packages/language-server/src/server.ts | 28 +- .../completionCoreCompletions.ts | 4 +- packages/language-support/src/dbSchema.ts | 6 +- packages/language-support/src/index.ts | 3 +- .../language-support/src/signatureHelp.ts | 26 +- .../semanticAnalysisWrapper.ts | 15 +- .../src/syntaxValidation/syntaxValidation.ts | 8 +- .../functionsCompletion.test.ts | 54 +- .../procedureCompletion.test.ts | 27 +- .../propertykeyCompletion.test.ts | 8 +- .../src/tests/consoleCommands.test.ts | 15 +- .../src/tests/signatureHelp.test.ts | 28 +- .../semanticValidation.test.ts | 262 + .../language-support/src/tests/testData.ts | 53602 ++++++++++++++-- packages/language-support/src/types.ts | 37 + .../src/e2e_tests/autoCompletion.spec.tsx | 12 +- .../src/lang-cypher/syntaxValidation.ts | 5 +- packages/schema-poller/src/metadataPoller.ts | 50 +- .../schema-poller/src/queries/functions.ts | 17 +- .../schema-poller/src/queries/procedures.ts | 27 +- packages/schema-poller/src/types/sdkTypes.ts | 10 - .../e2e_tests/tests/signatureHelp.spec.ts | 35 +- packages/vscode-extension/package.json | 2 +- 26 files changed, 49079 insertions(+), 5221 deletions(-) create mode 100644 packages/language-support/src/types.ts diff --git a/.vscode/launch.json b/.vscode/launch.json index bbf21924..2abae661 100644 --- a/.vscode/launch.json +++ b/.vscode/launch.json @@ -18,8 +18,8 @@ ], "outFiles": [ "${workspaceRoot}/packages/vscode-extension/**/*.js", - "${workspaceRoot}/packages/language-support/**/*.cjs", - "${workspaceRoot}/packages/schema-poller/**/*.cjs" + "${workspaceRoot}/packages/language-support/**/*.js", + "${workspaceRoot}/packages/schema-poller/**/*.js" ], "autoAttachChildProcesses": true, "sourceMaps": true diff --git a/package-lock.json b/package-lock.json index ce9dbf92..d2ff0bf0 100644 --- a/package-lock.json +++ b/package-lock.json @@ -5019,9 +5019,9 @@ "dev": true }, "node_modules/@types/vscode": { - "version": "1.83.1", - "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.83.1.tgz", - "integrity": "sha512-BHu51NaNKOtDf3BOonY3sKFFmZKEpRkzqkZVpSYxowLbs5JqjOQemYFob7Gs5rpxE5tiGhfpnMpcdF/oKrLg4w==", + "version": "1.87.0", + "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.87.0.tgz", + "integrity": "sha512-y3yYJV2esWr8LNjp3VNbSMWG7Y43jC8pCldG8YwiHGAQbsymkkMMt0aDT1xZIOFM2eFcNiUc+dJMx1+Z0UT8fg==", "dev": true }, "node_modules/@types/workerpool": { @@ -20218,7 +20218,7 @@ "@testcontainers/neo4j": "^10.4.0", "@types/mocha": "^10.0.1", "@types/node": "^16.11.7", - "@types/vscode": "^1.75.0", + "@types/vscode": "^1.87.0", "@vscode/test-electron": "^2.3.8", "@vscode/vsce": "^2.21.1", "mocha": "^10.2.0", diff --git a/packages/language-server/src/linting.ts b/packages/language-server/src/linting.ts index 4476da9e..9a9f84a6 100644 --- a/packages/language-server/src/linting.ts +++ b/packages/language-server/src/linting.ts @@ -1,4 +1,5 @@ import { validateSyntax } from '@neo4j-cypher/language-support'; +import { Neo4jSchemaPoller } from '@neo4j-cypher/schema-poller'; import debounce from 'lodash.debounce'; import { join } from 'path'; import { Diagnostic, TextDocumentChangeEvent } from 'vscode-languageserver'; @@ -16,6 +17,7 @@ let lastSemanticJob: LinterTask | undefined; async function rawLintDocument( change: TextDocumentChangeEvent, sendDiagnostics: (diagnostics: Diagnostic[]) => void, + neo4j: Neo4jSchemaPoller, ) { const { document } = change; @@ -25,7 +27,8 @@ async function rawLintDocument( return; } - const syntaxErrors = validateSyntax(query, {}); + const dbSchema = neo4j.metadata?.dbSchema ?? {}; + const syntaxErrors = validateSyntax(query, dbSchema); sendDiagnostics(syntaxErrors); @@ -36,7 +39,7 @@ async function rawLintDocument( } const proxyWorker = (await pool.proxy()) as unknown as LintWorker; - lastSemanticJob = proxyWorker.validateSemantics(query); + lastSemanticJob = proxyWorker.validateSemantics(query, dbSchema); const result = await lastSemanticJob; sendDiagnostics(result); diff --git a/packages/language-server/src/server.ts b/packages/language-server/src/server.ts index 59fe2a33..38556f18 100644 --- a/packages/language-server/src/server.ts +++ b/packages/language-server/src/server.ts @@ -26,7 +26,7 @@ import { cleanupWorkers, lintDocument } from './linting'; // Create a simple text document manager. const documents: TextDocuments = new TextDocuments(TextDocument); -const neo4jSdk = new Neo4jSchemaPoller(); +const neo4jSchemaPoller = new Neo4jSchemaPoller(); connection.onInitialize(() => { const result: InitializeResult = { @@ -74,12 +74,16 @@ connection.onInitialized(() => { }); documents.onDidChangeContent((change) => - lintDocument(change, (diagnostics: Diagnostic[]) => { - void connection.sendDiagnostics({ - uri: change.document.uri, - diagnostics, - }); - }), + lintDocument( + change, + (diagnostics: Diagnostic[]) => { + void connection.sendDiagnostics({ + uri: change.document.uri, + diagnostics, + }); + }, + neo4jSchemaPoller, + ), ); // Trigger the syntax colouring @@ -88,23 +92,23 @@ connection.languages.semanticTokens.on( ); // Trigger the signature help, providing info about functions / procedures -connection.onSignatureHelp(doSignatureHelp(documents, neo4jSdk)); +connection.onSignatureHelp(doSignatureHelp(documents, neo4jSchemaPoller)); // Trigger the auto completion -connection.onCompletion(doAutoCompletion(documents, neo4jSdk)); +connection.onCompletion(doAutoCompletion(documents, neo4jSchemaPoller)); connection.onDidChangeConfiguration( (params: { settings: { neo4j: Neo4jSettings } }) => { - neo4jSdk.disconnect(); + neo4jSchemaPoller.disconnect(); const neo4jConfig = params.settings.neo4j; if ( - neo4jSdk.connection === undefined && + neo4jSchemaPoller.connection === undefined && neo4jConfig.connect && neo4jConfig.password && neo4jConfig.connectURL && neo4jConfig.user ) { - void neo4jSdk.persistentConnect( + void neo4jSchemaPoller.persistentConnect( neo4jConfig.connectURL, { username: neo4jConfig.user, diff --git a/packages/language-support/src/autocompletion/completionCoreCompletions.ts b/packages/language-support/src/autocompletion/completionCoreCompletions.ts index f1b555ad..9dc340ae 100644 --- a/packages/language-support/src/autocompletion/completionCoreCompletions.ts +++ b/packages/language-support/src/autocompletion/completionCoreCompletions.ts @@ -44,7 +44,7 @@ const functionNameCompletions = ( namespacedCompletion( candidateRule, tokens, - Object.keys(dbSchema?.functionSignatures ?? {}), + Object.keys(dbSchema?.functions ?? {}), 'function', ); @@ -56,7 +56,7 @@ const procedureNameCompletions = ( namespacedCompletion( candidateRule, tokens, - Object.keys(dbSchema?.procedureSignatures ?? {}), + Object.keys(dbSchema?.procedures ?? {}), 'procedure', ); diff --git a/packages/language-support/src/dbSchema.ts b/packages/language-support/src/dbSchema.ts index e101fe80..822427ad 100644 --- a/packages/language-support/src/dbSchema.ts +++ b/packages/language-support/src/dbSchema.ts @@ -1,12 +1,12 @@ -import { SignatureInformation } from 'vscode-languageserver-types'; +import { Neo4jFunction, Neo4jProcedure } from './types'; export interface DbSchema { - procedureSignatures?: Record; - functionSignatures?: Record; labels?: string[]; relationshipTypes?: string[]; databaseNames?: string[]; aliasNames?: string[]; parameters?: Record; propertyKeys?: string[]; + procedures?: Record; + functions?: Record; } diff --git a/packages/language-support/src/index.ts b/packages/language-support/src/index.ts index 5877b91d..24d5eafe 100644 --- a/packages/language-support/src/index.ts +++ b/packages/language-support/src/index.ts @@ -8,7 +8,7 @@ export { parserWrapper, setConsoleCommandsEnabled, } from './parserWrapper'; -export { signatureHelp } from './signatureHelp'; +export { signatureHelp, toSignatureInformation } from './signatureHelp'; export { applySyntaxColouring, mapCypherToSemanticTokenIndex, @@ -22,6 +22,7 @@ export { } from './syntaxValidation/syntaxValidation'; export type { SyntaxDiagnostic } from './syntaxValidation/syntaxValidationHelpers'; export { testData } from './tests/testData'; +export type { Neo4jFunction, Neo4jProcedure } from './types'; export { CypherLexer, CypherParser }; import CypherLexer from './generated-parser/CypherCmdLexer'; diff --git a/packages/language-support/src/signatureHelp.ts b/packages/language-support/src/signatureHelp.ts index d9a32fa9..8560ab67 100644 --- a/packages/language-support/src/signatureHelp.ts +++ b/packages/language-support/src/signatureHelp.ts @@ -15,6 +15,7 @@ import { DbSchema } from './dbSchema'; import CypherCmdParserListener from './generated-parser/CypherCmdParserListener'; import { findCaret, isDefined } from './helpers'; import { parserWrapper } from './parserWrapper'; +import { Neo4jFunction, Neo4jProcedure } from './types'; export const emptyResult: SignatureHelp = { signatures: [], @@ -32,13 +33,28 @@ interface ParsedMethod { methodType: MethodType; } +export function toSignatureInformation( + curr: Neo4jFunction | Neo4jProcedure, +): SignatureInformation { + const { name, argumentDescription, description } = curr; + + return SignatureInformation.create( + name, + description, + ...argumentDescription.map((arg) => ({ + label: arg.name, + documentation: arg.description, + })), + ); +} + function toSignatureHelp( - methodSignatures: Record = {}, + methodSignatures: Record = {}, parsedMethod: ParsedMethod, -) { +): SignatureHelp { const methodName = parsedMethod.methodName; const method = methodSignatures[methodName]; - const signatures = method ? [method] : []; + const signatures = method ? [toSignatureInformation(method)] : []; const signatureHelp: SignatureHelp = { signatures: signatures, @@ -165,9 +181,9 @@ export function signatureHelp( if (method !== undefined) { if (method.methodType === MethodType.function) { - result = toSignatureHelp(dbSchema.functionSignatures, method); + result = toSignatureHelp(dbSchema.functions, method); } else { - result = toSignatureHelp(dbSchema.procedureSignatures, method); + result = toSignatureHelp(dbSchema.procedures, method); } } } diff --git a/packages/language-support/src/syntaxValidation/semanticAnalysisWrapper.ts b/packages/language-support/src/syntaxValidation/semanticAnalysisWrapper.ts index 8e05bd72..1499ef3f 100644 --- a/packages/language-support/src/syntaxValidation/semanticAnalysisWrapper.ts +++ b/packages/language-support/src/syntaxValidation/semanticAnalysisWrapper.ts @@ -3,9 +3,10 @@ /* eslint-disable @typescript-eslint/no-unsafe-assignment */ import { DiagnosticSeverity } from 'vscode-languageserver-types'; +import { DbSchema } from '../dbSchema'; // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-ignore -import { semanticAnalysis } from './semanticAnalysis'; +import { semanticAnalysis, updateSignatureResolver } from './semanticAnalysis'; export interface SemanticAnalysisResult { errors: SemanticAnalysisElement[]; @@ -26,9 +27,19 @@ type SemanticAnalysisElementNoSeverity = Omit< 'severity' >; -export function wrappedSemanticAnalysis(query: string): SemanticAnalysisResult { +export function wrappedSemanticAnalysis( + query: string, + dbSchema: DbSchema, +): SemanticAnalysisResult { try { let semanticErrorsResult = undefined; + + if (dbSchema.functions && dbSchema.procedures) { + updateSignatureResolver({ + procedures: Object.values(dbSchema.procedures), + functions: Object.values(dbSchema.functions), + }); + } semanticAnalysis([query], (a) => { semanticErrorsResult = a; }); diff --git a/packages/language-support/src/syntaxValidation/syntaxValidation.ts b/packages/language-support/src/syntaxValidation/syntaxValidation.ts index fb983fb6..3797ceb2 100644 --- a/packages/language-support/src/syntaxValidation/syntaxValidation.ts +++ b/packages/language-support/src/syntaxValidation/syntaxValidation.ts @@ -169,7 +169,7 @@ export function lintCypherQuery( return syntaxErrors; } - const semanticErrors = validateSemantics(query); + const semanticErrors = validateSemantics(query, dbSchema); return semanticErrors; } @@ -193,7 +193,10 @@ export function validateSyntax( /** * Assumes the provided query has no parse errors */ -export function validateSemantics(query: string): SyntaxDiagnostic[] { +export function validateSemantics( + query: string, + dbSchema: DbSchema, +): SyntaxDiagnostic[] { if (query.length > 0) { const cachedParse = parserWrapper.parse(query); const statements = cachedParse.statementsParsing; @@ -203,6 +206,7 @@ export function validateSemantics(query: string): SyntaxDiagnostic[] { if (cmd.type === 'cypher' && cmd.statement.length > 0) { const { notifications, errors } = wrappedSemanticAnalysis( cmd.statement, + dbSchema, ); const elements = notifications.concat(errors); diff --git a/packages/language-support/src/tests/autocompletion/functionsCompletion.test.ts b/packages/language-support/src/tests/autocompletion/functionsCompletion.test.ts index d5a809c4..7c5a4eba 100644 --- a/packages/language-support/src/tests/autocompletion/functionsCompletion.test.ts +++ b/packages/language-support/src/tests/autocompletion/functionsCompletion.test.ts @@ -1,54 +1,10 @@ import { CompletionItemKind } from 'vscode-languageserver-types'; import { DbSchema } from '../../dbSchema'; +import { testData } from '../testData'; import { testCompletions } from './completionAssertionHelpers'; describe('function invocations', () => { - const dbSchema: DbSchema = { - functionSignatures: { - abs: { label: 'abs' }, - acos: { label: 'acos' }, - all: { label: 'all' }, - any: { label: 'any' }, - 'apoc.agg.first': { label: 'apoc.agg.first' }, - 'apoc.agg.graph': { label: 'apoc.agg.graph' }, - 'apoc.agg.last': { label: 'apoc.agg.last' }, - 'apoc.agg.maxItems': { label: 'apoc.agg.maxItems' }, - 'apoc.agg.median': { label: 'apoc.agg.median' }, - 'apoc.agg.minItems': { label: 'apoc.agg.minItems' }, - 'apoc.agg.nth': { label: 'apoc.agg.nth' }, - 'apoc.agg.percentiles': { label: 'apoc.agg.percentiles' }, - 'apoc.agg.product': { label: 'apoc.agg.product' }, - 'apoc.agg.slice': { label: 'apoc.agg.slice' }, - 'apoc.agg.statistics': { label: 'apoc.agg.statistics' }, - 'apoc.any.isDeleted': { label: 'apoc.any.isDeleted' }, - 'apoc.any.properties': { label: 'apoc.any.properties' }, - 'apoc.any.property': { label: 'apoc.any.property' }, - 'apoc.any.rebind': { label: 'apoc.any.rebind' }, - 'apoc.bitwise.op': { label: 'apoc.bitwise.op' }, - 'apoc.coll.avg': { label: 'apoc.coll.avg' }, - 'apoc.coll.avgDuration': { label: 'apoc.coll.avgDuration' }, - 'apoc.coll.combinations': { label: 'apoc.coll.combinations' }, - 'apoc.coll.contains': { label: 'apoc.coll.contains' }, - 'apoc.coll.containsAll': { label: 'apoc.coll.containsAll' }, - 'apoc.coll.containsAllSorted': { label: 'apoc.coll.containsAllSorted' }, - 'apoc.coll.containsDuplicates': { label: 'apoc.coll.containsDuplicates' }, - 'apoc.coll.containsSorted': { label: 'apoc.coll.containsSorted' }, - 'apoc.coll.duplicates': { label: 'apoc.coll.duplicates' }, - 'apoc.coll.fill': { label: 'apoc.coll.fill' }, - 'apoc.coll.flatten': { label: 'apoc.coll.flatten' }, - 'apoc.coll.frequencies': { label: 'apoc.coll.frequencies' }, - 'apoc.coll.frequenciesAsMap': { label: 'apoc.coll.frequenciesAsMap' }, - 'apoc.coll.indexOf': { label: 'apoc.coll.indexOf' }, - 'apoc.coll.insert': { label: 'apoc.coll.insert' }, - 'apoc.coll.insertAll': { label: 'apoc.coll.insertAll' }, - 'apoc.coll.intersection': { label: 'apoc.coll.intersection' }, - 'apoc.coll.isEqualCollection': { label: 'apoc.coll.isEqualCollection' }, - 'apoc.coll.max': { label: 'apoc.coll.max' }, - 'apoc.coll.min': { label: 'apoc.coll.min' }, - 'apoc.coll.occurrences': { label: 'apoc.coll.occurrences' }, - 'apoc.coll.pairs': { label: 'apoc.coll.pairs' }, - }, - }; + const dbSchema: DbSchema = testData.mockSchema; test('Correctly completes unstarted function name in left hand side of WHERE', () => { const query = 'MATCH (n) WHERE '; @@ -340,9 +296,9 @@ describe('function invocations', () => { testCompletions({ query, dbSchema: { - functionSignatures: { - math: { label: 'math' }, - 'math.max': { label: 'math.max' }, + functions: { + math: { ...testData.emptyFunction, name: 'math' }, + 'math.max': { ...testData.emptyFunction, name: 'math.max' }, }, }, expected: [ diff --git a/packages/language-support/src/tests/autocompletion/procedureCompletion.test.ts b/packages/language-support/src/tests/autocompletion/procedureCompletion.test.ts index aa7eef95..2ff640f0 100644 --- a/packages/language-support/src/tests/autocompletion/procedureCompletion.test.ts +++ b/packages/language-support/src/tests/autocompletion/procedureCompletion.test.ts @@ -1,19 +1,30 @@ import { CompletionItemKind } from 'vscode-languageserver-types'; import { DbSchema } from '../../dbSchema'; +import { testData } from '../testData'; import { testCompletions } from './completionAssertionHelpers'; describe('Procedures auto-completion', () => { const dbSchema: DbSchema = { - procedureSignatures: { - 'tx.getMetaData': { label: 'tx.getMetaData' }, - 'jwt.security.requestAccess': { label: 'jwt.security.requestAccess' }, + procedures: { + 'tx.getMetaData': { ...testData.emptyProcedure, name: 'tx.getMetaData' }, + 'jwt.security.requestAccess': { + ...testData.emptyProcedure, + name: 'jwt.security.requestAccess', + }, 'db.index.fulltext.awaitEventuallyConsistentIndexRefresh': { - label: 'db.index.fulltext.awaitEventuallyConsistentIndexRefresh', + ...testData.emptyProcedure, + name: 'db.index.fulltext.awaitEventuallyConsistentIndexRefresh', + }, + 'db.ping': { ...testData.emptyProcedure, name: 'db.ping' }, + 'db.stats.retrieve': { + ...testData.emptyProcedure, + name: 'db.stats.retrieve', + }, + 'db.stats.collect': { + ...testData.emptyProcedure, + name: 'db.stats.collect', }, - 'db.ping': { label: 'db.ping' }, - 'db.stats.retrieve': { label: 'db.stats.retrieve' }, - 'db.stats.collect': { label: 'db.stats.collect' }, - 'db.stats.clear': { label: 'db.stats.clear' }, + 'db.stats.clear': { ...testData.emptyProcedure, name: 'db.stats.clear' }, }, }; diff --git a/packages/language-support/src/tests/autocompletion/propertykeyCompletion.test.ts b/packages/language-support/src/tests/autocompletion/propertykeyCompletion.test.ts index 2b55fc06..6db8eb83 100644 --- a/packages/language-support/src/tests/autocompletion/propertykeyCompletion.test.ts +++ b/packages/language-support/src/tests/autocompletion/propertykeyCompletion.test.ts @@ -1,11 +1,17 @@ import { CompletionItemKind } from 'vscode-languageserver-types'; import { DbSchema } from '../../dbSchema'; +import { testData } from '../testData'; import { testCompletions } from './completionAssertionHelpers'; describe('property key completions', () => { const dbSchema: DbSchema = { propertyKeys: ['name', 'type', 'level'], - functionSignatures: { 'apoc.util.sleep': { label: 'apoc.util.sleep' } }, + functions: { + 'apoc.util.sleep': { + ...testData.emptyFunction, + name: 'apoc.util.sleep', + }, + }, }; test('correctly completes property keys in WHERE', () => { diff --git a/packages/language-support/src/tests/consoleCommands.test.ts b/packages/language-support/src/tests/consoleCommands.test.ts index 010e44b9..1db7237d 100644 --- a/packages/language-support/src/tests/consoleCommands.test.ts +++ b/packages/language-support/src/tests/consoleCommands.test.ts @@ -5,6 +5,7 @@ import { setConsoleCommandsEnabled, } from '../parserWrapper'; import { applySyntaxColouring } from '../syntaxColouring/syntaxColouring'; +import { testData } from './testData'; function expectParsedCommands( query: string, @@ -243,13 +244,19 @@ describe('parameters', () => { test('autocompletes expressions', () => { const arrowCompletions = autocomplete(':param foo => ', { - functionSignatures: { - 'duration.inSeconds': { label: 'duration.inSeconds' }, + functions: { + 'duration.inSeconds': { + ...testData.emptyFunction, + name: 'duration.inSeconds', + }, }, }); const mapCompletions = autocomplete(':param {a: ', { - functionSignatures: { - 'duration.inSeconds': { label: 'duration.inSeconds' }, + functions: { + 'duration.inSeconds': { + ...testData.emptyFunction, + name: 'duration.inSeconds', + }, }, }); diff --git a/packages/language-support/src/tests/signatureHelp.test.ts b/packages/language-support/src/tests/signatureHelp.test.ts index 29c3f18f..8910650f 100644 --- a/packages/language-support/src/tests/signatureHelp.test.ts +++ b/packages/language-support/src/tests/signatureHelp.test.ts @@ -1,10 +1,10 @@ -import { - ParameterInformation, - SignatureHelp, - SignatureInformation, -} from 'vscode-languageserver-types'; +import { SignatureHelp } from 'vscode-languageserver-types'; import { DbSchema } from '../dbSchema'; -import { emptyResult, signatureHelp } from '../signatureHelp'; +import { + emptyResult, + signatureHelp, + toSignatureInformation, +} from '../signatureHelp'; import { testData } from './testData'; export function testSignatureHelp( @@ -23,13 +23,7 @@ export function testSignatureHelp( describe('Procedures signature help', () => { const dbSchema = testData.mockSchema; const procedureName = 'apoc.do.when'; - const signature = SignatureInformation.create( - procedureName, - dbSchema.procedureSignatures[procedureName].documentation, - ...dbSchema.procedureSignatures[procedureName].parameters.map((param) => - ParameterInformation.create(param.label, param.documentation), - ), - ); + const signature = toSignatureInformation(dbSchema.procedures[procedureName]); function expectedArgIndex(i: number): SignatureHelp { return { @@ -229,13 +223,7 @@ describe('Procedures signature help', () => { describe('Functions signature help', () => { const dbSchema = testData.mockSchema; const functionName = 'apoc.coll.combinations'; - const signature = SignatureInformation.create( - functionName, - dbSchema.functionSignatures[functionName].documentation, - ...dbSchema.functionSignatures[functionName].parameters.map((param) => - ParameterInformation.create(param.label, param.documentation), - ), - ); + const signature = toSignatureInformation(dbSchema.functions[functionName]); function expectedArgIndex(i: number): SignatureHelp { return { diff --git a/packages/language-support/src/tests/syntaxValidation/semanticValidation.test.ts b/packages/language-support/src/tests/syntaxValidation/semanticValidation.test.ts index ec892d9d..f0662195 100644 --- a/packages/language-support/src/tests/syntaxValidation/semanticValidation.test.ts +++ b/packages/language-support/src/tests/syntaxValidation/semanticValidation.test.ts @@ -1,4 +1,5 @@ import { setConsoleCommandsEnabled } from '../../parserWrapper'; +import { testData } from '../testData'; import { getDiagnosticsForQuery } from './helpers'; describe('Semantic validation spec', () => { @@ -1445,4 +1446,265 @@ In this case, p is defined in the same \`MATCH\` clause as ((a)-[e]->(b {h: (nod ]); setConsoleCommandsEnabled(false); }); + + test('Does not provide semantic validation for pluggeable functions when schema is not available', () => { + expect( + getDiagnosticsForQuery({ + query: `RETURN apoc.coll.sum(['a', 'b'])`, + }), + ).toEqual([]); + }); + + test('Provides semantic validation for built-in functions', () => { + expect( + getDiagnosticsForQuery({ + query: `WITH character_length() AS a + WITH character_length(1) AS b, a + RETURN a,b`, + }), + ).toEqual([ + { + message: "Insufficient parameters for function 'character_length'", + offsets: { + end: 28, + start: 5, + }, + range: { + end: { + character: 28, + line: 0, + }, + start: { + character: 5, + line: 0, + }, + }, + severity: 1, + }, + { + message: 'Type mismatch: expected String but was Integer', + offsets: { + end: 60, + start: 59, + }, + range: { + end: { + character: 31, + line: 1, + }, + start: { + character: 30, + line: 1, + }, + }, + severity: 1, + }, + ]); + }); + + test('Provides semantic validation for procedures when a schema is available', () => { + expect( + getDiagnosticsForQuery({ + query: ` + CALL db.awaitIndex('index', 'time') + CALL db.awaitIndex() + `, + dbSchema: testData.mockSchema, + }), + ).toEqual([ + { + message: 'Type mismatch: expected Integer but was String', + offsets: { + end: 43, + start: 37, + }, + range: { + end: { + character: 42, + line: 1, + }, + start: { + character: 36, + line: 1, + }, + }, + severity: 1, + }, + { + message: `Procedure call does not provide the required number of arguments: got 0 expected at least 1 (total: 2, 1 of which have default values). + +Procedure db.awaitIndex has signature: db.awaitIndex(indexName :: STRING, timeOutSeconds = 300 :: INTEGER) :: +meaning that it expects at least 1 argument of type STRING +`, + offsets: { + end: 73, + start: 53, + }, + range: { + end: { + character: 28, + line: 2, + }, + start: { + character: 8, + line: 2, + }, + }, + severity: 1, + }, + ]); + }); + + test('Shows default values correctly for external procedures', () => { + expect( + getDiagnosticsForQuery({ + query: 'CALL apoc.load.xml()', + dbSchema: testData.mockSchema, + }), + ).toEqual([ + { + message: `Procedure call does not provide the required number of arguments: got 0 expected at least 1 (total: 4, 3 of which have default values). + +Procedure apoc.load.xml has signature: apoc.load.xml(urlOrBinary :: ANY, path = / :: STRING, config = {} :: MAP, simple = false :: BOOLEAN) :: value :: MAP +meaning that it expects at least 1 argument of type ANY +`, + offsets: { + end: 20, + start: 0, + }, + range: { + end: { + character: 20, + line: 0, + }, + start: { + character: 0, + line: 0, + }, + }, + severity: 1, + }, + ]); + }); + + test('Does not fail if default arguments for procedure not provided', () => { + expect( + getDiagnosticsForQuery({ + query: `CALL apoc.load.xml('url', '/path')`, + dbSchema: testData.mockSchema, + }), + ).toEqual([]); + }); + + test('Does not fail semantic validation for functions that expect LIST', () => { + expect( + getDiagnosticsForQuery({ + query: `RETURN apoc.coll.max(['a'])`, + dbSchema: testData.mockSchema, + }), + ).toEqual([]); + }); + + test('Provides semantic validation for functions that expect LIST', () => { + expect( + getDiagnosticsForQuery({ + query: `RETURN apoc.coll.sum(['a', 'b'])`, + dbSchema: testData.mockSchema, + }), + ).toEqual([ + { + message: + 'Type mismatch: expected List, List or List but was List', + offsets: { + end: 31, + start: 21, + }, + range: { + end: { + character: 31, + line: 0, + }, + start: { + character: 21, + line: 0, + }, + }, + severity: 1, + }, + ]); + }); + + // TODO This doesn't seem to warn on deprecated + // arguments for either functions or procedures, + // needs to be solved in the database first + test('Notifies of deprecated returns in procedures', () => { + expect( + getDiagnosticsForQuery({ + query: `CALL apoc.meta.graphSample({})`, + dbSchema: { + functions: {}, + procedures: { + 'apoc.meta.graphSample': { + name: 'apoc.meta.graphSample', + description: + 'Examines the full graph and returns a meta-graph.\nUnlike `apoc.meta.graph`, this procedure does not filter away non-existing paths.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + + signature: + 'apoc.meta.graphSample(config = {} :: MAP) :: (nodes :: LIST, relationships :: LIST)', + returnDescription: [ + { + isDeprecated: true, + description: 'nodes :: LIST', + name: 'nodes', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'relationships :: LIST', + name: 'relationships', + type: 'LIST', + }, + ], + + admin: false, + option: { + deprecated: false, + }, + }, + }, + }, + }), + ).toEqual([ + { + message: + "The query used a deprecated field from a procedure. ('nodes' returned by 'apoc.meta.graphSample' is deprecated.)", + offsets: { + end: 30, + start: 0, + }, + range: { + end: { + character: 30, + line: 0, + }, + start: { + character: 0, + line: 0, + }, + }, + severity: 2, + }, + ]); + }); }); diff --git a/packages/language-support/src/tests/testData.ts b/packages/language-support/src/tests/testData.ts index 35342a0d..2633ccda 100644 --- a/packages/language-support/src/tests/testData.ts +++ b/packages/language-support/src/tests/testData.ts @@ -1,8886 +1,52438 @@ -const mockSchema = { - functionSignatures: { +import { DbSchema } from '../dbSchema'; +import { Neo4jFunction, Neo4jProcedure } from '../types'; + +const mockSchema: DbSchema = { + functions: { abs: { - label: 'abs', - documentation: 'Returns the absolute value of an `INTEGER` or `FLOAT`.', - parameters: [ + name: 'abs', + category: 'Numeric', + description: 'Returns the absolute value of an `INTEGER` or `FLOAT`.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: INTEGER | FLOAT', + isDeprecated: false, + description: 'input :: INTEGER | FLOAT', + name: 'input', + type: 'INTEGER | FLOAT', }, ], + signature: 'abs(input :: INTEGER | FLOAT) :: INTEGER | FLOAT', + returnDescription: 'INTEGER | FLOAT', + aggregating: false, }, acos: { - label: 'acos', - documentation: 'Returns the arccosine of a `FLOAT` in radians.', - parameters: [ + name: 'acos', + category: 'Trigonometric', + description: 'Returns the arccosine of a `FLOAT` in radians.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: FLOAT', + isDeprecated: false, + description: 'input :: FLOAT', + name: 'input', + type: 'FLOAT', }, ], + signature: 'acos(input :: FLOAT) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, all: { - label: 'all', - documentation: + name: 'all', + category: 'Predicate', + description: 'Returns true if the predicate holds for all elements in the given `LIST`.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'variable', - documentation: 'variable :: ANY', + isDeprecated: false, + description: 'variable :: ANY', + name: 'variable', + type: 'ANY', }, { - label: 'list', - documentation: 'list :: LIST', + isDeprecated: false, + description: 'list :: LIST', + name: 'list', + type: 'LIST', }, ], + signature: + 'all(variable :: VARIABLE IN list :: LIST WHERE predicate :: ANY) :: BOOLEAN', + returnDescription: 'BOOLEAN', + aggregating: false, }, any: { - label: 'any', - documentation: + name: 'any', + category: 'Predicate', + description: 'Returns true if the predicate holds for at least one element in the given `LIST`.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'variable', - documentation: 'variable :: ANY', + isDeprecated: false, + description: 'variable :: ANY', + name: 'variable', + type: 'ANY', }, { - label: 'list', - documentation: 'list :: LIST', + isDeprecated: false, + description: 'list :: LIST', + name: 'list', + type: 'LIST', }, ], + signature: + 'any(variable :: VARIABLE IN list :: LIST WHERE predicate :: ANY) :: BOOLEAN', + returnDescription: 'BOOLEAN', + aggregating: false, }, 'apoc.agg.first': { - label: 'apoc.agg.first', - documentation: 'Returns the first value from the given collection.', - parameters: [ + name: 'apoc.agg.first', + category: '', + description: 'Returns the first value from the given collection.', + isBuiltIn: false, + argumentDescription: [ { - label: 'value', - documentation: 'value :: ANY', + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', }, ], + signature: 'apoc.agg.first(value :: ANY) :: ANY', + returnDescription: 'ANY', + aggregating: true, }, 'apoc.agg.graph': { - label: 'apoc.agg.graph', - documentation: + name: 'apoc.agg.graph', + category: '', + description: 'Returns all distinct `NODE` and `RELATIONSHIP` values collected into a `MAP` with the keys `nodes` and `relationships`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'path', - documentation: 'path :: ANY', + isDeprecated: false, + description: 'path :: ANY', + name: 'path', + type: 'ANY', }, ], + signature: 'apoc.agg.graph(path :: ANY) :: MAP', + returnDescription: 'MAP', + aggregating: true, }, 'apoc.agg.last': { - label: 'apoc.agg.last', - documentation: 'Returns the last value from the given collection.', - parameters: [ + name: 'apoc.agg.last', + category: '', + description: 'Returns the last value from the given collection.', + isBuiltIn: false, + argumentDescription: [ { - label: 'value', - documentation: 'value :: ANY', + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', }, ], + signature: 'apoc.agg.last(value :: ANY) :: ANY', + returnDescription: 'ANY', + aggregating: true, }, 'apoc.agg.maxItems': { - label: 'apoc.agg.maxItems', - documentation: + name: 'apoc.agg.maxItems', + category: '', + description: 'Returns a `MAP` `{items: LIST, value: ANY}` where the `value` key is the maximum value present, and `items` represent all items with the same value. The size of the list of items can be limited to a given max size.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'items', - documentation: 'items :: ANY', + isDeprecated: false, + description: 'items :: ANY', + name: 'items', + type: 'ANY', }, { - label: 'value', - documentation: 'value :: ANY', + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', }, { - label: 'groupLimit', - documentation: 'groupLimit = -1 :: INTEGER', + isDeprecated: false, + default: 'DefaultParameterValue{value=-1, type=INTEGER}', + description: 'groupLimit = -1 :: INTEGER', + name: 'groupLimit', + type: 'INTEGER', }, ], + signature: + 'apoc.agg.maxItems(items :: ANY, value :: ANY, groupLimit = -1 :: INTEGER) :: ANY', + returnDescription: 'ANY', + aggregating: true, }, 'apoc.agg.median': { - label: 'apoc.agg.median', - documentation: + name: 'apoc.agg.median', + category: '', + description: 'Returns the mathematical median for all non-null `INTEGER` and `FLOAT` values.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'value', - documentation: 'value :: ANY', + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', }, ], + signature: 'apoc.agg.median(value :: ANY) :: ANY', + returnDescription: 'ANY', + aggregating: true, }, 'apoc.agg.minItems': { - label: 'apoc.agg.minItems', - documentation: + name: 'apoc.agg.minItems', + category: '', + description: 'Returns a `MAP` `{items: LIST, value: ANY}` where the `value` key is the minimum value present, and `items` represent all items with the same value. The size of the list of items can be limited to a given max size.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'items', - documentation: 'items :: ANY', + isDeprecated: false, + description: 'items :: ANY', + name: 'items', + type: 'ANY', }, { - label: 'value', - documentation: 'value :: ANY', + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', }, { - label: 'groupLimit', - documentation: 'groupLimit = -1 :: INTEGER', + isDeprecated: false, + default: 'DefaultParameterValue{value=-1, type=INTEGER}', + description: 'groupLimit = -1 :: INTEGER', + name: 'groupLimit', + type: 'INTEGER', }, ], + signature: + 'apoc.agg.minItems(items :: ANY, value :: ANY, groupLimit = -1 :: INTEGER) :: ANY', + returnDescription: 'ANY', + aggregating: true, }, 'apoc.agg.nth': { - label: 'apoc.agg.nth', - documentation: + name: 'apoc.agg.nth', + category: '', + description: 'Returns the nth value in the given collection (to fetch the last item of an unknown length collection, -1 can be used).', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'value', - documentation: 'value :: ANY', + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', }, { - label: 'offset', - documentation: 'offset :: INTEGER', + isDeprecated: false, + description: 'offset :: INTEGER', + name: 'offset', + type: 'INTEGER', }, ], + signature: 'apoc.agg.nth(value :: ANY, offset :: INTEGER) :: ANY', + returnDescription: 'ANY', + aggregating: true, }, 'apoc.agg.percentiles': { - label: 'apoc.agg.percentiles', - documentation: + name: 'apoc.agg.percentiles', + category: '', + description: 'Returns the given percentiles over the range of numerical values in the given collection.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'value', - documentation: 'value :: INTEGER | FLOAT', + isDeprecated: false, + description: 'value :: INTEGER | FLOAT', + name: 'value', + type: 'INTEGER | FLOAT', }, { - label: 'percentiles', - documentation: + isDeprecated: false, + default: + 'DefaultParameterValue{value=[0.5, 0.75, 0.9, 0.95, 0.99], type=LIST}', + description: 'percentiles = [0.5, 0.75, 0.9, 0.95, 0.99] :: LIST', + name: 'percentiles', + type: 'LIST', }, ], + signature: + 'apoc.agg.percentiles(value :: INTEGER | FLOAT, percentiles = [0.5, 0.75, 0.9, 0.95, 0.99] :: LIST) :: LIST', + returnDescription: 'LIST', + aggregating: true, }, 'apoc.agg.product': { - label: 'apoc.agg.product', - documentation: + name: 'apoc.agg.product', + category: '', + description: 'Returns the product of all non-null `INTEGER` and `FLOAT` values in the collection.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'value', - documentation: 'value :: INTEGER | FLOAT', + isDeprecated: false, + description: 'value :: INTEGER | FLOAT', + name: 'value', + type: 'INTEGER | FLOAT', }, ], + signature: + 'apoc.agg.product(value :: INTEGER | FLOAT) :: INTEGER | FLOAT', + returnDescription: 'INTEGER | FLOAT', + aggregating: true, }, 'apoc.agg.slice': { - label: 'apoc.agg.slice', - documentation: + name: 'apoc.agg.slice', + category: '', + description: 'Returns a subset of non-null values from the given collection (the collection is considered to be zero-indexed).\nTo specify the range from start until the end of the collection, the length should be set to -1.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'value', - documentation: 'value :: ANY', + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', }, { - label: 'from', - documentation: 'from = 0 :: INTEGER', + isDeprecated: false, + default: 'DefaultParameterValue{value=0, type=INTEGER}', + description: 'from = 0 :: INTEGER', + name: 'from', + type: 'INTEGER', }, { - label: 'to', - documentation: 'to = -1 :: INTEGER', + isDeprecated: false, + default: 'DefaultParameterValue{value=-1, type=INTEGER}', + description: 'to = -1 :: INTEGER', + name: 'to', + type: 'INTEGER', }, ], + signature: + 'apoc.agg.slice(value :: ANY, from = 0 :: INTEGER, to = -1 :: INTEGER) :: LIST', + returnDescription: 'LIST', + aggregating: true, }, 'apoc.agg.statistics': { - label: 'apoc.agg.statistics', - documentation: + name: 'apoc.agg.statistics', + category: '', + description: 'Returns the following statistics on the `INTEGER` and `FLOAT` values in the given collection: percentiles, min, minNonZero, max, total, mean, stdev.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'value', - documentation: 'value :: INTEGER | FLOAT', + isDeprecated: false, + description: 'value :: INTEGER | FLOAT', + name: 'value', + type: 'INTEGER | FLOAT', }, { - label: 'percentiles', - documentation: + isDeprecated: false, + default: + 'DefaultParameterValue{value=[0.5, 0.75, 0.9, 0.95, 0.99], type=LIST}', + description: 'percentiles = [0.5, 0.75, 0.9, 0.95, 0.99] :: LIST', + name: 'percentiles', + type: 'LIST', }, ], + signature: + 'apoc.agg.statistics(value :: INTEGER | FLOAT, percentiles = [0.5, 0.75, 0.9, 0.95, 0.99] :: LIST) :: MAP', + returnDescription: 'MAP', + aggregating: true, }, 'apoc.any.isDeleted': { - label: 'apoc.any.isDeleted', - documentation: + name: 'apoc.any.isDeleted', + category: '', + description: 'Returns true if the given `NODE` or `RELATIONSHIP` no longer exists.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'object', - documentation: 'object :: ANY', + isDeprecated: false, + description: 'object :: ANY', + name: 'object', + type: 'ANY', }, ], + signature: 'apoc.any.isDeleted(object :: ANY) :: BOOLEAN', + returnDescription: 'BOOLEAN', + aggregating: false, }, 'apoc.any.properties': { - label: 'apoc.any.properties', - documentation: + name: 'apoc.any.properties', + category: '', + description: 'Returns all properties of the given object.\nThe object can be a virtual `NODE`, a real `NODE`, a virtual `RELATIONSHIP`, a real `RELATIONSHIP`, or a `MAP`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'object', - documentation: 'object :: ANY', + isDeprecated: false, + description: 'object :: ANY', + name: 'object', + type: 'ANY', }, { - label: 'keys', - documentation: 'keys = null :: LIST', + isDeprecated: false, + default: 'DefaultParameterValue{value=null, type=LIST}', + description: 'keys = null :: LIST', + name: 'keys', + type: 'LIST', }, ], + signature: + 'apoc.any.properties(object :: ANY, keys = null :: LIST) :: MAP', + returnDescription: 'MAP', + aggregating: false, }, 'apoc.any.property': { - label: 'apoc.any.property', - documentation: + name: 'apoc.any.property', + category: '', + description: 'Returns the property for the given key from an object.\nThe object can be a virtual `NODE`, a real `NODE`, a virtual `RELATIONSHIP`, a real `RELATIONSHIP`, or a `MAP`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'object', - documentation: 'object :: ANY', + isDeprecated: false, + description: 'object :: ANY', + name: 'object', + type: 'ANY', }, { - label: 'key', - documentation: 'key :: STRING', + isDeprecated: false, + description: 'key :: STRING', + name: 'key', + type: 'STRING', }, ], + signature: 'apoc.any.property(object :: ANY, key :: STRING) :: ANY', + returnDescription: 'ANY', + aggregating: false, }, 'apoc.bitwise.op': { - label: 'apoc.bitwise.op', - documentation: 'Returns the result of the bitwise operation', - parameters: [ + name: 'apoc.bitwise.op', + category: '', + description: 'Returns the result of the bitwise operation', + isBuiltIn: false, + argumentDescription: [ { - label: 'a', - documentation: 'a :: INTEGER', + isDeprecated: false, + description: 'a :: INTEGER', + name: 'a', + type: 'INTEGER', }, { - label: 'operator', - documentation: 'operator :: STRING', + isDeprecated: false, + description: 'operator :: STRING', + name: 'operator', + type: 'STRING', }, { - label: 'b', - documentation: 'b :: INTEGER', + isDeprecated: false, + description: 'b :: INTEGER', + name: 'b', + type: 'INTEGER', }, ], + signature: + 'apoc.bitwise.op(a :: INTEGER, operator :: STRING, b :: INTEGER) :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, 'apoc.coll.avg': { - label: 'apoc.coll.avg', - documentation: + name: 'apoc.coll.avg', + category: '', + description: 'Returns the average of the numbers in the `LIST`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'coll', - documentation: 'coll :: LIST', + isDeprecated: false, + description: 'coll :: LIST', + name: 'coll', + type: 'LIST', }, ], + signature: 'apoc.coll.avg(coll :: LIST) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, 'apoc.coll.combinations': { - label: 'apoc.coll.combinations', - documentation: + name: 'apoc.coll.combinations', + category: '', + description: 'Returns a collection of all combinations of `LIST` elements between the selection size `minSelect` and `maxSelect` (default: `minSelect`).', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'coll', - documentation: 'coll :: LIST', + isDeprecated: false, + description: 'coll :: LIST', + name: 'coll', + type: 'LIST', }, { - label: 'minSelect', - documentation: 'minSelect :: INTEGER', + isDeprecated: false, + description: 'minSelect :: INTEGER', + name: 'minSelect', + type: 'INTEGER', }, { - label: 'maxSelect', - documentation: 'maxSelect = -1 :: INTEGER', + isDeprecated: false, + default: 'DefaultParameterValue{value=-1, type=INTEGER}', + description: 'maxSelect = -1 :: INTEGER', + name: 'maxSelect', + type: 'INTEGER', }, ], + signature: + 'apoc.coll.combinations(coll :: LIST, minSelect :: INTEGER, maxSelect = -1 :: INTEGER) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.coll.contains': { - label: 'apoc.coll.contains', - documentation: + name: 'apoc.coll.contains', + category: '', + description: 'Returns whether or not the given value exists in the given collection (using a HashSet).', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'coll', - documentation: 'coll :: LIST', + isDeprecated: false, + description: 'coll :: LIST', + name: 'coll', + type: 'LIST', }, { - label: 'value', - documentation: 'value :: ANY', + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', }, ], + signature: + 'apoc.coll.contains(coll :: LIST, value :: ANY) :: BOOLEAN', + returnDescription: 'BOOLEAN', + aggregating: false, }, 'apoc.coll.containsAll': { - label: 'apoc.coll.containsAll', - documentation: + name: 'apoc.coll.containsAll', + category: '', + description: 'Returns whether or not all of the given values exist in the given collection (using a HashSet).', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'coll1', - documentation: 'coll1 :: LIST', + isDeprecated: false, + description: 'coll1 :: LIST', + name: 'coll1', + type: 'LIST', }, { - label: 'coll2', - documentation: 'coll2 :: LIST', + isDeprecated: false, + description: 'coll2 :: LIST', + name: 'coll2', + type: 'LIST', }, ], + signature: + 'apoc.coll.containsAll(coll1 :: LIST, coll2 :: LIST) :: BOOLEAN', + returnDescription: 'BOOLEAN', + aggregating: false, }, 'apoc.coll.containsAllSorted': { - label: 'apoc.coll.containsAllSorted', - documentation: + name: 'apoc.coll.containsAllSorted', + category: '', + description: 'Returns whether or not all of the given values in the second `LIST` exist in an already sorted collection (using a binary search).', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'coll1', - documentation: 'coll1 :: LIST', + isDeprecated: false, + description: 'coll1 :: LIST', + name: 'coll1', + type: 'LIST', }, { - label: 'coll2', - documentation: 'coll2 :: LIST', + isDeprecated: false, + description: 'coll2 :: LIST', + name: 'coll2', + type: 'LIST', }, ], + signature: + 'apoc.coll.containsAllSorted(coll1 :: LIST, coll2 :: LIST) :: BOOLEAN', + returnDescription: 'BOOLEAN', + aggregating: false, }, 'apoc.coll.containsDuplicates': { - label: 'apoc.coll.containsDuplicates', - documentation: - 'Returns true if a collection contains duplicate elements.', - parameters: [ + name: 'apoc.coll.containsDuplicates', + category: '', + description: 'Returns true if a collection contains duplicate elements.', + isBuiltIn: false, + argumentDescription: [ { - label: 'coll', - documentation: 'coll :: LIST', + isDeprecated: false, + description: 'coll :: LIST', + name: 'coll', + type: 'LIST', }, ], + signature: 'apoc.coll.containsDuplicates(coll :: LIST) :: BOOLEAN', + returnDescription: 'BOOLEAN', + aggregating: false, }, 'apoc.coll.containsSorted': { - label: 'apoc.coll.containsSorted', - documentation: + name: 'apoc.coll.containsSorted', + category: '', + description: 'Returns whether or not the given value exists in an already sorted collection (using a binary search).', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'coll', - documentation: 'coll :: LIST', + isDeprecated: false, + description: 'coll :: LIST', + name: 'coll', + type: 'LIST', }, { - label: 'value', - documentation: 'value :: ANY', + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', }, ], + signature: + 'apoc.coll.containsSorted(coll :: LIST, value :: ANY) :: BOOLEAN', + returnDescription: 'BOOLEAN', + aggregating: false, }, 'apoc.coll.different': { - label: 'apoc.coll.different', - documentation: + name: 'apoc.coll.different', + category: '', + description: 'Returns true if all the values in the given `LIST` are unique.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'coll', - documentation: 'coll :: LIST', + isDeprecated: false, + description: 'coll :: LIST', + name: 'coll', + type: 'LIST', }, ], + signature: 'apoc.coll.different(coll :: LIST) :: BOOLEAN', + returnDescription: 'BOOLEAN', + aggregating: false, }, 'apoc.coll.disjunction': { - label: 'apoc.coll.disjunction', - documentation: 'Returns the disjunct set from two `LIST` values.', - parameters: [ + name: 'apoc.coll.disjunction', + category: '', + description: 'Returns the disjunct set from two `LIST` values.', + isBuiltIn: false, + argumentDescription: [ { - label: 'list1', - documentation: 'list1 :: LIST', + isDeprecated: false, + description: 'list1 :: LIST', + name: 'list1', + type: 'LIST', }, { - label: 'list2', - documentation: 'list2 :: LIST', + isDeprecated: false, + description: 'list2 :: LIST', + name: 'list2', + type: 'LIST', }, ], + signature: + 'apoc.coll.disjunction(list1 :: LIST, list2 :: LIST) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.coll.dropDuplicateNeighbors': { - label: 'apoc.coll.dropDuplicateNeighbors', - documentation: - 'Removes duplicate consecutive objects in the `LIST`.', - parameters: [ + name: 'apoc.coll.dropDuplicateNeighbors', + category: '', + description: 'Removes duplicate consecutive objects in the `LIST`.', + isBuiltIn: false, + argumentDescription: [ { - label: 'list', - documentation: 'list :: LIST', + isDeprecated: false, + description: 'list :: LIST', + name: 'list', + type: 'LIST', }, ], + signature: + 'apoc.coll.dropDuplicateNeighbors(list :: LIST) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.coll.duplicates': { - label: 'apoc.coll.duplicates', - documentation: + name: 'apoc.coll.duplicates', + category: '', + description: 'Returns a `LIST` of duplicate items in the collection.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'coll', - documentation: 'coll :: LIST', + isDeprecated: false, + description: 'coll :: LIST', + name: 'coll', + type: 'LIST', }, ], + signature: 'apoc.coll.duplicates(coll :: LIST) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.coll.duplicatesWithCount': { - label: 'apoc.coll.duplicatesWithCount', - documentation: + name: 'apoc.coll.duplicatesWithCount', + category: '', + description: 'Returns a `LIST` of duplicate items in the collection and their count, keyed by `item` and `count`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'coll', - documentation: 'coll :: LIST', + isDeprecated: false, + description: 'coll :: LIST', + name: 'coll', + type: 'LIST', }, ], + signature: + 'apoc.coll.duplicatesWithCount(coll :: LIST) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.coll.fill': { - label: 'apoc.coll.fill', - documentation: 'Returns a `LIST` with the given count of items.', - parameters: [ + name: 'apoc.coll.fill', + category: '', + description: 'Returns a `LIST` with the given count of items.', + isBuiltIn: false, + argumentDescription: [ { - label: 'items', - documentation: 'items :: STRING', + isDeprecated: false, + description: 'items :: STRING', + name: 'items', + type: 'STRING', }, { - label: 'count', - documentation: 'count :: INTEGER', + isDeprecated: false, + description: 'count :: INTEGER', + name: 'count', + type: 'INTEGER', }, ], + signature: + 'apoc.coll.fill(items :: STRING, count :: INTEGER) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.coll.flatten': { - label: 'apoc.coll.flatten', - documentation: + name: 'apoc.coll.flatten', + category: '', + description: 'Flattens the given `LIST` (to flatten nested `LIST` values, set recursive to true).', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'coll', - documentation: 'coll :: LIST', + isDeprecated: false, + description: 'coll :: LIST', + name: 'coll', + type: 'LIST', }, { - label: 'recursive', - documentation: 'recursive = false :: BOOLEAN', + isDeprecated: false, + default: 'DefaultParameterValue{value=false, type=BOOLEAN}', + description: 'recursive = false :: BOOLEAN', + name: 'recursive', + type: 'BOOLEAN', }, ], + signature: + 'apoc.coll.flatten(coll :: LIST, recursive = false :: BOOLEAN) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.coll.frequencies': { - label: 'apoc.coll.frequencies', - documentation: + name: 'apoc.coll.frequencies', + category: '', + description: 'Returns a `LIST` of frequencies of the items in the collection, keyed by `item` and `count`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'coll', - documentation: 'coll :: LIST', + isDeprecated: false, + description: 'coll :: LIST', + name: 'coll', + type: 'LIST', }, ], + signature: 'apoc.coll.frequencies(coll :: LIST) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.coll.frequenciesAsMap': { - label: 'apoc.coll.frequenciesAsMap', - documentation: + name: 'apoc.coll.frequenciesAsMap', + category: '', + description: 'Returns a `MAP` of frequencies of the items in the collection, keyed by `item` and `count`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'coll', - documentation: 'coll :: LIST', + isDeprecated: false, + description: 'coll :: LIST', + name: 'coll', + type: 'LIST', }, ], + signature: 'apoc.coll.frequenciesAsMap(coll :: LIST) :: MAP', + returnDescription: 'MAP', + aggregating: false, }, 'apoc.coll.indexOf': { - label: 'apoc.coll.indexOf', - documentation: + name: 'apoc.coll.indexOf', + category: '', + description: 'Returns the index for the first occurrence of the specified value in the `LIST`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'coll', - documentation: 'coll :: LIST', + isDeprecated: false, + description: 'coll :: LIST', + name: 'coll', + type: 'LIST', }, { - label: 'value', - documentation: 'value :: ANY', + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', }, ], + signature: + 'apoc.coll.indexOf(coll :: LIST, value :: ANY) :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, 'apoc.coll.insert': { - label: 'apoc.coll.insert', - documentation: + name: 'apoc.coll.insert', + category: '', + description: 'Inserts a value into the specified index in the `LIST`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'coll', - documentation: 'coll :: LIST', + isDeprecated: false, + description: 'coll :: LIST', + name: 'coll', + type: 'LIST', }, { - label: 'index', - documentation: 'index :: INTEGER', + isDeprecated: false, + description: 'index :: INTEGER', + name: 'index', + type: 'INTEGER', }, { - label: 'value', - documentation: 'value :: ANY', + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', }, ], + signature: + 'apoc.coll.insert(coll :: LIST, index :: INTEGER, value :: ANY) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.coll.insertAll': { - label: 'apoc.coll.insertAll', - documentation: + name: 'apoc.coll.insertAll', + category: '', + description: 'Inserts all of the values into the `LIST`, starting at the specified index.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'coll', - documentation: 'coll :: LIST', + isDeprecated: false, + description: 'coll :: LIST', + name: 'coll', + type: 'LIST', }, { - label: 'index', - documentation: 'index :: INTEGER', + isDeprecated: false, + description: 'index :: INTEGER', + name: 'index', + type: 'INTEGER', }, { - label: 'values', - documentation: 'values :: LIST', + isDeprecated: false, + description: 'values :: LIST', + name: 'values', + type: 'LIST', }, ], + signature: + 'apoc.coll.insertAll(coll :: LIST, index :: INTEGER, values :: LIST) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.coll.intersection': { - label: 'apoc.coll.intersection', - documentation: + name: 'apoc.coll.intersection', + category: '', + description: 'Returns the distinct intersection of two `LIST` values.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'list1', - documentation: 'list1 :: LIST', + isDeprecated: false, + description: 'list1 :: LIST', + name: 'list1', + type: 'LIST', }, { - label: 'list2', - documentation: 'list2 :: LIST', + isDeprecated: false, + description: 'list2 :: LIST', + name: 'list2', + type: 'LIST', }, ], + signature: + 'apoc.coll.intersection(list1 :: LIST, list2 :: LIST) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.coll.isEqualCollection': { - label: 'apoc.coll.isEqualCollection', - documentation: + name: 'apoc.coll.isEqualCollection', + category: '', + description: 'Returns true if the two collections contain the same elements with the same cardinality in any order (using a HashMap).', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'coll', - documentation: 'coll :: LIST', + isDeprecated: false, + description: 'coll :: LIST', + name: 'coll', + type: 'LIST', }, { - label: 'values', - documentation: 'values :: LIST', + isDeprecated: false, + description: 'values :: LIST', + name: 'values', + type: 'LIST', }, ], + signature: + 'apoc.coll.isEqualCollection(coll :: LIST, values :: LIST) :: BOOLEAN', + returnDescription: 'BOOLEAN', + aggregating: false, }, 'apoc.coll.max': { - label: 'apoc.coll.max', - documentation: + name: 'apoc.coll.max', + category: '', + description: 'Returns the maximum of all values in the given `LIST`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'values', - documentation: 'values :: LIST', + isDeprecated: false, + description: 'values :: LIST', + name: 'values', + type: 'LIST', }, ], + signature: 'apoc.coll.max(values :: LIST) :: ANY', + returnDescription: 'ANY', + aggregating: false, }, 'apoc.coll.min': { - label: 'apoc.coll.min', - documentation: + name: 'apoc.coll.min', + category: '', + description: 'Returns the minimum of all values in the given `LIST`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'values', - documentation: 'values :: LIST', + isDeprecated: false, + description: 'values :: LIST', + name: 'values', + type: 'LIST', }, ], + signature: 'apoc.coll.min(values :: LIST) :: ANY', + returnDescription: 'ANY', + aggregating: false, }, 'apoc.coll.occurrences': { - label: 'apoc.coll.occurrences', - documentation: 'Returns the count of the given item in the collection.', - parameters: [ + name: 'apoc.coll.occurrences', + category: '', + description: 'Returns the count of the given item in the collection.', + isBuiltIn: false, + argumentDescription: [ { - label: 'coll', - documentation: 'coll :: LIST', + isDeprecated: false, + description: 'coll :: LIST', + name: 'coll', + type: 'LIST', }, { - label: 'item', - documentation: 'item :: ANY', + isDeprecated: false, + description: 'item :: ANY', + name: 'item', + type: 'ANY', }, ], + signature: + 'apoc.coll.occurrences(coll :: LIST, item :: ANY) :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, 'apoc.coll.pairWithOffset': { - label: 'apoc.coll.pairWithOffset', - documentation: 'Returns a `LIST` of pairs defined by the offset.', - parameters: [ + name: 'apoc.coll.pairWithOffset', + category: '', + description: 'Returns a `LIST` of pairs defined by the offset.', + isBuiltIn: false, + argumentDescription: [ { - label: 'coll', - documentation: 'coll :: LIST', + isDeprecated: false, + description: 'coll :: LIST', + name: 'coll', + type: 'LIST', }, { - label: 'offset', - documentation: 'offset :: INTEGER', + isDeprecated: false, + description: 'offset :: INTEGER', + name: 'offset', + type: 'INTEGER', }, ], + signature: + 'apoc.coll.pairWithOffset(coll :: LIST, offset :: INTEGER) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.coll.pairs': { - label: 'apoc.coll.pairs', - documentation: + name: 'apoc.coll.pairs', + category: '', + description: 'Returns a `LIST` of adjacent elements in the `LIST` ([1,2],[2,3],[3,null]).', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'list', - documentation: 'list :: LIST', + isDeprecated: false, + description: 'list :: LIST', + name: 'list', + type: 'LIST', }, ], + signature: 'apoc.coll.pairs(list :: LIST) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.coll.pairsMin': { - label: 'apoc.coll.pairsMin', - documentation: + name: 'apoc.coll.pairsMin', + category: '', + description: 'Returns `LIST` values of adjacent elements in the `LIST` ([1,2],[2,3]), skipping the final element.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'list', - documentation: 'list :: LIST', + isDeprecated: false, + description: 'list :: LIST', + name: 'list', + type: 'LIST', }, ], + signature: 'apoc.coll.pairsMin(list :: LIST) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.coll.partition': { - label: 'apoc.coll.partition', - documentation: + name: 'apoc.coll.partition', + category: '', + description: 'Partitions the original `LIST` into a new `LIST` of the given batch size.\nThe final `LIST` may be smaller than the given batch size.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'coll', - documentation: 'coll :: LIST', + isDeprecated: false, + description: 'coll :: LIST', + name: 'coll', + type: 'LIST', }, { - label: 'batchSize', - documentation: 'batchSize :: INTEGER', + isDeprecated: false, + description: 'batchSize :: INTEGER', + name: 'batchSize', + type: 'INTEGER', }, ], + signature: + 'apoc.coll.partition(coll :: LIST, batchSize :: INTEGER) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.coll.randomItem': { - label: 'apoc.coll.randomItem', - documentation: + name: 'apoc.coll.randomItem', + category: '', + description: 'Returns a random item from the `LIST`, or null on `LIST` or `LIST`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'coll', - documentation: 'coll :: LIST', + isDeprecated: false, + description: 'coll :: LIST', + name: 'coll', + type: 'LIST', }, ], + signature: 'apoc.coll.randomItem(coll :: LIST) :: ANY', + returnDescription: 'ANY', + aggregating: false, }, 'apoc.coll.randomItems': { - label: 'apoc.coll.randomItems', - documentation: + name: 'apoc.coll.randomItems', + category: '', + description: 'Returns a `LIST` of `itemCount` random items from the original `LIST` (optionally allowing elements in the original `LIST` to be selected more than once).', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'coll', - documentation: 'coll :: LIST', + isDeprecated: false, + description: 'coll :: LIST', + name: 'coll', + type: 'LIST', }, { - label: 'itemCount', - documentation: 'itemCount :: INTEGER', + isDeprecated: false, + description: 'itemCount :: INTEGER', + name: 'itemCount', + type: 'INTEGER', }, { - label: 'allowRepick', - documentation: 'allowRepick = false :: BOOLEAN', + isDeprecated: false, + default: 'DefaultParameterValue{value=false, type=BOOLEAN}', + description: 'allowRepick = false :: BOOLEAN', + name: 'allowRepick', + type: 'BOOLEAN', }, ], + signature: + 'apoc.coll.randomItems(coll :: LIST, itemCount :: INTEGER, allowRepick = false :: BOOLEAN) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.coll.remove': { - label: 'apoc.coll.remove', - documentation: + name: 'apoc.coll.remove', + category: '', + description: 'Removes a range of values from the `LIST`, beginning at position index for the given length of values.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'coll', - documentation: 'coll :: LIST', + isDeprecated: false, + description: 'coll :: LIST', + name: 'coll', + type: 'LIST', }, { - label: 'index', - documentation: 'index :: INTEGER', + isDeprecated: false, + description: 'index :: INTEGER', + name: 'index', + type: 'INTEGER', }, { - label: 'length', - documentation: 'length = 1 :: INTEGER', + isDeprecated: false, + default: 'DefaultParameterValue{value=1, type=INTEGER}', + description: 'length = 1 :: INTEGER', + name: 'length', + type: 'INTEGER', }, ], + signature: + 'apoc.coll.remove(coll :: LIST, index :: INTEGER, length = 1 :: INTEGER) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.coll.removeAll': { - label: 'apoc.coll.removeAll', - documentation: + name: 'apoc.coll.removeAll', + category: '', + description: 'Returns the first `LIST` with all elements also present in the second `LIST` removed.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'list1', - documentation: 'list1 :: LIST', + isDeprecated: false, + description: 'list1 :: LIST', + name: 'list1', + type: 'LIST', }, { - label: 'list2', - documentation: 'list2 :: LIST', + isDeprecated: false, + description: 'list2 :: LIST', + name: 'list2', + type: 'LIST', }, ], + signature: + 'apoc.coll.removeAll(list1 :: LIST, list2 :: LIST) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.coll.runningTotal': { - label: 'apoc.coll.runningTotal', - documentation: 'Returns an accumulative `LIST`.', - parameters: [ + name: 'apoc.coll.runningTotal', + category: '', + description: 'Returns an accumulative `LIST`.', + isBuiltIn: false, + argumentDescription: [ { - label: 'list', - documentation: 'list :: LIST', + isDeprecated: false, + description: 'list :: LIST', + name: 'list', + type: 'LIST', }, ], + signature: + 'apoc.coll.runningTotal(list :: LIST) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.coll.set': { - label: 'apoc.coll.set', - documentation: 'Sets the element at the given index to the new value.', - parameters: [ + name: 'apoc.coll.set', + category: '', + description: 'Sets the element at the given index to the new value.', + isBuiltIn: false, + argumentDescription: [ { - label: 'coll', - documentation: 'coll :: LIST', + isDeprecated: false, + description: 'coll :: LIST', + name: 'coll', + type: 'LIST', }, { - label: 'index', - documentation: 'index :: INTEGER', + isDeprecated: false, + description: 'index :: INTEGER', + name: 'index', + type: 'INTEGER', }, { - label: 'value', - documentation: 'value :: ANY', + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', }, ], + signature: + 'apoc.coll.set(coll :: LIST, index :: INTEGER, value :: ANY) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.coll.shuffle': { - label: 'apoc.coll.shuffle', - documentation: 'Returns the `LIST` shuffled.', - parameters: [ + name: 'apoc.coll.shuffle', + category: '', + description: 'Returns the `LIST` shuffled.', + isBuiltIn: false, + argumentDescription: [ { - label: 'coll', - documentation: 'coll :: LIST', + isDeprecated: false, + description: 'coll :: LIST', + name: 'coll', + type: 'LIST', }, ], + signature: 'apoc.coll.shuffle(coll :: LIST) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.coll.sort': { - label: 'apoc.coll.sort', - documentation: 'Sorts the given `LIST` into ascending order.', - parameters: [ + name: 'apoc.coll.sort', + category: '', + description: 'Sorts the given `LIST` into ascending order.', + isBuiltIn: false, + argumentDescription: [ { - label: 'coll', - documentation: 'coll :: LIST', + isDeprecated: false, + description: 'coll :: LIST', + name: 'coll', + type: 'LIST', }, ], + signature: 'apoc.coll.sort(coll :: LIST) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.coll.sortMaps': { - label: 'apoc.coll.sortMaps', - documentation: + name: 'apoc.coll.sortMaps', + category: '', + description: 'Sorts the given `LIST>` into descending order, based on the `MAP` property indicated by `prop`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'list', - documentation: 'list :: LIST', + isDeprecated: false, + description: 'list :: LIST', + name: 'list', + type: 'LIST', }, { - label: 'prop', - documentation: 'prop :: STRING', + isDeprecated: false, + description: 'prop :: STRING', + name: 'prop', + type: 'STRING', }, ], + signature: + 'apoc.coll.sortMaps(list :: LIST, prop :: STRING) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.coll.sortMulti': { - label: 'apoc.coll.sortMulti', - documentation: + name: 'apoc.coll.sortMulti', + category: '', + description: 'Sorts the given `LIST>` by the given fields.\nTo indicate that a field should be sorted according to ascending values, prefix it with a caret (^).\nIt is also possible to add limits to the `LIST>` and to skip values.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'coll', - documentation: 'coll :: LIST', + isDeprecated: false, + description: 'coll :: LIST', + name: 'coll', + type: 'LIST', }, { - label: 'orderFields', - documentation: 'orderFields = [] :: LIST', + isDeprecated: false, + default: 'DefaultParameterValue{value=[], type=LIST}', + description: 'orderFields = [] :: LIST', + name: 'orderFields', + type: 'LIST', }, { - label: 'limit', - documentation: 'limit = -1 :: INTEGER', + isDeprecated: false, + default: 'DefaultParameterValue{value=-1, type=INTEGER}', + description: 'limit = -1 :: INTEGER', + name: 'limit', + type: 'INTEGER', }, { - label: 'skip', - documentation: 'skip = 0 :: INTEGER', + isDeprecated: false, + default: 'DefaultParameterValue{value=0, type=INTEGER}', + description: 'skip = 0 :: INTEGER', + name: 'skip', + type: 'INTEGER', }, ], + signature: + 'apoc.coll.sortMulti(coll :: LIST, orderFields = [] :: LIST, limit = -1 :: INTEGER, skip = 0 :: INTEGER) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.coll.sortNodes': { - label: 'apoc.coll.sortNodes', - documentation: + name: 'apoc.coll.sortNodes', + category: '', + description: 'Sorts the given `LIST` by the property of the nodes into descending order.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'coll', - documentation: 'coll :: LIST', + isDeprecated: false, + description: 'coll :: LIST', + name: 'coll', + type: 'LIST', }, { - label: 'prop', - documentation: 'prop :: STRING', + isDeprecated: false, + description: 'prop :: STRING', + name: 'prop', + type: 'STRING', }, ], + signature: + 'apoc.coll.sortNodes(coll :: LIST, prop :: STRING) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.coll.sortText': { - label: 'apoc.coll.sortText', - documentation: 'Sorts the given `LIST` into ascending order.', - parameters: [ + name: 'apoc.coll.sortText', + category: '', + description: 'Sorts the given `LIST` into ascending order.', + isBuiltIn: false, + argumentDescription: [ { - label: 'coll', - documentation: 'coll :: LIST', + isDeprecated: false, + description: 'coll :: LIST', + name: 'coll', + type: 'LIST', }, { - label: 'conf', - documentation: 'conf = {} :: MAP', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'conf = {} :: MAP', + name: 'conf', + type: 'MAP', }, ], + signature: + 'apoc.coll.sortText(coll :: LIST, conf = {} :: MAP) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.coll.stdev': { - label: 'apoc.coll.stdev', - documentation: + name: 'apoc.coll.stdev', + category: '', + description: 'Returns sample or population standard deviation with `isBiasCorrected` true or false respectively.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'list', - documentation: 'list :: LIST', + isDeprecated: false, + description: 'list :: LIST', + name: 'list', + type: 'LIST', }, { - label: 'isBiasCorrected', - documentation: 'isBiasCorrected = true :: BOOLEAN', + isDeprecated: false, + default: 'DefaultParameterValue{value=true, type=BOOLEAN}', + description: 'isBiasCorrected = true :: BOOLEAN', + name: 'isBiasCorrected', + type: 'BOOLEAN', }, ], + signature: + 'apoc.coll.stdev(list :: LIST, isBiasCorrected = true :: BOOLEAN) :: INTEGER | FLOAT', + returnDescription: 'INTEGER | FLOAT', + aggregating: false, }, 'apoc.coll.subtract': { - label: 'apoc.coll.subtract', - documentation: + name: 'apoc.coll.subtract', + category: '', + description: 'Returns the first `LIST` as a set with all the elements of the second `LIST` removed.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'list1', - documentation: 'list1 :: LIST', + isDeprecated: false, + description: 'list1 :: LIST', + name: 'list1', + type: 'LIST', }, { - label: 'list2', - documentation: 'list2 :: LIST', + isDeprecated: false, + description: 'list2 :: LIST', + name: 'list2', + type: 'LIST', }, ], + signature: + 'apoc.coll.subtract(list1 :: LIST, list2 :: LIST) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.coll.sum': { - label: 'apoc.coll.sum', - documentation: + name: 'apoc.coll.sum', + category: '', + description: 'Returns the sum of all the `INTEGER | FLOAT` in the `LIST`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'coll', - documentation: 'coll :: LIST', + isDeprecated: false, + description: 'coll :: LIST', + name: 'coll', + type: 'LIST', }, ], + signature: 'apoc.coll.sum(coll :: LIST) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, 'apoc.coll.sumLongs': { - label: 'apoc.coll.sumLongs', - documentation: + name: 'apoc.coll.sumLongs', + category: '', + description: 'Returns the sum of all the `INTEGER | FLOAT` in the `LIST`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'coll', - documentation: 'coll :: LIST', + isDeprecated: false, + description: 'coll :: LIST', + name: 'coll', + type: 'LIST', }, ], + signature: 'apoc.coll.sumLongs(coll :: LIST) :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, 'apoc.coll.toSet': { - label: 'apoc.coll.toSet', - documentation: 'Returns a unique `LIST` from the given `LIST`.', - parameters: [ + name: 'apoc.coll.toSet', + category: '', + description: 'Returns a unique `LIST` from the given `LIST`.', + isBuiltIn: false, + argumentDescription: [ { - label: 'coll', - documentation: 'coll :: LIST', + isDeprecated: false, + description: 'coll :: LIST', + name: 'coll', + type: 'LIST', }, ], + signature: 'apoc.coll.toSet(coll :: LIST) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.coll.union': { - label: 'apoc.coll.union', - documentation: + name: 'apoc.coll.union', + category: '', + description: 'Returns the distinct union of the two given `LIST` values.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'list1', - documentation: 'list1 :: LIST', + isDeprecated: false, + description: 'list1 :: LIST', + name: 'list1', + type: 'LIST', }, { - label: 'list2', - documentation: 'list2 :: LIST', + isDeprecated: false, + description: 'list2 :: LIST', + name: 'list2', + type: 'LIST', }, ], + signature: + 'apoc.coll.union(list1 :: LIST, list2 :: LIST) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.coll.unionAll': { - label: 'apoc.coll.unionAll', - documentation: + name: 'apoc.coll.unionAll', + category: '', + description: 'Returns the full union of the two given `LIST` values (duplicates included).', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'list1', - documentation: 'list1 :: LIST', + isDeprecated: false, + description: 'list1 :: LIST', + name: 'list1', + type: 'LIST', }, { - label: 'list2', - documentation: 'list2 :: LIST', + isDeprecated: false, + description: 'list2 :: LIST', + name: 'list2', + type: 'LIST', }, ], + signature: + 'apoc.coll.unionAll(list1 :: LIST, list2 :: LIST) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.coll.zip': { - label: 'apoc.coll.zip', - documentation: + name: 'apoc.coll.zip', + category: '', + description: 'Returns the two given `LIST` values zipped together as a `LIST>`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'list1', - documentation: 'list1 :: LIST', + isDeprecated: false, + description: 'list1 :: LIST', + name: 'list1', + type: 'LIST', }, { - label: 'list2', - documentation: 'list2 :: LIST', + isDeprecated: false, + description: 'list2 :: LIST', + name: 'list2', + type: 'LIST', }, ], + signature: + 'apoc.coll.zip(list1 :: LIST, list2 :: LIST) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.convert.fromJsonList': { - label: 'apoc.convert.fromJsonList', - documentation: - 'Converts the given JSON list into a Cypher `LIST`.', - parameters: [ + name: 'apoc.convert.fromJsonList', + category: '', + description: 'Converts the given JSON list into a Cypher `LIST`.', + isBuiltIn: false, + argumentDescription: [ { - label: 'list', - documentation: 'list :: STRING', + isDeprecated: false, + description: 'list :: STRING', + name: 'list', + type: 'STRING', }, { - label: 'path', - documentation: 'path = :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'path = :: STRING', + name: 'path', + type: 'STRING', }, { - label: 'pathOptions', - documentation: 'pathOptions = null :: LIST', + isDeprecated: false, + default: 'DefaultParameterValue{value=null, type=LIST}', + description: 'pathOptions = null :: LIST', + name: 'pathOptions', + type: 'LIST', }, ], + signature: + 'apoc.convert.fromJsonList(list :: STRING, path = :: STRING, pathOptions = null :: LIST) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.convert.fromJsonMap': { - label: 'apoc.convert.fromJsonMap', - documentation: 'Converts the given JSON map into a Cypher `MAP`.', - parameters: [ + name: 'apoc.convert.fromJsonMap', + category: '', + description: 'Converts the given JSON map into a Cypher `MAP`.', + isBuiltIn: false, + argumentDescription: [ { - label: 'map', - documentation: 'map :: STRING', + isDeprecated: false, + description: 'map :: STRING', + name: 'map', + type: 'STRING', }, { - label: 'path', - documentation: 'path = :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'path = :: STRING', + name: 'path', + type: 'STRING', }, { - label: 'pathOptions', - documentation: 'pathOptions = null :: LIST', + isDeprecated: false, + default: 'DefaultParameterValue{value=null, type=LIST}', + description: 'pathOptions = null :: LIST', + name: 'pathOptions', + type: 'LIST', }, ], + signature: + 'apoc.convert.fromJsonMap(map :: STRING, path = :: STRING, pathOptions = null :: LIST) :: MAP', + returnDescription: 'MAP', + aggregating: false, }, 'apoc.convert.getJsonProperty': { - label: 'apoc.convert.getJsonProperty', - documentation: + name: 'apoc.convert.getJsonProperty', + category: '', + description: 'Converts a serialized JSON object from the property of the given `NODE` into the equivalent Cypher structure (e.g. `MAP`, `LIST`).', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'node', - documentation: 'node :: NODE', + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', }, { - label: 'key', - documentation: 'key :: STRING', + isDeprecated: false, + description: 'key :: STRING', + name: 'key', + type: 'STRING', }, { - label: 'path', - documentation: 'path = :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'path = :: STRING', + name: 'path', + type: 'STRING', }, { - label: 'pathOptions', - documentation: 'pathOptions = null :: LIST', + isDeprecated: false, + default: 'DefaultParameterValue{value=null, type=LIST}', + description: 'pathOptions = null :: LIST', + name: 'pathOptions', + type: 'LIST', }, ], + signature: + 'apoc.convert.getJsonProperty(node :: NODE, key :: STRING, path = :: STRING, pathOptions = null :: LIST) :: ANY', + returnDescription: 'ANY', + aggregating: false, }, 'apoc.convert.getJsonPropertyMap': { - label: 'apoc.convert.getJsonPropertyMap', - documentation: + name: 'apoc.convert.getJsonPropertyMap', + category: '', + description: 'Converts a serialized JSON object from the property of the given `NODE` into a Cypher `MAP`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'node', - documentation: 'node :: NODE', + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', }, { - label: 'key', - documentation: 'key :: STRING', + isDeprecated: false, + description: 'key :: STRING', + name: 'key', + type: 'STRING', }, { - label: 'path', - documentation: 'path = :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'path = :: STRING', + name: 'path', + type: 'STRING', }, { - label: 'pathOptions', - documentation: 'pathOptions = null :: LIST', + isDeprecated: false, + default: 'DefaultParameterValue{value=null, type=LIST}', + description: 'pathOptions = null :: LIST', + name: 'pathOptions', + type: 'LIST', }, ], + signature: + 'apoc.convert.getJsonPropertyMap(node :: NODE, key :: STRING, path = :: STRING, pathOptions = null :: LIST) :: MAP', + returnDescription: 'MAP', + aggregating: false, }, 'apoc.convert.toJson': { - label: 'apoc.convert.toJson', - documentation: 'Serializes the given JSON value.', - parameters: [ + name: 'apoc.convert.toJson', + category: '', + description: 'Serializes the given JSON value.', + isBuiltIn: false, + argumentDescription: [ { - label: 'value', - documentation: 'value :: ANY', + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', }, ], + signature: 'apoc.convert.toJson(value :: ANY) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.convert.toList': { - label: 'apoc.convert.toList', - documentation: 'Converts the given value into a `LIST`.', - parameters: [ + name: 'apoc.convert.toList', + category: '', + description: 'Converts the given value into a `LIST`.', + isBuiltIn: false, + argumentDescription: [ { - label: 'value', - documentation: 'value :: ANY', + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', }, ], + signature: 'apoc.convert.toList(value :: ANY) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.convert.toMap': { - label: 'apoc.convert.toMap', - documentation: 'Converts the given value into a `MAP`.', - parameters: [ + name: 'apoc.convert.toMap', + category: '', + description: 'Converts the given value into a `MAP`.', + isBuiltIn: false, + argumentDescription: [ { - label: 'map', - documentation: 'map :: ANY', + isDeprecated: false, + description: 'map :: ANY', + name: 'map', + type: 'ANY', }, ], + signature: 'apoc.convert.toMap(map :: ANY) :: MAP', + returnDescription: 'MAP', + aggregating: false, }, 'apoc.convert.toNode': { - label: 'apoc.convert.toNode', - documentation: 'Converts the given value into a `NODE`.', - parameters: [ + name: 'apoc.convert.toNode', + category: '', + description: 'Converts the given value into a `NODE`.', + isBuiltIn: false, + argumentDescription: [ { - label: 'node', - documentation: 'node :: ANY', + isDeprecated: false, + description: 'node :: ANY', + name: 'node', + type: 'ANY', }, ], + signature: 'apoc.convert.toNode(node :: ANY) :: NODE', + returnDescription: 'NODE', + aggregating: false, }, 'apoc.convert.toNodeList': { - label: 'apoc.convert.toNodeList', - documentation: 'Converts the given value into a `LIST`.', - parameters: [ + name: 'apoc.convert.toNodeList', + category: '', + description: 'Converts the given value into a `LIST`.', + isBuiltIn: false, + argumentDescription: [ { - label: 'list', - documentation: 'list :: ANY', + isDeprecated: false, + description: 'list :: ANY', + name: 'list', + type: 'ANY', }, ], + signature: 'apoc.convert.toNodeList(list :: ANY) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.convert.toRelationship': { - label: 'apoc.convert.toRelationship', - documentation: 'Converts the given value into a `RELATIONSHIP`.', - parameters: [ + name: 'apoc.convert.toRelationship', + category: '', + description: 'Converts the given value into a `RELATIONSHIP`.', + isBuiltIn: false, + argumentDescription: [ { - label: 'rel', - documentation: 'rel :: ANY', + isDeprecated: false, + description: 'rel :: ANY', + name: 'rel', + type: 'ANY', }, ], + signature: 'apoc.convert.toRelationship(rel :: ANY) :: RELATIONSHIP', + returnDescription: 'RELATIONSHIP', + aggregating: false, }, 'apoc.convert.toRelationshipList': { - label: 'apoc.convert.toRelationshipList', - documentation: 'Converts the given value into a `LIST`.', - parameters: [ + name: 'apoc.convert.toRelationshipList', + category: '', + description: 'Converts the given value into a `LIST`.', + isBuiltIn: false, + argumentDescription: [ { - label: 'relList', - documentation: 'relList :: ANY', + isDeprecated: false, + description: 'relList :: ANY', + name: 'relList', + type: 'ANY', }, ], + signature: 'apoc.convert.toRelationshipList(relList :: ANY) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.convert.toSet': { - label: 'apoc.convert.toSet', - documentation: + name: 'apoc.convert.toSet', + category: '', + description: 'Converts the given value into a set represented in Cypher as a `LIST`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'list', - documentation: 'list :: ANY', + isDeprecated: false, + description: 'list :: ANY', + name: 'list', + type: 'ANY', }, ], + signature: 'apoc.convert.toSet(list :: ANY) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.convert.toSortedJsonMap': { - label: 'apoc.convert.toSortedJsonMap', - documentation: + name: 'apoc.convert.toSortedJsonMap', + category: '', + description: 'Converts a serialized JSON object from the property of a given `NODE` into a Cypher `MAP`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'value', - documentation: 'value :: ANY', + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', }, { - label: 'ignoreCase', - documentation: 'ignoreCase = true :: BOOLEAN', + isDeprecated: false, + default: 'DefaultParameterValue{value=true, type=BOOLEAN}', + description: 'ignoreCase = true :: BOOLEAN', + name: 'ignoreCase', + type: 'BOOLEAN', }, ], + signature: + 'apoc.convert.toSortedJsonMap(value :: ANY, ignoreCase = true :: BOOLEAN) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.create.uuid': { - label: 'apoc.create.uuid', - documentation: 'Returns a UUID.', - parameters: [], + name: 'apoc.create.uuid', + category: '', + description: 'Returns a UUID.', + isBuiltIn: false, + argumentDescription: [], + signature: 'apoc.create.uuid() :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.create.uuidBase64': { - label: 'apoc.create.uuidBase64', - documentation: 'Returns a UUID encoded with base64.', - parameters: [], + name: 'apoc.create.uuidBase64', + category: '', + description: 'Returns a UUID encoded with base64.', + isBuiltIn: false, + argumentDescription: [], + signature: 'apoc.create.uuidBase64() :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.create.uuidBase64ToHex': { - label: 'apoc.create.uuidBase64ToHex', - documentation: + name: 'apoc.create.uuidBase64ToHex', + category: '', + description: 'Takes the given base64 encoded UUID and returns it as a hexadecimal `STRING`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'base64Uuid', - documentation: 'base64Uuid :: STRING', + isDeprecated: false, + description: 'base64Uuid :: STRING', + name: 'base64Uuid', + type: 'STRING', }, ], + signature: 'apoc.create.uuidBase64ToHex(base64Uuid :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.create.uuidHexToBase64': { - label: 'apoc.create.uuidHexToBase64', - documentation: + name: 'apoc.create.uuidHexToBase64', + category: '', + description: 'Takes the given UUID represented as a hexadecimal `STRING` and returns it encoded with base64.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'uuid', - documentation: 'uuid :: STRING', + isDeprecated: false, + description: 'uuid :: STRING', + name: 'uuid', + type: 'STRING', }, ], + signature: 'apoc.create.uuidHexToBase64(uuid :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.create.vNode': { - label: 'apoc.create.vNode', - documentation: 'Returns a virtual `NODE`.', - parameters: [ + name: 'apoc.create.vNode', + category: '', + description: 'Returns a virtual `NODE`.', + isBuiltIn: false, + argumentDescription: [ { - label: 'labels', - documentation: 'labels :: LIST', + isDeprecated: false, + description: 'labels :: LIST', + name: 'labels', + type: 'LIST', }, { - label: 'props', - documentation: 'props = {} :: MAP', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'props = {} :: MAP', + name: 'props', + type: 'MAP', }, ], + signature: + 'apoc.create.vNode(labels :: LIST, props = {} :: MAP) :: NODE', + returnDescription: 'NODE', + aggregating: false, }, 'apoc.create.vRelationship': { - label: 'apoc.create.vRelationship', - documentation: 'Returns a virtual `RELATIONSHIP`.', - parameters: [ + name: 'apoc.create.vRelationship', + category: '', + description: 'Returns a virtual `RELATIONSHIP`.', + isBuiltIn: false, + argumentDescription: [ { - label: 'from', - documentation: 'from :: NODE', + isDeprecated: false, + description: 'from :: NODE', + name: 'from', + type: 'NODE', }, { - label: 'relType', - documentation: 'relType :: STRING', + isDeprecated: false, + description: 'relType :: STRING', + name: 'relType', + type: 'STRING', }, { - label: 'props', - documentation: 'props :: MAP', + isDeprecated: false, + description: 'props :: MAP', + name: 'props', + type: 'MAP', }, { - label: 'to', - documentation: 'to :: NODE', + isDeprecated: false, + description: 'to :: NODE', + name: 'to', + type: 'NODE', }, ], + signature: + 'apoc.create.vRelationship(from :: NODE, relType :: STRING, props :: MAP, to :: NODE) :: RELATIONSHIP', + returnDescription: 'RELATIONSHIP', + aggregating: false, }, 'apoc.create.virtual.fromNode': { - label: 'apoc.create.virtual.fromNode', - documentation: + name: 'apoc.create.virtual.fromNode', + category: '', + description: 'Returns a virtual `NODE` from the given existing `NODE`. The virtual `NODE` only contains the requested properties.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'node', - documentation: 'node :: NODE', + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', }, { - label: 'propertyNames', - documentation: 'propertyNames :: LIST', + isDeprecated: false, + description: 'propertyNames :: LIST', + name: 'propertyNames', + type: 'LIST', }, ], + signature: + 'apoc.create.virtual.fromNode(node :: NODE, propertyNames :: LIST) :: NODE', + returnDescription: 'NODE', + aggregating: false, }, 'apoc.cypher.runFirstColumnMany': { - label: 'apoc.cypher.runFirstColumnMany', - documentation: + name: 'apoc.cypher.runFirstColumnMany', + category: '', + description: 'Runs the given statement with the given parameters and returns the first column collected into a `LIST`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'statement', - documentation: 'statement :: STRING', + isDeprecated: false, + description: 'statement :: STRING', + name: 'statement', + type: 'STRING', }, { - label: 'params', - documentation: 'params :: MAP', + isDeprecated: false, + description: 'params :: MAP', + name: 'params', + type: 'MAP', }, ], + signature: + 'apoc.cypher.runFirstColumnMany(statement :: STRING, params :: MAP) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.cypher.runFirstColumnSingle': { - label: 'apoc.cypher.runFirstColumnSingle', - documentation: + name: 'apoc.cypher.runFirstColumnSingle', + category: '', + description: 'Runs the given statement with the given parameters and returns the first element of the first column.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'statement', - documentation: 'statement :: STRING', + isDeprecated: false, + description: 'statement :: STRING', + name: 'statement', + type: 'STRING', }, { - label: 'params', - documentation: 'params :: MAP', + isDeprecated: false, + description: 'params :: MAP', + name: 'params', + type: 'MAP', }, ], + signature: + 'apoc.cypher.runFirstColumnSingle(statement :: STRING, params :: MAP) :: ANY', + returnDescription: 'ANY', + aggregating: false, }, 'apoc.data.url': { - label: 'apoc.data.url', - documentation: 'Turns a URL into a `MAP`.', - parameters: [ + name: 'apoc.data.url', + category: '', + description: 'Turns a URL into a `MAP`.', + isBuiltIn: false, + argumentDescription: [ { - label: 'url', - documentation: 'url :: STRING', + isDeprecated: false, + description: 'url :: STRING', + name: 'url', + type: 'STRING', }, ], + signature: 'apoc.data.url(url :: STRING) :: MAP', + returnDescription: 'MAP', + aggregating: false, }, 'apoc.date.add': { - label: 'apoc.date.add', - documentation: 'Adds a unit of specified time to the given timestamp.', - parameters: [ + name: 'apoc.date.add', + category: '', + description: 'Adds a unit of specified time to the given timestamp.', + isBuiltIn: false, + argumentDescription: [ { - label: 'time', - documentation: 'time :: INTEGER', + isDeprecated: false, + description: 'time :: INTEGER', + name: 'time', + type: 'INTEGER', }, { - label: 'unit', - documentation: 'unit :: STRING', + isDeprecated: false, + description: 'unit :: STRING', + name: 'unit', + type: 'STRING', }, { - label: 'addValue', - documentation: 'addValue :: INTEGER', + isDeprecated: false, + description: 'addValue :: INTEGER', + name: 'addValue', + type: 'INTEGER', }, { - label: 'addUnit', - documentation: 'addUnit :: STRING', + isDeprecated: false, + description: 'addUnit :: STRING', + name: 'addUnit', + type: 'STRING', }, ], + signature: + 'apoc.date.add(time :: INTEGER, unit :: STRING, addValue :: INTEGER, addUnit :: STRING) :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, 'apoc.date.convert': { - label: 'apoc.date.convert', - documentation: + name: 'apoc.date.convert', + category: '', + description: 'Converts the given timestamp from one time unit into a timestamp of a different time unit.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'time', - documentation: 'time :: INTEGER', + isDeprecated: false, + description: 'time :: INTEGER', + name: 'time', + type: 'INTEGER', }, { - label: 'unit', - documentation: 'unit :: STRING', + isDeprecated: false, + description: 'unit :: STRING', + name: 'unit', + type: 'STRING', }, { - label: 'toUnit', - documentation: 'toUnit :: STRING', + isDeprecated: false, + description: 'toUnit :: STRING', + name: 'toUnit', + type: 'STRING', }, ], + signature: + 'apoc.date.convert(time :: INTEGER, unit :: STRING, toUnit :: STRING) :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, 'apoc.date.convertFormat': { - label: 'apoc.date.convertFormat', - documentation: + name: 'apoc.date.convertFormat', + category: '', + description: 'Converts a `STRING` of one type of date format into a `STRING` of another type of date format.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'temporal', - documentation: 'temporal :: STRING', + isDeprecated: false, + description: 'temporal :: STRING', + name: 'temporal', + type: 'STRING', }, { - label: 'currentFormat', - documentation: 'currentFormat :: STRING', + isDeprecated: false, + description: 'currentFormat :: STRING', + name: 'currentFormat', + type: 'STRING', }, { - label: 'convertTo', - documentation: 'convertTo = yyyy-MM-dd :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=yyyy-MM-dd, type=STRING}', + description: 'convertTo = yyyy-MM-dd :: STRING', + name: 'convertTo', + type: 'STRING', }, ], + signature: + 'apoc.date.convertFormat(temporal :: STRING, currentFormat :: STRING, convertTo = yyyy-MM-dd :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.date.currentTimestamp': { - label: 'apoc.date.currentTimestamp', - documentation: - 'Returns the current Unix epoch timestamp in milliseconds.', - parameters: [], + name: 'apoc.date.currentTimestamp', + category: '', + description: 'Returns the current Unix epoch timestamp in milliseconds.', + isBuiltIn: false, + argumentDescription: [], + signature: 'apoc.date.currentTimestamp() :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, 'apoc.date.field': { - label: 'apoc.date.field', - documentation: 'Returns the value of one field from the given date time.', - parameters: [ + name: 'apoc.date.field', + category: '', + description: 'Returns the value of one field from the given date time.', + isBuiltIn: false, + argumentDescription: [ { - label: 'time', - documentation: 'time :: INTEGER', + isDeprecated: false, + description: 'time :: INTEGER', + name: 'time', + type: 'INTEGER', }, { - label: 'unit', - documentation: 'unit = d :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=d, type=STRING}', + description: 'unit = d :: STRING', + name: 'unit', + type: 'STRING', }, { - label: 'timezone', - documentation: 'timezone = UTC :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=UTC, type=STRING}', + description: 'timezone = UTC :: STRING', + name: 'timezone', + type: 'STRING', }, ], + signature: + 'apoc.date.field(time :: INTEGER, unit = d :: STRING, timezone = UTC :: STRING) :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, 'apoc.date.fields': { - label: 'apoc.date.fields', - documentation: + name: 'apoc.date.fields', + category: '', + description: 'Splits the given date into fields returning a `MAP` containing the values of each field.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'date', - documentation: 'date :: STRING', + isDeprecated: false, + description: 'date :: STRING', + name: 'date', + type: 'STRING', }, { - label: 'pattern', - documentation: 'pattern = yyyy-MM-dd HH:mm:ss :: STRING', + isDeprecated: false, + default: + 'DefaultParameterValue{value=yyyy-MM-dd HH:mm:ss, type=STRING}', + description: 'pattern = yyyy-MM-dd HH:mm:ss :: STRING', + name: 'pattern', + type: 'STRING', }, ], + signature: + 'apoc.date.fields(date :: STRING, pattern = yyyy-MM-dd HH:mm:ss :: STRING) :: MAP', + returnDescription: 'MAP', + aggregating: false, }, 'apoc.date.format': { - label: 'apoc.date.format', - documentation: + name: 'apoc.date.format', + category: '', + description: 'Returns a `STRING` representation of the time value.\nThe time unit (default: ms), date format (default: ISO), and time zone (default: current time zone) can all be changed.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'time', - documentation: 'time :: INTEGER', + isDeprecated: false, + description: 'time :: INTEGER', + name: 'time', + type: 'INTEGER', }, { - label: 'unit', - documentation: 'unit = ms :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=ms, type=STRING}', + description: 'unit = ms :: STRING', + name: 'unit', + type: 'STRING', }, { - label: 'format', - documentation: 'format = yyyy-MM-dd HH:mm:ss :: STRING', + isDeprecated: false, + default: + 'DefaultParameterValue{value=yyyy-MM-dd HH:mm:ss, type=STRING}', + description: 'format = yyyy-MM-dd HH:mm:ss :: STRING', + name: 'format', + type: 'STRING', }, { - label: 'timezone', - documentation: 'timezone = :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'timezone = :: STRING', + name: 'timezone', + type: 'STRING', }, ], + signature: + 'apoc.date.format(time :: INTEGER, unit = ms :: STRING, format = yyyy-MM-dd HH:mm:ss :: STRING, timezone = :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.date.fromISO8601': { - label: 'apoc.date.fromISO8601', - documentation: + name: 'apoc.date.fromISO8601', + category: '', + description: 'Converts the given date `STRING` (ISO8601) to an `INTEGER` representing the time value in milliseconds.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'time', - documentation: 'time :: STRING', + isDeprecated: false, + description: 'time :: STRING', + name: 'time', + type: 'STRING', }, ], + signature: 'apoc.date.fromISO8601(time :: STRING) :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, 'apoc.date.parse': { - label: 'apoc.date.parse', - documentation: + name: 'apoc.date.parse', + category: '', + description: 'Parses the given date `STRING` from a specified format into the specified time unit.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'time', - documentation: 'time :: STRING', + isDeprecated: false, + description: 'time :: STRING', + name: 'time', + type: 'STRING', }, { - label: 'unit', - documentation: 'unit = ms :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=ms, type=STRING}', + description: 'unit = ms :: STRING', + name: 'unit', + type: 'STRING', }, { - label: 'format', - documentation: 'format = yyyy-MM-dd HH:mm:ss :: STRING', + isDeprecated: false, + default: + 'DefaultParameterValue{value=yyyy-MM-dd HH:mm:ss, type=STRING}', + description: 'format = yyyy-MM-dd HH:mm:ss :: STRING', + name: 'format', + type: 'STRING', }, { - label: 'timezone', - documentation: 'timezone = :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'timezone = :: STRING', + name: 'timezone', + type: 'STRING', }, ], + signature: + 'apoc.date.parse(time :: STRING, unit = ms :: STRING, format = yyyy-MM-dd HH:mm:ss :: STRING, timezone = :: STRING) :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, 'apoc.date.systemTimezone': { - label: 'apoc.date.systemTimezone', - documentation: + name: 'apoc.date.systemTimezone', + category: '', + description: 'Returns the display name of the system time zone (e.g. Europe/London).', - parameters: [], + isBuiltIn: false, + argumentDescription: [], + signature: 'apoc.date.systemTimezone() :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.date.toISO8601': { - label: 'apoc.date.toISO8601', - documentation: + name: 'apoc.date.toISO8601', + category: '', + description: 'Returns a `STRING` representation of a specified time value in the ISO8601 format.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'time', - documentation: 'time :: INTEGER', + isDeprecated: false, + description: 'time :: INTEGER', + name: 'time', + type: 'INTEGER', }, { - label: 'unit', - documentation: 'unit = ms :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=ms, type=STRING}', + description: 'unit = ms :: STRING', + name: 'unit', + type: 'STRING', }, ], + signature: + 'apoc.date.toISO8601(time :: INTEGER, unit = ms :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.date.toYears': { - label: 'apoc.date.toYears', - documentation: + name: 'apoc.date.toYears', + category: '', + description: 'Converts the given timestamp or the given date into a `FLOAT` representing years.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'value', - documentation: 'value :: ANY', + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', }, { - label: 'format', - documentation: 'format = yyyy-MM-dd HH:mm:ss :: STRING', + isDeprecated: false, + default: + 'DefaultParameterValue{value=yyyy-MM-dd HH:mm:ss, type=STRING}', + description: 'format = yyyy-MM-dd HH:mm:ss :: STRING', + name: 'format', + type: 'STRING', }, ], + signature: + 'apoc.date.toYears(value :: ANY, format = yyyy-MM-dd HH:mm:ss :: STRING) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, 'apoc.diff.nodes': { - label: 'apoc.diff.nodes', - documentation: + name: 'apoc.diff.nodes', + category: '', + description: 'Returns a `MAP` detailing the differences between the two given `NODE` values.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'leftNode', - documentation: 'leftNode :: NODE', + isDeprecated: false, + description: 'leftNode :: NODE', + name: 'leftNode', + type: 'NODE', }, { - label: 'rightNode', - documentation: 'rightNode :: NODE', + isDeprecated: false, + description: 'rightNode :: NODE', + name: 'rightNode', + type: 'NODE', }, ], + signature: 'apoc.diff.nodes(leftNode :: NODE, rightNode :: NODE) :: MAP', + returnDescription: 'MAP', + aggregating: false, }, 'apoc.hashing.fingerprint': { - label: 'apoc.hashing.fingerprint', - documentation: + name: 'apoc.hashing.fingerprint', + category: '', + description: 'Calculates a MD5 checksum over a `NODE` or `RELATIONSHIP` (identical entities share the same checksum).\nUnsuitable for cryptographic use-cases.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'object', - documentation: 'object :: ANY', + isDeprecated: false, + description: 'object :: ANY', + name: 'object', + type: 'ANY', }, { - label: 'excludedPropertyKeys', - documentation: 'excludedPropertyKeys = [] :: LIST', + isDeprecated: false, + default: 'DefaultParameterValue{value=[], type=LIST}', + description: 'excludedPropertyKeys = [] :: LIST', + name: 'excludedPropertyKeys', + type: 'LIST', }, ], + signature: + 'apoc.hashing.fingerprint(object :: ANY, excludedPropertyKeys = [] :: LIST) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.hashing.fingerprintGraph': { - label: 'apoc.hashing.fingerprintGraph', - documentation: + name: 'apoc.hashing.fingerprintGraph', + category: '', + description: 'Calculates a MD5 checksum over the full graph.\nThis function uses in-memory data structures.\nUnsuitable for cryptographic use-cases.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'propertyExcludes', - documentation: 'propertyExcludes = [] :: LIST', + isDeprecated: false, + default: 'DefaultParameterValue{value=[], type=LIST}', + description: 'propertyExcludes = [] :: LIST', + name: 'propertyExcludes', + type: 'LIST', }, ], + signature: + 'apoc.hashing.fingerprintGraph(propertyExcludes = [] :: LIST) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.hashing.fingerprinting': { - label: 'apoc.hashing.fingerprinting', - documentation: + name: 'apoc.hashing.fingerprinting', + category: '', + description: 'Calculates a MD5 checksum over a `NODE` or `RELATIONSHIP` (identical entities share the same checksum).\nUnlike `apoc.hashing.fingerprint()`, this function supports a number of config parameters.\nUnsuitable for cryptographic use-cases.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'object', - documentation: 'object :: ANY', + isDeprecated: false, + description: 'object :: ANY', + name: 'object', + type: 'ANY', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', }, ], + signature: + 'apoc.hashing.fingerprinting(object :: ANY, config = {} :: MAP) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.json.path': { - label: 'apoc.json.path', - documentation: 'Returns the given JSON path.', - parameters: [ + name: 'apoc.json.path', + category: '', + description: 'Returns the given JSON path.', + isBuiltIn: false, + argumentDescription: [ { - label: 'json', - documentation: 'json :: STRING', + isDeprecated: false, + description: 'json :: STRING', + name: 'json', + type: 'STRING', }, { - label: 'path', - documentation: 'path = $ :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=$, type=STRING}', + description: 'path = $ :: STRING', + name: 'path', + type: 'STRING', }, { - label: 'pathOptions', - documentation: 'pathOptions = null :: LIST', + isDeprecated: false, + default: 'DefaultParameterValue{value=null, type=LIST}', + description: 'pathOptions = null :: LIST', + name: 'pathOptions', + type: 'LIST', }, ], + signature: + 'apoc.json.path(json :: STRING, path = $ :: STRING, pathOptions = null :: LIST) :: ANY', + returnDescription: 'ANY', + aggregating: false, }, 'apoc.label.exists': { - label: 'apoc.label.exists', - documentation: + name: 'apoc.label.exists', + category: '', + description: 'Returns true or false depending on whether or not the given label exists.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'node', - documentation: 'node :: ANY', + isDeprecated: false, + description: 'node :: ANY', + name: 'node', + type: 'ANY', }, { - label: 'label', - documentation: 'label :: STRING', + isDeprecated: false, + description: 'label :: STRING', + name: 'label', + type: 'STRING', }, ], + signature: 'apoc.label.exists(node :: ANY, label :: STRING) :: BOOLEAN', + returnDescription: 'BOOLEAN', + aggregating: false, }, 'apoc.map.clean': { - label: 'apoc.map.clean', - documentation: + name: 'apoc.map.clean', + category: '', + description: 'Filters the keys and values contained in the given `LIST` values.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'map', - documentation: 'map :: MAP', + isDeprecated: false, + description: 'map :: MAP', + name: 'map', + type: 'MAP', }, { - label: 'keys', - documentation: 'keys :: LIST', + isDeprecated: false, + description: 'keys :: LIST', + name: 'keys', + type: 'LIST', }, { - label: 'values', - documentation: 'values :: LIST', + isDeprecated: false, + description: 'values :: LIST', + name: 'values', + type: 'LIST', }, ], + signature: + 'apoc.map.clean(map :: MAP, keys :: LIST, values :: LIST) :: MAP', + returnDescription: 'MAP', + aggregating: false, }, 'apoc.map.flatten': { - label: 'apoc.map.flatten', - documentation: + name: 'apoc.map.flatten', + category: '', + description: 'Flattens nested items in the given `MAP`.\nThis function is the reverse of the `apoc.map.unflatten` function.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'map', - documentation: 'map :: MAP', + isDeprecated: false, + description: 'map :: MAP', + name: 'map', + type: 'MAP', }, { - label: 'delimiter', - documentation: 'delimiter = . :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=., type=STRING}', + description: 'delimiter = . :: STRING', + name: 'delimiter', + type: 'STRING', }, ], + signature: 'apoc.map.flatten(map :: MAP, delimiter = . :: STRING) :: MAP', + returnDescription: 'MAP', + aggregating: false, }, 'apoc.map.fromLists': { - label: 'apoc.map.fromLists', - documentation: + name: 'apoc.map.fromLists', + category: '', + description: 'Creates a `MAP` from the keys and values in the given `LIST` values.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'keys', - documentation: 'keys :: LIST', + isDeprecated: false, + description: 'keys :: LIST', + name: 'keys', + type: 'LIST', }, { - label: 'values', - documentation: 'values :: LIST', + isDeprecated: false, + description: 'values :: LIST', + name: 'values', + type: 'LIST', }, ], + signature: + 'apoc.map.fromLists(keys :: LIST, values :: LIST) :: MAP', + returnDescription: 'MAP', + aggregating: false, }, 'apoc.map.fromNodes': { - label: 'apoc.map.fromNodes', - documentation: + name: 'apoc.map.fromNodes', + category: '', + description: 'Returns a `MAP` of the given prop to the node of the given label.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'label', - documentation: 'label :: STRING', + isDeprecated: false, + description: 'label :: STRING', + name: 'label', + type: 'STRING', }, { - label: 'prop', - documentation: 'prop :: STRING', + isDeprecated: false, + description: 'prop :: STRING', + name: 'prop', + type: 'STRING', }, ], + signature: 'apoc.map.fromNodes(label :: STRING, prop :: STRING) :: MAP', + returnDescription: 'MAP', + aggregating: false, }, 'apoc.map.fromPairs': { - label: 'apoc.map.fromPairs', - documentation: + name: 'apoc.map.fromPairs', + category: '', + description: 'Creates a `MAP` from the given `LIST>` of key-value pairs.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'pairs', - documentation: 'pairs :: LIST>', + isDeprecated: false, + description: 'pairs :: LIST>', + name: 'pairs', + type: 'LIST>', }, ], + signature: 'apoc.map.fromPairs(pairs :: LIST>) :: MAP', + returnDescription: 'MAP', + aggregating: false, }, 'apoc.map.fromValues': { - label: 'apoc.map.fromValues', - documentation: + name: 'apoc.map.fromValues', + category: '', + description: 'Creates a `MAP` from the alternating keys and values in the given `LIST`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'values', - documentation: 'values :: LIST', + isDeprecated: false, + description: 'values :: LIST', + name: 'values', + type: 'LIST', }, ], + signature: 'apoc.map.fromValues(values :: LIST) :: MAP', + returnDescription: 'MAP', + aggregating: false, }, 'apoc.map.get': { - label: 'apoc.map.get', - documentation: + name: 'apoc.map.get', + category: '', + description: 'Returns a value for the given key.\nIf the given key does not exist, or lacks a default value, this function will throw an exception.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'map', - documentation: 'map :: MAP', + isDeprecated: false, + description: 'map :: MAP', + name: 'map', + type: 'MAP', }, { - label: 'key', - documentation: 'key :: STRING', + isDeprecated: false, + description: 'key :: STRING', + name: 'key', + type: 'STRING', }, { - label: 'value', - documentation: 'value = null :: ANY', + isDeprecated: false, + default: 'DefaultParameterValue{value=null, type=ANY}', + description: 'value = null :: ANY', + name: 'value', + type: 'ANY', }, { - label: 'fail', - documentation: 'fail = true :: BOOLEAN', + isDeprecated: false, + default: 'DefaultParameterValue{value=true, type=BOOLEAN}', + description: 'fail = true :: BOOLEAN', + name: 'fail', + type: 'BOOLEAN', }, ], + signature: + 'apoc.map.get(map :: MAP, key :: STRING, value = null :: ANY, fail = true :: BOOLEAN) :: ANY', + returnDescription: 'ANY', + aggregating: false, }, 'apoc.map.groupBy': { - label: 'apoc.map.groupBy', - documentation: + name: 'apoc.map.groupBy', + category: '', + description: 'Creates a `MAP` of the `LIST` keyed by the given property, with single values.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'values', - documentation: 'values :: LIST', + isDeprecated: false, + description: 'values :: LIST', + name: 'values', + type: 'LIST', }, { - label: 'key', - documentation: 'key :: STRING', + isDeprecated: false, + description: 'key :: STRING', + name: 'key', + type: 'STRING', }, ], + signature: 'apoc.map.groupBy(values :: LIST, key :: STRING) :: MAP', + returnDescription: 'MAP', + aggregating: false, }, 'apoc.map.groupByMulti': { - label: 'apoc.map.groupByMulti', - documentation: + name: 'apoc.map.groupByMulti', + category: '', + description: 'Creates a `MAP` of the `LIST` values keyed by the given property, with the `LIST` values.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'values', - documentation: 'values :: LIST', + isDeprecated: false, + description: 'values :: LIST', + name: 'values', + type: 'LIST', }, { - label: 'key', - documentation: 'key :: STRING', + isDeprecated: false, + description: 'key :: STRING', + name: 'key', + type: 'STRING', }, ], + signature: + 'apoc.map.groupByMulti(values :: LIST, key :: STRING) :: MAP', + returnDescription: 'MAP', + aggregating: false, }, 'apoc.map.merge': { - label: 'apoc.map.merge', - documentation: 'Merges the two given `MAP` values into one `MAP`.', - parameters: [ + name: 'apoc.map.merge', + category: '', + description: 'Merges the two given `MAP` values into one `MAP`.', + isBuiltIn: false, + argumentDescription: [ { - label: 'map1', - documentation: 'map1 :: MAP', + isDeprecated: false, + description: 'map1 :: MAP', + name: 'map1', + type: 'MAP', }, { - label: 'map2', - documentation: 'map2 :: MAP', + isDeprecated: false, + description: 'map2 :: MAP', + name: 'map2', + type: 'MAP', }, ], + signature: 'apoc.map.merge(map1 :: MAP, map2 :: MAP) :: MAP', + returnDescription: 'MAP', + aggregating: false, }, 'apoc.map.mergeList': { - label: 'apoc.map.mergeList', - documentation: + name: 'apoc.map.mergeList', + category: '', + description: 'Merges all `MAP` values in the given `LIST>` into one `MAP`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'maps', - documentation: 'maps :: LIST', + isDeprecated: false, + description: 'maps :: LIST', + name: 'maps', + type: 'LIST', }, ], + signature: 'apoc.map.mergeList(maps :: LIST) :: MAP', + returnDescription: 'MAP', + aggregating: false, }, 'apoc.map.mget': { - label: 'apoc.map.mget', - documentation: + name: 'apoc.map.mget', + category: '', + description: 'Returns a `LIST` for the given keys.\nIf one of the keys does not exist, or lacks a default value, this function will throw an exception.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'map', - documentation: 'map :: MAP', + isDeprecated: false, + description: 'map :: MAP', + name: 'map', + type: 'MAP', }, { - label: 'keys', - documentation: 'keys :: LIST', + isDeprecated: false, + description: 'keys :: LIST', + name: 'keys', + type: 'LIST', }, { - label: 'values', - documentation: 'values = [] :: LIST', + isDeprecated: false, + default: 'DefaultParameterValue{value=[], type=LIST}', + description: 'values = [] :: LIST', + name: 'values', + type: 'LIST', }, { - label: 'fail', - documentation: 'fail = true :: BOOLEAN', + isDeprecated: false, + default: 'DefaultParameterValue{value=true, type=BOOLEAN}', + description: 'fail = true :: BOOLEAN', + name: 'fail', + type: 'BOOLEAN', }, ], + signature: + 'apoc.map.mget(map :: MAP, keys :: LIST, values = [] :: LIST, fail = true :: BOOLEAN) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.map.removeKey': { - label: 'apoc.map.removeKey', - documentation: + name: 'apoc.map.removeKey', + category: '', + description: 'Removes the given key from the `MAP` (recursively if recursive is true).', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'map', - documentation: 'map :: MAP', + isDeprecated: false, + description: 'map :: MAP', + name: 'map', + type: 'MAP', }, { - label: 'key', - documentation: 'key :: STRING', + isDeprecated: false, + description: 'key :: STRING', + name: 'key', + type: 'STRING', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', }, ], + signature: + 'apoc.map.removeKey(map :: MAP, key :: STRING, config = {} :: MAP) :: MAP', + returnDescription: 'MAP', + aggregating: false, }, 'apoc.map.removeKeys': { - label: 'apoc.map.removeKeys', - documentation: + name: 'apoc.map.removeKeys', + category: '', + description: 'Removes the given keys from the `MAP` (recursively if recursive is true).', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'map', - documentation: 'map :: MAP', + isDeprecated: false, + description: 'map :: MAP', + name: 'map', + type: 'MAP', }, { - label: 'keys', - documentation: 'keys :: LIST', + isDeprecated: false, + description: 'keys :: LIST', + name: 'keys', + type: 'LIST', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', }, ], + signature: + 'apoc.map.removeKeys(map :: MAP, keys :: LIST, config = {} :: MAP) :: MAP', + returnDescription: 'MAP', + aggregating: false, }, 'apoc.map.setEntry': { - label: 'apoc.map.setEntry', - documentation: 'Adds or updates the given entry in the `MAP`.', - parameters: [ + name: 'apoc.map.setEntry', + category: '', + description: 'Adds or updates the given entry in the `MAP`.', + isBuiltIn: false, + argumentDescription: [ { - label: 'map', - documentation: 'map :: MAP', + isDeprecated: false, + description: 'map :: MAP', + name: 'map', + type: 'MAP', }, { - label: 'key', - documentation: 'key :: STRING', + isDeprecated: false, + description: 'key :: STRING', + name: 'key', + type: 'STRING', }, { - label: 'value', - documentation: 'value :: ANY', + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', }, ], + signature: + 'apoc.map.setEntry(map :: MAP, key :: STRING, value :: ANY) :: MAP', + returnDescription: 'MAP', + aggregating: false, }, 'apoc.map.setKey': { - label: 'apoc.map.setKey', - documentation: 'Adds or updates the given entry in the `MAP`.', - parameters: [ + name: 'apoc.map.setKey', + category: '', + description: 'Adds or updates the given entry in the `MAP`.', + isBuiltIn: false, + argumentDescription: [ { - label: 'map', - documentation: 'map :: MAP', + isDeprecated: false, + description: 'map :: MAP', + name: 'map', + type: 'MAP', }, { - label: 'key', - documentation: 'key :: STRING', + isDeprecated: false, + description: 'key :: STRING', + name: 'key', + type: 'STRING', }, { - label: 'value', - documentation: 'value :: ANY', + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', }, ], + signature: + 'apoc.map.setKey(map :: MAP, key :: STRING, value :: ANY) :: MAP', + returnDescription: 'MAP', + aggregating: false, }, 'apoc.map.setLists': { - label: 'apoc.map.setLists', - documentation: + name: 'apoc.map.setLists', + category: '', + description: 'Adds or updates the given keys/value pairs provided in `LIST` format (e.g. [key1, key2],[value1, value2]) in a `MAP`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'map', - documentation: 'map :: MAP', + isDeprecated: false, + description: 'map :: MAP', + name: 'map', + type: 'MAP', }, { - label: 'keys', - documentation: 'keys :: LIST', + isDeprecated: false, + description: 'keys :: LIST', + name: 'keys', + type: 'LIST', }, { - label: 'values', - documentation: 'values :: LIST', + isDeprecated: false, + description: 'values :: LIST', + name: 'values', + type: 'LIST', }, ], + signature: + 'apoc.map.setLists(map :: MAP, keys :: LIST, values :: LIST) :: MAP', + returnDescription: 'MAP', + aggregating: false, }, 'apoc.map.setPairs': { - label: 'apoc.map.setPairs', - documentation: + name: 'apoc.map.setPairs', + category: '', + description: 'Adds or updates the given key/value pairs (e.g. [key1,value1],[key2,value2]) in a `MAP`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'map', - documentation: 'map :: MAP', + isDeprecated: false, + description: 'map :: MAP', + name: 'map', + type: 'MAP', }, { - label: 'pairs', - documentation: 'pairs :: LIST>', + isDeprecated: false, + description: 'pairs :: LIST>', + name: 'pairs', + type: 'LIST>', }, ], + signature: + 'apoc.map.setPairs(map :: MAP, pairs :: LIST>) :: MAP', + returnDescription: 'MAP', + aggregating: false, }, 'apoc.map.setValues': { - label: 'apoc.map.setValues', - documentation: + name: 'apoc.map.setValues', + category: '', + description: 'Adds or updates the alternating key/value pairs (e.g. [key1,value1,key2,value2]) in a `MAP`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'map', - documentation: 'map :: MAP', + isDeprecated: false, + description: 'map :: MAP', + name: 'map', + type: 'MAP', }, { - label: 'pairs', - documentation: 'pairs :: LIST', + isDeprecated: false, + description: 'pairs :: LIST', + name: 'pairs', + type: 'LIST', }, ], + signature: 'apoc.map.setValues(map :: MAP, pairs :: LIST) :: MAP', + returnDescription: 'MAP', + aggregating: false, }, 'apoc.map.sortedProperties': { - label: 'apoc.map.sortedProperties', - documentation: + name: 'apoc.map.sortedProperties', + category: '', + description: 'Returns a `LIST` of key/value pairs.\nThe pairs are sorted by alphabetically by key, with optional case sensitivity.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'map', - documentation: 'map :: MAP', + isDeprecated: false, + description: 'map :: MAP', + name: 'map', + type: 'MAP', }, { - label: 'ignoreCase', - documentation: 'ignoreCase = true :: BOOLEAN', + isDeprecated: false, + default: 'DefaultParameterValue{value=true, type=BOOLEAN}', + description: 'ignoreCase = true :: BOOLEAN', + name: 'ignoreCase', + type: 'BOOLEAN', }, ], + signature: + 'apoc.map.sortedProperties(map :: MAP, ignoreCase = true :: BOOLEAN) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.map.submap': { - label: 'apoc.map.submap', - documentation: + name: 'apoc.map.submap', + category: '', + description: 'Returns a sub-map for the given keys.\nIf one of the keys does not exist, or lacks a default value, this function will throw an exception.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'map', - documentation: 'map :: MAP', + isDeprecated: false, + description: 'map :: MAP', + name: 'map', + type: 'MAP', }, { - label: 'keys', - documentation: 'keys :: LIST', + isDeprecated: false, + description: 'keys :: LIST', + name: 'keys', + type: 'LIST', }, { - label: 'values', - documentation: 'values = [] :: LIST', + isDeprecated: false, + default: 'DefaultParameterValue{value=[], type=LIST}', + description: 'values = [] :: LIST', + name: 'values', + type: 'LIST', }, { - label: 'fail', - documentation: 'fail = true :: BOOLEAN', + isDeprecated: false, + default: 'DefaultParameterValue{value=true, type=BOOLEAN}', + description: 'fail = true :: BOOLEAN', + name: 'fail', + type: 'BOOLEAN', }, ], + signature: + 'apoc.map.submap(map :: MAP, keys :: LIST, values = [] :: LIST, fail = true :: BOOLEAN) :: MAP', + returnDescription: 'MAP', + aggregating: false, }, 'apoc.map.unflatten': { - label: 'apoc.map.unflatten', - documentation: + name: 'apoc.map.unflatten', + category: '', + description: 'Unflattens items in the given `MAP` to nested items.\nThis function is the reverse of the `apoc.map.flatten` function.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'map', - documentation: 'map :: MAP', + isDeprecated: false, + description: 'map :: MAP', + name: 'map', + type: 'MAP', }, { - label: 'delimiter', - documentation: 'delimiter = . :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=., type=STRING}', + description: 'delimiter = . :: STRING', + name: 'delimiter', + type: 'STRING', }, ], + signature: + 'apoc.map.unflatten(map :: MAP, delimiter = . :: STRING) :: MAP', + returnDescription: 'MAP', + aggregating: false, }, 'apoc.map.updateTree': { - label: 'apoc.map.updateTree', - documentation: + name: 'apoc.map.updateTree', + category: '', + description: 'Adds the data `MAP` on each level of the nested tree, where the key-value pairs match.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'tree', - documentation: 'tree :: MAP', + isDeprecated: false, + description: 'tree :: MAP', + name: 'tree', + type: 'MAP', }, { - label: 'key', - documentation: 'key :: STRING', + isDeprecated: false, + description: 'key :: STRING', + name: 'key', + type: 'STRING', }, { - label: 'data', - documentation: 'data :: LIST>', + isDeprecated: false, + description: 'data :: LIST>', + name: 'data', + type: 'LIST>', }, ], + signature: + 'apoc.map.updateTree(tree :: MAP, key :: STRING, data :: LIST>) :: MAP', + returnDescription: 'MAP', + aggregating: false, }, 'apoc.map.values': { - label: 'apoc.map.values', - documentation: + name: 'apoc.map.values', + category: '', + description: 'Returns a `LIST` indicated by the given keys (returns a null value if a given key is missing).', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'map', - documentation: 'map :: MAP', + isDeprecated: false, + description: 'map :: MAP', + name: 'map', + type: 'MAP', }, { - label: 'keys', - documentation: 'keys = [] :: LIST', + isDeprecated: false, + default: 'DefaultParameterValue{value=[], type=LIST}', + description: 'keys = [] :: LIST', + name: 'keys', + type: 'LIST', }, { - label: 'addNullsForMissing', - documentation: 'addNullsForMissing = false :: BOOLEAN', + isDeprecated: false, + default: 'DefaultParameterValue{value=false, type=BOOLEAN}', + description: 'addNullsForMissing = false :: BOOLEAN', + name: 'addNullsForMissing', + type: 'BOOLEAN', }, ], + signature: + 'apoc.map.values(map :: MAP, keys = [] :: LIST, addNullsForMissing = false :: BOOLEAN) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.math.cosh': { - label: 'apoc.math.cosh', - documentation: 'Returns the hyperbolic cosine.', - parameters: [ + name: 'apoc.math.cosh', + category: '', + description: 'Returns the hyperbolic cosine.', + isBuiltIn: false, + argumentDescription: [ { - label: 'value', - documentation: 'value :: FLOAT', + isDeprecated: false, + description: 'value :: FLOAT', + name: 'value', + type: 'FLOAT', }, ], + signature: 'apoc.math.cosh(value :: FLOAT) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, 'apoc.math.coth': { - label: 'apoc.math.coth', - documentation: 'Returns the hyperbolic cotangent.', - parameters: [ + name: 'apoc.math.coth', + category: '', + description: 'Returns the hyperbolic cotangent.', + isBuiltIn: false, + argumentDescription: [ { - label: 'value', - documentation: 'value :: FLOAT', + isDeprecated: false, + description: 'value :: FLOAT', + name: 'value', + type: 'FLOAT', }, ], + signature: 'apoc.math.coth(value :: FLOAT) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, 'apoc.math.csch': { - label: 'apoc.math.csch', - documentation: 'Returns the hyperbolic cosecant.', - parameters: [ + name: 'apoc.math.csch', + category: '', + description: 'Returns the hyperbolic cosecant.', + isBuiltIn: false, + argumentDescription: [ { - label: 'value', - documentation: 'value :: FLOAT', + isDeprecated: false, + description: 'value :: FLOAT', + name: 'value', + type: 'FLOAT', }, ], + signature: 'apoc.math.csch(value :: FLOAT) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, 'apoc.math.maxByte': { - label: 'apoc.math.maxByte', - documentation: 'Returns the maximum value of a byte.', - parameters: [], + name: 'apoc.math.maxByte', + category: '', + description: 'Returns the maximum value of a byte.', + isBuiltIn: false, + argumentDescription: [], + signature: 'apoc.math.maxByte() :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, 'apoc.math.maxDouble': { - label: 'apoc.math.maxDouble', - documentation: - 'Returns the largest positive finite value of type double.', - parameters: [], + name: 'apoc.math.maxDouble', + category: '', + description: 'Returns the largest positive finite value of type double.', + isBuiltIn: false, + argumentDescription: [], + signature: 'apoc.math.maxDouble() :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, 'apoc.math.maxInt': { - label: 'apoc.math.maxInt', - documentation: 'Returns the maximum value of an integer.', - parameters: [], + name: 'apoc.math.maxInt', + category: '', + description: 'Returns the maximum value of an integer.', + isBuiltIn: false, + argumentDescription: [], + signature: 'apoc.math.maxInt() :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, 'apoc.math.maxLong': { - label: 'apoc.math.maxLong', - documentation: 'Returns the maximum value of a long.', - parameters: [], + name: 'apoc.math.maxLong', + category: '', + description: 'Returns the maximum value of a long.', + isBuiltIn: false, + argumentDescription: [], + signature: 'apoc.math.maxLong() :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, 'apoc.math.minByte': { - label: 'apoc.math.minByte', - documentation: 'Returns the minimum value of a byte.', - parameters: [], + name: 'apoc.math.minByte', + category: '', + description: 'Returns the minimum value of a byte.', + isBuiltIn: false, + argumentDescription: [], + signature: 'apoc.math.minByte() :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, 'apoc.math.minDouble': { - label: 'apoc.math.minDouble', - documentation: + name: 'apoc.math.minDouble', + category: '', + description: 'Returns the smallest positive non-zero value of type double.', - parameters: [], + isBuiltIn: false, + argumentDescription: [], + signature: 'apoc.math.minDouble() :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, 'apoc.math.minInt': { - label: 'apoc.math.minInt', - documentation: 'Returns the minimum value of an integer.', - parameters: [], + name: 'apoc.math.minInt', + category: '', + description: 'Returns the minimum value of an integer.', + isBuiltIn: false, + argumentDescription: [], + signature: 'apoc.math.minInt() :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, 'apoc.math.minLong': { - label: 'apoc.math.minLong', - documentation: 'Returns the minimum value of a long.', - parameters: [], + name: 'apoc.math.minLong', + category: '', + description: 'Returns the minimum value of a long.', + isBuiltIn: false, + argumentDescription: [], + signature: 'apoc.math.minLong() :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, 'apoc.math.sech': { - label: 'apoc.math.sech', - documentation: 'Returns the hyperbolic secant of the given value.', - parameters: [ + name: 'apoc.math.sech', + category: '', + description: 'Returns the hyperbolic secant of the given value.', + isBuiltIn: false, + argumentDescription: [ { - label: 'value', - documentation: 'value :: FLOAT', + isDeprecated: false, + description: 'value :: FLOAT', + name: 'value', + type: 'FLOAT', }, ], + signature: 'apoc.math.sech(value :: FLOAT) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, 'apoc.math.sigmoid': { - label: 'apoc.math.sigmoid', - documentation: 'Returns the sigmoid of the given value.', - parameters: [ + name: 'apoc.math.sigmoid', + category: '', + description: 'Returns the sigmoid of the given value.', + isBuiltIn: false, + argumentDescription: [ { - label: 'value', - documentation: 'value :: FLOAT', + isDeprecated: false, + description: 'value :: FLOAT', + name: 'value', + type: 'FLOAT', }, ], + signature: 'apoc.math.sigmoid(value :: FLOAT) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, 'apoc.math.sigmoidPrime': { - label: 'apoc.math.sigmoidPrime', - documentation: + name: 'apoc.math.sigmoidPrime', + category: '', + description: 'Returns the sigmoid prime [ sigmoid(val) * (1 - sigmoid(val)) ] of the given value.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'value', - documentation: 'value :: FLOAT', + isDeprecated: false, + description: 'value :: FLOAT', + name: 'value', + type: 'FLOAT', }, ], + signature: 'apoc.math.sigmoidPrime(value :: FLOAT) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, 'apoc.math.sinh': { - label: 'apoc.math.sinh', - documentation: 'Returns the hyperbolic sine of the given value.', - parameters: [ + name: 'apoc.math.sinh', + category: '', + description: 'Returns the hyperbolic sine of the given value.', + isBuiltIn: false, + argumentDescription: [ { - label: 'value', - documentation: 'value :: FLOAT', + isDeprecated: false, + description: 'value :: FLOAT', + name: 'value', + type: 'FLOAT', }, ], + signature: 'apoc.math.sinh(value :: FLOAT) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, 'apoc.math.tanh': { - label: 'apoc.math.tanh', - documentation: 'Returns the hyperbolic tangent of the given value.', - parameters: [ + name: 'apoc.math.tanh', + category: '', + description: 'Returns the hyperbolic tangent of the given value.', + isBuiltIn: false, + argumentDescription: [ { - label: 'value', - documentation: 'value :: FLOAT', + isDeprecated: false, + description: 'value :: FLOAT', + name: 'value', + type: 'FLOAT', }, ], + signature: 'apoc.math.tanh(value :: FLOAT) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, 'apoc.meta.cypher.isType': { - label: 'apoc.meta.cypher.isType', - documentation: 'Returns true if the given value matches the given type.', - parameters: [ + name: 'apoc.meta.cypher.isType', + category: '', + description: 'Returns true if the given value matches the given type.', + isBuiltIn: false, + argumentDescription: [ { - label: 'value', - documentation: 'value :: ANY', + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', }, { - label: 'type', - documentation: 'type :: STRING', + isDeprecated: false, + description: 'type :: STRING', + name: 'type', + type: 'STRING', }, ], + signature: + 'apoc.meta.cypher.isType(value :: ANY, type :: STRING) :: BOOLEAN', + returnDescription: 'BOOLEAN', + aggregating: false, }, 'apoc.meta.cypher.type': { - label: 'apoc.meta.cypher.type', - documentation: 'Returns the type name of the given value.', - parameters: [ + name: 'apoc.meta.cypher.type', + category: '', + description: 'Returns the type name of the given value.', + isBuiltIn: false, + argumentDescription: [ { - label: 'value', - documentation: 'value :: ANY', + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', }, ], + signature: 'apoc.meta.cypher.type(value :: ANY) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.meta.cypher.types': { - label: 'apoc.meta.cypher.types', - documentation: + name: 'apoc.meta.cypher.types', + category: '', + description: 'Returns a `MAP` containing the type names of the given values.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'props', - documentation: 'props :: ANY', + isDeprecated: false, + description: 'props :: ANY', + name: 'props', + type: 'ANY', }, ], + signature: 'apoc.meta.cypher.types(props :: ANY) :: MAP', + returnDescription: 'MAP', + aggregating: false, }, 'apoc.meta.nodes.count': { - label: 'apoc.meta.nodes.count', - documentation: + name: 'apoc.meta.nodes.count', + category: '', + description: 'Returns the sum of the `NODE` values with the given labels in the `LIST`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'nodes', - documentation: 'nodes = [] :: LIST', + isDeprecated: false, + default: 'DefaultParameterValue{value=[], type=LIST}', + description: 'nodes = [] :: LIST', + name: 'nodes', + type: 'LIST', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', }, ], + signature: + 'apoc.meta.nodes.count(nodes = [] :: LIST, config = {} :: MAP) :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, 'apoc.node.degree': { - label: 'apoc.node.degree', - documentation: 'Returns the total degrees of the given `NODE`.', - parameters: [ + name: 'apoc.node.degree', + category: '', + description: 'Returns the total degrees of the given `NODE`.', + isBuiltIn: false, + argumentDescription: [ { - label: 'node', - documentation: 'node :: NODE', + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', }, { - label: 'relTypes', - documentation: 'relTypes = :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'relTypes = :: STRING', + name: 'relTypes', + type: 'STRING', }, ], + signature: + 'apoc.node.degree(node :: NODE, relTypes = :: STRING) :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, 'apoc.node.degree.in': { - label: 'apoc.node.degree.in', - documentation: + name: 'apoc.node.degree.in', + category: '', + description: 'Returns the total number of incoming `RELATIONSHIP` values connected to the given `NODE`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'node', - documentation: 'node :: NODE', + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', }, { - label: 'relTypes', - documentation: 'relTypes = :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'relTypes = :: STRING', + name: 'relTypes', + type: 'STRING', }, ], + signature: + 'apoc.node.degree.in(node :: NODE, relTypes = :: STRING) :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, 'apoc.node.degree.out': { - label: 'apoc.node.degree.out', - documentation: + name: 'apoc.node.degree.out', + category: '', + description: 'Returns the total number of outgoing `RELATIONSHIP` values from the given `NODE`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'node', - documentation: 'node :: NODE', + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', }, { - label: 'relTypes', - documentation: 'relTypes = :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'relTypes = :: STRING', + name: 'relTypes', + type: 'STRING', }, ], + signature: + 'apoc.node.degree.out(node :: NODE, relTypes = :: STRING) :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, 'apoc.node.id': { - label: 'apoc.node.id', - documentation: 'Returns the id for the given virtual `NODE`.', - parameters: [ + name: 'apoc.node.id', + category: '', + description: 'Returns the id for the given virtual `NODE`.', + isBuiltIn: false, + argumentDescription: [ { - label: 'node', - documentation: 'node :: NODE', + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', }, ], + signature: 'apoc.node.id(node :: NODE) :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, 'apoc.node.labels': { - label: 'apoc.node.labels', - documentation: 'Returns the labels for the given virtual `NODE`.', - parameters: [ + name: 'apoc.node.labels', + category: '', + description: 'Returns the labels for the given virtual `NODE`.', + isBuiltIn: false, + argumentDescription: [ { - label: 'node', - documentation: 'node :: NODE', + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', }, ], + signature: 'apoc.node.labels(node :: NODE) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.node.relationship.exists': { - label: 'apoc.node.relationship.exists', - documentation: + name: 'apoc.node.relationship.exists', + category: '', + description: 'Returns a `BOOLEAN` based on whether the given `NODE` has a connecting `RELATIONSHIP` (or whether the given `NODE` has a connecting `RELATIONSHIP` of the given type and direction).', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'node', - documentation: 'node :: NODE', + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', }, { - label: 'relTypes', - documentation: 'relTypes = :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'relTypes = :: STRING', + name: 'relTypes', + type: 'STRING', }, ], + signature: + 'apoc.node.relationship.exists(node :: NODE, relTypes = :: STRING) :: BOOLEAN', + returnDescription: 'BOOLEAN', + aggregating: false, }, 'apoc.node.relationship.types': { - label: 'apoc.node.relationship.types', - documentation: + name: 'apoc.node.relationship.types', + category: '', + description: 'Returns a `LIST` of distinct `RELATIONSHIP` types for the given `NODE`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'node', - documentation: 'node :: NODE', + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', }, { - label: 'relTypes', - documentation: 'relTypes = :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'relTypes = :: STRING', + name: 'relTypes', + type: 'STRING', }, ], + signature: + 'apoc.node.relationship.types(node :: NODE, relTypes = :: STRING) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.node.relationships.exist': { - label: 'apoc.node.relationships.exist', - documentation: + name: 'apoc.node.relationships.exist', + category: '', + description: 'Returns a `BOOLEAN` based on whether the given `NODE` has connecting `RELATIONSHIP` values (or whether the given `NODE` has connecting `RELATIONSHIP` values of the given type and direction).', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'node', - documentation: 'node :: NODE', + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', }, { - label: 'relTypes', - documentation: 'relTypes = :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'relTypes = :: STRING', + name: 'relTypes', + type: 'STRING', }, ], + signature: + 'apoc.node.relationships.exist(node :: NODE, relTypes = :: STRING) :: MAP', + returnDescription: 'MAP', + aggregating: false, }, 'apoc.nodes.connected': { - label: 'apoc.nodes.connected', - documentation: + name: 'apoc.nodes.connected', + category: '', + description: 'Returns true when a given `NODE` is directly connected to another given `NODE`.\nThis function is optimized for dense nodes.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'startNode', - documentation: 'startNode :: NODE', + isDeprecated: false, + description: 'startNode :: NODE', + name: 'startNode', + type: 'NODE', }, { - label: 'endNode', - documentation: 'endNode :: NODE', + isDeprecated: false, + description: 'endNode :: NODE', + name: 'endNode', + type: 'NODE', }, { - label: 'types', - documentation: 'types = :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'types = :: STRING', + name: 'types', + type: 'STRING', }, ], + signature: + 'apoc.nodes.connected(startNode :: NODE, endNode :: NODE, types = :: STRING) :: BOOLEAN', + returnDescription: 'BOOLEAN', + aggregating: false, }, 'apoc.nodes.isDense': { - label: 'apoc.nodes.isDense', - documentation: 'Returns true if the given `NODE` is a dense node.', - parameters: [ + name: 'apoc.nodes.isDense', + category: '', + description: 'Returns true if the given `NODE` is a dense node.', + isBuiltIn: false, + argumentDescription: [ { - label: 'node', - documentation: 'node :: NODE', + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', }, ], + signature: 'apoc.nodes.isDense(node :: NODE) :: BOOLEAN', + returnDescription: 'BOOLEAN', + aggregating: false, }, 'apoc.nodes.relationship.types': { - label: 'apoc.nodes.relationship.types', - documentation: + name: 'apoc.nodes.relationship.types', + category: '', + description: 'Returns a `LIST` of distinct `RELATIONSHIP` types from the given `LIST` values.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'nodes', - documentation: 'nodes :: ANY', + isDeprecated: false, + description: 'nodes :: ANY', + name: 'nodes', + type: 'ANY', }, { - label: 'types', - documentation: 'types = :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'types = :: STRING', + name: 'types', + type: 'STRING', }, ], + signature: + 'apoc.nodes.relationship.types(nodes :: ANY, types = :: STRING) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.nodes.relationships.exist': { - label: 'apoc.nodes.relationships.exist', - documentation: + name: 'apoc.nodes.relationships.exist', + category: '', + description: 'Returns a `BOOLEAN` based on whether or not the given `NODE` values have the given `RELATIONSHIP` values.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'nodes', - documentation: 'nodes :: ANY', + isDeprecated: false, + description: 'nodes :: ANY', + name: 'nodes', + type: 'ANY', }, { - label: 'types', - documentation: 'types = :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'types = :: STRING', + name: 'types', + type: 'STRING', }, ], + signature: + 'apoc.nodes.relationships.exist(nodes :: ANY, types = :: STRING) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.number.arabicToRoman': { - label: 'apoc.number.arabicToRoman', - documentation: 'Converts the given Arabic numbers to Roman numbers.', - parameters: [ + name: 'apoc.number.arabicToRoman', + category: '', + description: 'Converts the given Arabic numbers to Roman numbers.', + isBuiltIn: false, + argumentDescription: [ { - label: 'number', - documentation: 'number :: ANY', + isDeprecated: false, + description: 'number :: ANY', + name: 'number', + type: 'ANY', }, ], + signature: 'apoc.number.arabicToRoman(number :: ANY) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.number.exact.add': { - label: 'apoc.number.exact.add', - documentation: + name: 'apoc.number.exact.add', + category: '', + description: 'Returns the result of adding the two given large numbers (using Java BigDecimal).', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'stringA', - documentation: 'stringA :: STRING', + isDeprecated: false, + description: 'stringA :: STRING', + name: 'stringA', + type: 'STRING', }, { - label: 'stringB', - documentation: 'stringB :: STRING', + isDeprecated: false, + description: 'stringB :: STRING', + name: 'stringB', + type: 'STRING', }, ], + signature: + 'apoc.number.exact.add(stringA :: STRING, stringB :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.number.exact.div': { - label: 'apoc.number.exact.div', - documentation: + name: 'apoc.number.exact.div', + category: '', + description: 'Returns the result of dividing a given large number with another given large number (using Java BigDecimal).', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'stringA', - documentation: 'stringA :: STRING', + isDeprecated: false, + description: 'stringA :: STRING', + name: 'stringA', + type: 'STRING', }, { - label: 'stringB', - documentation: 'stringB :: STRING', + isDeprecated: false, + description: 'stringB :: STRING', + name: 'stringB', + type: 'STRING', }, { - label: 'precision', - documentation: 'precision = 0 :: INTEGER', + isDeprecated: false, + default: 'DefaultParameterValue{value=0, type=INTEGER}', + description: 'precision = 0 :: INTEGER', + name: 'precision', + type: 'INTEGER', }, { - label: 'roundingMode', - documentation: 'roundingMode = HALF_UP :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=HALF_UP, type=STRING}', + description: 'roundingMode = HALF_UP :: STRING', + name: 'roundingMode', + type: 'STRING', }, ], + signature: + 'apoc.number.exact.div(stringA :: STRING, stringB :: STRING, precision = 0 :: INTEGER, roundingMode = HALF_UP :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.number.exact.mul': { - label: 'apoc.number.exact.mul', - documentation: + name: 'apoc.number.exact.mul', + category: '', + description: 'Returns the result of multiplying two given large numbers (using Java BigDecimal).', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'stringA', - documentation: 'stringA :: STRING', + isDeprecated: false, + description: 'stringA :: STRING', + name: 'stringA', + type: 'STRING', }, { - label: 'stringB', - documentation: 'stringB :: STRING', + isDeprecated: false, + description: 'stringB :: STRING', + name: 'stringB', + type: 'STRING', }, { - label: 'precision', - documentation: 'precision = 0 :: INTEGER', + isDeprecated: false, + default: 'DefaultParameterValue{value=0, type=INTEGER}', + description: 'precision = 0 :: INTEGER', + name: 'precision', + type: 'INTEGER', }, { - label: 'roundingMode', - documentation: 'roundingMode = HALF_UP :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=HALF_UP, type=STRING}', + description: 'roundingMode = HALF_UP :: STRING', + name: 'roundingMode', + type: 'STRING', }, ], + signature: + 'apoc.number.exact.mul(stringA :: STRING, stringB :: STRING, precision = 0 :: INTEGER, roundingMode = HALF_UP :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.number.exact.sub': { - label: 'apoc.number.exact.sub', - documentation: + name: 'apoc.number.exact.sub', + category: '', + description: 'Returns the result of subtracting a given large number from another given large number (using Java BigDecimal).', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'stringA', - documentation: 'stringA :: STRING', + isDeprecated: false, + description: 'stringA :: STRING', + name: 'stringA', + type: 'STRING', }, { - label: 'stringB', - documentation: 'stringB :: STRING', + isDeprecated: false, + description: 'stringB :: STRING', + name: 'stringB', + type: 'STRING', }, ], + signature: + 'apoc.number.exact.sub(stringA :: STRING, stringB :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.number.exact.toExact': { - label: 'apoc.number.exact.toExact', - documentation: + name: 'apoc.number.exact.toExact', + category: '', + description: 'Returns the exact value of the given number (using Java BigDecimal).', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'number', - documentation: 'number :: INTEGER', + isDeprecated: false, + description: 'number :: INTEGER', + name: 'number', + type: 'INTEGER', }, ], + signature: 'apoc.number.exact.toExact(number :: INTEGER) :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, 'apoc.number.exact.toFloat': { - label: 'apoc.number.exact.toFloat', - documentation: + name: 'apoc.number.exact.toFloat', + category: '', + description: 'Returns the `FLOAT` of the given large number (using Java BigDecimal).', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'string', - documentation: 'string :: STRING', + isDeprecated: false, + description: 'string :: STRING', + name: 'string', + type: 'STRING', }, { - label: 'precision', - documentation: 'precision = 0 :: INTEGER', + isDeprecated: false, + default: 'DefaultParameterValue{value=0, type=INTEGER}', + description: 'precision = 0 :: INTEGER', + name: 'precision', + type: 'INTEGER', }, { - label: 'roundingMode', - documentation: 'roundingMode = HALF_UP :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=HALF_UP, type=STRING}', + description: 'roundingMode = HALF_UP :: STRING', + name: 'roundingMode', + type: 'STRING', }, ], + signature: + 'apoc.number.exact.toFloat(string :: STRING, precision = 0 :: INTEGER, roundingMode = HALF_UP :: STRING) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, 'apoc.number.exact.toInteger': { - label: 'apoc.number.exact.toInteger', - documentation: + name: 'apoc.number.exact.toInteger', + category: '', + description: 'Returns the `INTEGER` of the given large number (using Java BigDecimal).', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'string', - documentation: 'string :: STRING', + isDeprecated: false, + description: 'string :: STRING', + name: 'string', + type: 'STRING', }, { - label: 'precision', - documentation: 'precision = 0 :: INTEGER', + isDeprecated: false, + default: 'DefaultParameterValue{value=0, type=INTEGER}', + description: 'precision = 0 :: INTEGER', + name: 'precision', + type: 'INTEGER', }, { - label: 'roundingMode', - documentation: 'roundingMode = HALF_UP :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=HALF_UP, type=STRING}', + description: 'roundingMode = HALF_UP :: STRING', + name: 'roundingMode', + type: 'STRING', }, ], + signature: + 'apoc.number.exact.toInteger(string :: STRING, precision = 0 :: INTEGER, roundingMode = HALF_UP :: STRING) :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, 'apoc.number.format': { - label: 'apoc.number.format', - documentation: + name: 'apoc.number.format', + category: '', + description: 'Formats the given `INTEGER` or `FLOAT` using the given pattern and language to produce a `STRING`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'number', - documentation: 'number :: ANY', + isDeprecated: false, + description: 'number :: ANY', + name: 'number', + type: 'ANY', }, { - label: 'pattern', - documentation: 'pattern = :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'pattern = :: STRING', + name: 'pattern', + type: 'STRING', }, { - label: 'language', - documentation: 'language = :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'language = :: STRING', + name: 'language', + type: 'STRING', }, ], + signature: + 'apoc.number.format(number :: ANY, pattern = :: STRING, language = :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.number.parseFloat': { - label: 'apoc.number.parseFloat', - documentation: + name: 'apoc.number.parseFloat', + category: '', + description: 'Parses the given `STRING` using the given pattern and language to produce a `FLOAT`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'text', - documentation: 'text :: STRING', + isDeprecated: false, + description: 'text :: STRING', + name: 'text', + type: 'STRING', }, { - label: 'pattern', - documentation: 'pattern = :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'pattern = :: STRING', + name: 'pattern', + type: 'STRING', }, { - label: 'language', - documentation: 'language = :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'language = :: STRING', + name: 'language', + type: 'STRING', }, ], + signature: + 'apoc.number.parseFloat(text :: STRING, pattern = :: STRING, language = :: STRING) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, 'apoc.number.parseInt': { - label: 'apoc.number.parseInt', - documentation: + name: 'apoc.number.parseInt', + category: '', + description: 'Parses the given `STRING` using the given pattern and language to produce a `INTEGER`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'text', - documentation: 'text :: STRING', + isDeprecated: false, + description: 'text :: STRING', + name: 'text', + type: 'STRING', }, { - label: 'pattern', - documentation: 'pattern = :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'pattern = :: STRING', + name: 'pattern', + type: 'STRING', }, { - label: 'language', - documentation: 'language = :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'language = :: STRING', + name: 'language', + type: 'STRING', }, ], + signature: + 'apoc.number.parseInt(text :: STRING, pattern = :: STRING, language = :: STRING) :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, 'apoc.number.romanToArabic': { - label: 'apoc.number.romanToArabic', - documentation: 'Converts the given Roman numbers to Arabic numbers.', - parameters: [ + name: 'apoc.number.romanToArabic', + category: '', + description: 'Converts the given Roman numbers to Arabic numbers.', + isBuiltIn: false, + argumentDescription: [ { - label: 'romanNumber', - documentation: 'romanNumber :: STRING', + isDeprecated: false, + description: 'romanNumber :: STRING', + name: 'romanNumber', + type: 'STRING', }, ], + signature: + 'apoc.number.romanToArabic(romanNumber :: STRING) :: INTEGER | FLOAT', + returnDescription: 'INTEGER | FLOAT', + aggregating: false, }, 'apoc.path.combine': { - label: 'apoc.path.combine', - documentation: 'Combines the two given `PATH` values into one `PATH`.', - parameters: [ + name: 'apoc.path.combine', + category: '', + description: 'Combines the two given `PATH` values into one `PATH`.', + isBuiltIn: false, + argumentDescription: [ { - label: 'path1', - documentation: 'path1 :: PATH', + isDeprecated: false, + description: 'path1 :: PATH', + name: 'path1', + type: 'PATH', }, { - label: 'path2', - documentation: 'path2 :: PATH', + isDeprecated: false, + description: 'path2 :: PATH', + name: 'path2', + type: 'PATH', }, ], + signature: 'apoc.path.combine(path1 :: PATH, path2 :: PATH) :: PATH', + returnDescription: 'PATH', + aggregating: false, }, 'apoc.path.create': { - label: 'apoc.path.create', - documentation: + name: 'apoc.path.create', + category: '', + description: 'Returns a `PATH` from the given start `NODE` and `LIST`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'startNode', - documentation: 'startNode :: NODE', + isDeprecated: false, + description: 'startNode :: NODE', + name: 'startNode', + type: 'NODE', }, { - label: 'rels', - documentation: 'rels = [] :: LIST', + isDeprecated: false, + default: 'DefaultParameterValue{value=[], type=LIST}', + description: 'rels = [] :: LIST', + name: 'rels', + type: 'LIST', }, ], + signature: + 'apoc.path.create(startNode :: NODE, rels = [] :: LIST) :: PATH', + returnDescription: 'PATH', + aggregating: false, }, 'apoc.path.elements': { - label: 'apoc.path.elements', - documentation: + name: 'apoc.path.elements', + category: '', + description: 'Converts the given `PATH` into a `LIST`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'path', - documentation: 'path :: PATH', + isDeprecated: false, + description: 'path :: PATH', + name: 'path', + type: 'PATH', }, ], + signature: 'apoc.path.elements(path :: PATH) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.path.slice': { - label: 'apoc.path.slice', - documentation: + name: 'apoc.path.slice', + category: '', + description: 'Returns a new `PATH` of the given length, taken from the given `PATH` at the given offset.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'path', - documentation: 'path :: PATH', + isDeprecated: false, + description: 'path :: PATH', + name: 'path', + type: 'PATH', }, { - label: 'offset', - documentation: 'offset = 0 :: INTEGER', + isDeprecated: false, + default: 'DefaultParameterValue{value=0, type=INTEGER}', + description: 'offset = 0 :: INTEGER', + name: 'offset', + type: 'INTEGER', }, { - label: 'length', - documentation: 'length = -1 :: INTEGER', + isDeprecated: false, + default: 'DefaultParameterValue{value=-1, type=INTEGER}', + description: 'length = -1 :: INTEGER', + name: 'length', + type: 'INTEGER', }, ], + signature: + 'apoc.path.slice(path :: PATH, offset = 0 :: INTEGER, length = -1 :: INTEGER) :: PATH', + returnDescription: 'PATH', + aggregating: false, }, 'apoc.rel.endNode': { - label: 'apoc.rel.endNode', - documentation: + name: 'apoc.rel.endNode', + category: '', + description: 'Returns the end `NODE` for the given virtual `RELATIONSHIP`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'rel', - documentation: 'rel :: RELATIONSHIP', + isDeprecated: false, + description: 'rel :: RELATIONSHIP', + name: 'rel', + type: 'RELATIONSHIP', }, ], + signature: 'apoc.rel.endNode(rel :: RELATIONSHIP) :: NODE', + returnDescription: 'NODE', + aggregating: false, }, 'apoc.rel.id': { - label: 'apoc.rel.id', - documentation: 'Returns the id for the given virtual `RELATIONSHIP`.', - parameters: [ + name: 'apoc.rel.id', + category: '', + description: 'Returns the id for the given virtual `RELATIONSHIP`.', + isBuiltIn: false, + argumentDescription: [ { - label: 'rel', - documentation: 'rel :: RELATIONSHIP', + isDeprecated: false, + description: 'rel :: RELATIONSHIP', + name: 'rel', + type: 'RELATIONSHIP', }, ], + signature: 'apoc.rel.id(rel :: RELATIONSHIP) :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, 'apoc.rel.startNode': { - label: 'apoc.rel.startNode', - documentation: + name: 'apoc.rel.startNode', + category: '', + description: 'Returns the start `NODE` for the given virtual `RELATIONSHIP`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'rel', - documentation: 'rel :: RELATIONSHIP', + isDeprecated: false, + description: 'rel :: RELATIONSHIP', + name: 'rel', + type: 'RELATIONSHIP', }, ], + signature: 'apoc.rel.startNode(rel :: RELATIONSHIP) :: NODE', + returnDescription: 'NODE', + aggregating: false, }, 'apoc.rel.type': { - label: 'apoc.rel.type', - documentation: 'Returns the type for the given virtual `RELATIONSHIP`.', - parameters: [ + name: 'apoc.rel.type', + category: '', + description: 'Returns the type for the given virtual `RELATIONSHIP`.', + isBuiltIn: false, + argumentDescription: [ { - label: 'rel', - documentation: 'rel :: RELATIONSHIP', + isDeprecated: false, + description: 'rel :: RELATIONSHIP', + name: 'rel', + type: 'RELATIONSHIP', }, ], + signature: 'apoc.rel.type(rel :: RELATIONSHIP) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.schema.node.constraintExists': { - label: 'apoc.schema.node.constraintExists', - documentation: + name: 'apoc.schema.node.constraintExists', + category: '', + description: 'Returns a `BOOLEAN` depending on whether or not a constraint exists for the given `NODE` label with the given property names.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'labelName', - documentation: 'labelName :: STRING', + isDeprecated: false, + description: 'labelName :: STRING', + name: 'labelName', + type: 'STRING', }, { - label: 'propertyName', - documentation: 'propertyName :: LIST', + isDeprecated: false, + description: 'propertyName :: LIST', + name: 'propertyName', + type: 'LIST', }, ], + signature: + 'apoc.schema.node.constraintExists(labelName :: STRING, propertyName :: LIST) :: BOOLEAN', + returnDescription: 'BOOLEAN', + aggregating: false, }, 'apoc.schema.node.indexExists': { - label: 'apoc.schema.node.indexExists', - documentation: + name: 'apoc.schema.node.indexExists', + category: '', + description: 'Returns a `BOOLEAN` depending on whether or not an index exists for the given `NODE` label with the given property names.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'labelName', - documentation: 'labelName :: STRING', + isDeprecated: false, + description: 'labelName :: STRING', + name: 'labelName', + type: 'STRING', }, { - label: 'propertyName', - documentation: 'propertyName :: LIST', + isDeprecated: false, + description: 'propertyName :: LIST', + name: 'propertyName', + type: 'LIST', }, ], + signature: + 'apoc.schema.node.indexExists(labelName :: STRING, propertyName :: LIST) :: BOOLEAN', + returnDescription: 'BOOLEAN', + aggregating: false, }, 'apoc.schema.relationship.constraintExists': { - label: 'apoc.schema.relationship.constraintExists', - documentation: + name: 'apoc.schema.relationship.constraintExists', + category: '', + description: 'Returns a `BOOLEAN` depending on whether or not a constraint exists for the given `RELATIONSHIP` type with the given property names.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'type', - documentation: 'type :: STRING', + isDeprecated: false, + description: 'type :: STRING', + name: 'type', + type: 'STRING', }, { - label: 'propertyName', - documentation: 'propertyName :: LIST', + isDeprecated: false, + description: 'propertyName :: LIST', + name: 'propertyName', + type: 'LIST', }, ], + signature: + 'apoc.schema.relationship.constraintExists(type :: STRING, propertyName :: LIST) :: BOOLEAN', + returnDescription: 'BOOLEAN', + aggregating: false, }, 'apoc.schema.relationship.indexExists': { - label: 'apoc.schema.relationship.indexExists', - documentation: + name: 'apoc.schema.relationship.indexExists', + category: '', + description: 'Returns a `BOOLEAN` depending on whether or not an index exists for the given `RELATIONSHIP` type with the given property names.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'type', - documentation: 'type :: STRING', + isDeprecated: false, + description: 'type :: STRING', + name: 'type', + type: 'STRING', }, { - label: 'propertyName', - documentation: 'propertyName :: LIST', + isDeprecated: false, + description: 'propertyName :: LIST', + name: 'propertyName', + type: 'LIST', }, ], + signature: + 'apoc.schema.relationship.indexExists(type :: STRING, propertyName :: LIST) :: BOOLEAN', + returnDescription: 'BOOLEAN', + aggregating: false, }, 'apoc.scoring.existence': { - label: 'apoc.scoring.existence', - documentation: 'Returns the given score if true, 0 if false.', - parameters: [ + name: 'apoc.scoring.existence', + category: '', + description: 'Returns the given score if true, 0 if false.', + isBuiltIn: false, + argumentDescription: [ { - label: 'score', - documentation: 'score :: INTEGER', + isDeprecated: false, + description: 'score :: INTEGER', + name: 'score', + type: 'INTEGER', }, { - label: 'exists', - documentation: 'exists :: BOOLEAN', + isDeprecated: false, + description: 'exists :: BOOLEAN', + name: 'exists', + type: 'BOOLEAN', }, ], + signature: + 'apoc.scoring.existence(score :: INTEGER, exists :: BOOLEAN) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, 'apoc.scoring.pareto': { - label: 'apoc.scoring.pareto', - documentation: + name: 'apoc.scoring.pareto', + category: '', + description: 'Applies a Pareto scoring function over the given `INTEGER` values.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'minimumThreshold', - documentation: 'minimumThreshold :: INTEGER', + isDeprecated: false, + description: 'minimumThreshold :: INTEGER', + name: 'minimumThreshold', + type: 'INTEGER', }, { - label: 'eightyPercentValue', - documentation: 'eightyPercentValue :: INTEGER', + isDeprecated: false, + description: 'eightyPercentValue :: INTEGER', + name: 'eightyPercentValue', + type: 'INTEGER', }, { - label: 'maximumValue', - documentation: 'maximumValue :: INTEGER', + isDeprecated: false, + description: 'maximumValue :: INTEGER', + name: 'maximumValue', + type: 'INTEGER', }, { - label: 'score', - documentation: 'score :: INTEGER', + isDeprecated: false, + description: 'score :: INTEGER', + name: 'score', + type: 'INTEGER', }, ], + signature: + 'apoc.scoring.pareto(minimumThreshold :: INTEGER, eightyPercentValue :: INTEGER, maximumValue :: INTEGER, score :: INTEGER) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, 'apoc.temporal.format': { - label: 'apoc.temporal.format', - documentation: + name: 'apoc.temporal.format', + category: '', + description: 'Formats the given temporal value into the given time format.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'temporal', - documentation: 'temporal :: ANY', + isDeprecated: false, + description: 'temporal :: ANY', + name: 'temporal', + type: 'ANY', }, { - label: 'format', - documentation: 'format = yyyy-MM-dd :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=yyyy-MM-dd, type=STRING}', + description: 'format = yyyy-MM-dd :: STRING', + name: 'format', + type: 'STRING', }, ], + signature: + 'apoc.temporal.format(temporal :: ANY, format = yyyy-MM-dd :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.temporal.formatDuration': { - label: 'apoc.temporal.formatDuration', - documentation: 'Formats the given duration into the given time format.', - parameters: [ + name: 'apoc.temporal.formatDuration', + category: '', + description: 'Formats the given duration into the given time format.', + isBuiltIn: false, + argumentDescription: [ { - label: 'input', - documentation: 'input :: ANY', + isDeprecated: false, + description: 'input :: ANY', + name: 'input', + type: 'ANY', }, { - label: 'format', - documentation: 'format :: STRING', + isDeprecated: false, + description: 'format :: STRING', + name: 'format', + type: 'STRING', }, ], + signature: + 'apoc.temporal.formatDuration(input :: ANY, format :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.temporal.toZonedTemporal': { - label: 'apoc.temporal.toZonedTemporal', - documentation: + name: 'apoc.temporal.toZonedTemporal', + category: '', + description: 'Parses the given date `STRING` using the specified format into the given time zone.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'time', - documentation: 'time :: STRING', + isDeprecated: false, + description: 'time :: STRING', + name: 'time', + type: 'STRING', }, { - label: 'format', - documentation: 'format = yyyy-MM-dd HH:mm:ss :: STRING', + isDeprecated: false, + default: + 'DefaultParameterValue{value=yyyy-MM-dd HH:mm:ss, type=STRING}', + description: 'format = yyyy-MM-dd HH:mm:ss :: STRING', + name: 'format', + type: 'STRING', }, { - label: 'timezone', - documentation: 'timezone = UTC :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=UTC, type=STRING}', + description: 'timezone = UTC :: STRING', + name: 'timezone', + type: 'STRING', }, ], + signature: + 'apoc.temporal.toZonedTemporal(time :: STRING, format = yyyy-MM-dd HH:mm:ss :: STRING, timezone = UTC :: STRING) :: ZONED DATETIME', + returnDescription: 'ZONED DATETIME', + aggregating: false, }, 'apoc.text.base64Decode': { - label: 'apoc.text.base64Decode', - documentation: 'Decodes the given Base64 encoded `STRING`.', - parameters: [ + name: 'apoc.text.base64Decode', + category: '', + description: 'Decodes the given Base64 encoded `STRING`.', + isBuiltIn: false, + argumentDescription: [ { - label: 'text', - documentation: 'text :: STRING', + isDeprecated: false, + description: 'text :: STRING', + name: 'text', + type: 'STRING', }, ], + signature: 'apoc.text.base64Decode(text :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.text.base64Encode': { - label: 'apoc.text.base64Encode', - documentation: 'Encodes the given `STRING` with Base64.', - parameters: [ + name: 'apoc.text.base64Encode', + category: '', + description: 'Encodes the given `STRING` with Base64.', + isBuiltIn: false, + argumentDescription: [ { - label: 'text', - documentation: 'text :: STRING', + isDeprecated: false, + description: 'text :: STRING', + name: 'text', + type: 'STRING', }, ], + signature: 'apoc.text.base64Encode(text :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.text.base64UrlDecode': { - label: 'apoc.text.base64UrlDecode', - documentation: 'Decodes the given Base64 encoded URL.', - parameters: [ + name: 'apoc.text.base64UrlDecode', + category: '', + description: 'Decodes the given Base64 encoded URL.', + isBuiltIn: false, + argumentDescription: [ { - label: 'url', - documentation: 'url :: STRING', + isDeprecated: false, + description: 'url :: STRING', + name: 'url', + type: 'STRING', }, ], + signature: 'apoc.text.base64UrlDecode(url :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.text.base64UrlEncode': { - label: 'apoc.text.base64UrlEncode', - documentation: 'Encodes the given URL with Base64.', - parameters: [ + name: 'apoc.text.base64UrlEncode', + category: '', + description: 'Encodes the given URL with Base64.', + isBuiltIn: false, + argumentDescription: [ { - label: 'url', - documentation: 'url :: STRING', + isDeprecated: false, + description: 'url :: STRING', + name: 'url', + type: 'STRING', }, ], + signature: 'apoc.text.base64UrlEncode(url :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.text.byteCount': { - label: 'apoc.text.byteCount', - documentation: 'Returns the size of the given `STRING` in bytes.', - parameters: [ + name: 'apoc.text.byteCount', + category: '', + description: 'Returns the size of the given `STRING` in bytes.', + isBuiltIn: false, + argumentDescription: [ { - label: 'text', - documentation: 'text :: STRING', + isDeprecated: false, + description: 'text :: STRING', + name: 'text', + type: 'STRING', }, { - label: 'charset', - documentation: 'charset = UTF-8 :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=UTF-8, type=STRING}', + description: 'charset = UTF-8 :: STRING', + name: 'charset', + type: 'STRING', }, ], + signature: + 'apoc.text.byteCount(text :: STRING, charset = UTF-8 :: STRING) :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, 'apoc.text.bytes': { - label: 'apoc.text.bytes', - documentation: 'Returns the given `STRING` as bytes.', - parameters: [ + name: 'apoc.text.bytes', + category: '', + description: 'Returns the given `STRING` as bytes.', + isBuiltIn: false, + argumentDescription: [ { - label: 'text', - documentation: 'text :: STRING', + isDeprecated: false, + description: 'text :: STRING', + name: 'text', + type: 'STRING', }, { - label: 'charset', - documentation: 'charset = UTF-8 :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=UTF-8, type=STRING}', + description: 'charset = UTF-8 :: STRING', + name: 'charset', + type: 'STRING', }, ], + signature: + 'apoc.text.bytes(text :: STRING, charset = UTF-8 :: STRING) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.text.camelCase': { - label: 'apoc.text.camelCase', - documentation: 'Converts the given `STRING` to camel case.', - parameters: [ + name: 'apoc.text.camelCase', + category: '', + description: 'Converts the given `STRING` to camel case.', + isBuiltIn: false, + argumentDescription: [ { - label: 'text', - documentation: 'text :: STRING', + isDeprecated: false, + description: 'text :: STRING', + name: 'text', + type: 'STRING', }, ], + signature: 'apoc.text.camelCase(text :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.text.capitalize': { - label: 'apoc.text.capitalize', - documentation: 'Capitalizes the first letter of the given `STRING`.', - parameters: [ + name: 'apoc.text.capitalize', + category: '', + description: 'Capitalizes the first letter of the given `STRING`.', + isBuiltIn: false, + argumentDescription: [ { - label: 'text', - documentation: 'text :: STRING', + isDeprecated: false, + description: 'text :: STRING', + name: 'text', + type: 'STRING', }, ], + signature: 'apoc.text.capitalize(text :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.text.capitalizeAll': { - label: 'apoc.text.capitalizeAll', - documentation: + name: 'apoc.text.capitalizeAll', + category: '', + description: 'Capitalizes the first letter of every word in the given `STRING`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'text', - documentation: 'text :: STRING', + isDeprecated: false, + description: 'text :: STRING', + name: 'text', + type: 'STRING', }, ], + signature: 'apoc.text.capitalizeAll(text :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.text.charAt': { - label: 'apoc.text.charAt', - documentation: + name: 'apoc.text.charAt', + category: '', + description: 'Returns the `INTEGER` value of the character at the given index.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'text', - documentation: 'text :: STRING', + isDeprecated: false, + description: 'text :: STRING', + name: 'text', + type: 'STRING', }, { - label: 'index', - documentation: 'index :: INTEGER', + isDeprecated: false, + description: 'index :: INTEGER', + name: 'index', + type: 'INTEGER', }, ], + signature: + 'apoc.text.charAt(text :: STRING, index :: INTEGER) :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, 'apoc.text.clean': { - label: 'apoc.text.clean', - documentation: + name: 'apoc.text.clean', + category: '', + description: 'Strips the given `STRING` of everything except alpha numeric characters and converts it to lower case.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'text', - documentation: 'text :: STRING', + isDeprecated: false, + description: 'text :: STRING', + name: 'text', + type: 'STRING', }, ], + signature: 'apoc.text.clean(text :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.text.code': { - label: 'apoc.text.code', - documentation: 'Converts the `INTEGER` value into a `STRING`.', - parameters: [ + name: 'apoc.text.code', + category: '', + description: 'Converts the `INTEGER` value into a `STRING`.', + isBuiltIn: false, + argumentDescription: [ { - label: 'codepoint', - documentation: 'codepoint :: INTEGER', + isDeprecated: false, + description: 'codepoint :: INTEGER', + name: 'codepoint', + type: 'INTEGER', }, ], + signature: 'apoc.text.code(codepoint :: INTEGER) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.text.compareCleaned': { - label: 'apoc.text.compareCleaned', - documentation: + name: 'apoc.text.compareCleaned', + category: '', + description: 'Compares two given `STRING` values stripped of everything except alpha numeric characters converted to lower case.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'text1', - documentation: 'text1 :: STRING', + isDeprecated: false, + description: 'text1 :: STRING', + name: 'text1', + type: 'STRING', }, { - label: 'text2', - documentation: 'text2 :: STRING', + isDeprecated: false, + description: 'text2 :: STRING', + name: 'text2', + type: 'STRING', }, ], + signature: + 'apoc.text.compareCleaned(text1 :: STRING, text2 :: STRING) :: BOOLEAN', + returnDescription: 'BOOLEAN', + aggregating: false, }, 'apoc.text.decapitalize': { - label: 'apoc.text.decapitalize', - documentation: + name: 'apoc.text.decapitalize', + category: '', + description: 'Turns the first letter of the given `STRING` from upper case to lower case.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'text', - documentation: 'text :: STRING', + isDeprecated: false, + description: 'text :: STRING', + name: 'text', + type: 'STRING', }, ], + signature: 'apoc.text.decapitalize(text :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.text.decapitalizeAll': { - label: 'apoc.text.decapitalizeAll', - documentation: + name: 'apoc.text.decapitalizeAll', + category: '', + description: 'Turns the first letter of every word in the given `STRING` to lower case.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'text', - documentation: 'text :: STRING', + isDeprecated: false, + description: 'text :: STRING', + name: 'text', + type: 'STRING', }, ], + signature: 'apoc.text.decapitalizeAll(text :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.text.distance': { - label: 'apoc.text.distance', - documentation: + name: 'apoc.text.distance', + category: '', + description: 'Compares the two given `STRING` values using the Levenshtein distance algorithm.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'text1', - documentation: 'text1 :: STRING', + isDeprecated: false, + description: 'text1 :: STRING', + name: 'text1', + type: 'STRING', }, { - label: 'text2', - documentation: 'text2 :: STRING', + isDeprecated: false, + description: 'text2 :: STRING', + name: 'text2', + type: 'STRING', }, ], + signature: + 'apoc.text.distance(text1 :: STRING, text2 :: STRING) :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, 'apoc.text.doubleMetaphone': { - label: 'apoc.text.doubleMetaphone', - documentation: + name: 'apoc.text.doubleMetaphone', + category: '', + description: 'Returns the double metaphone phonetic encoding of all words in the given `STRING` value.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'value', - documentation: 'value :: STRING', + isDeprecated: false, + description: 'value :: STRING', + name: 'value', + type: 'STRING', }, ], + signature: 'apoc.text.doubleMetaphone(value :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.text.format': { - label: 'apoc.text.format', - documentation: 'Formats the given `STRING` with the given parameters.', - parameters: [ + name: 'apoc.text.format', + category: '', + description: 'Formats the given `STRING` with the given parameters.', + isBuiltIn: false, + argumentDescription: [ { - label: 'text', - documentation: 'text :: STRING', + isDeprecated: false, + description: 'text :: STRING', + name: 'text', + type: 'STRING', }, { - label: 'params', - documentation: 'params :: LIST', + isDeprecated: false, + description: 'params :: LIST', + name: 'params', + type: 'LIST', }, { - label: 'language', - documentation: 'language = en :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=en, type=STRING}', + description: 'language = en :: STRING', + name: 'language', + type: 'STRING', }, ], + signature: + 'apoc.text.format(text :: STRING, params :: LIST, language = en :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.text.fuzzyMatch': { - label: 'apoc.text.fuzzyMatch', - documentation: + name: 'apoc.text.fuzzyMatch', + category: '', + description: 'Performs a fuzzy match search of the two given `STRING` values.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'text1', - documentation: 'text1 :: STRING', + isDeprecated: false, + description: 'text1 :: STRING', + name: 'text1', + type: 'STRING', }, { - label: 'text2', - documentation: 'text2 :: STRING', + isDeprecated: false, + description: 'text2 :: STRING', + name: 'text2', + type: 'STRING', }, ], + signature: + 'apoc.text.fuzzyMatch(text1 :: STRING, text2 :: STRING) :: BOOLEAN', + returnDescription: 'BOOLEAN', + aggregating: false, }, 'apoc.text.hammingDistance': { - label: 'apoc.text.hammingDistance', - documentation: + name: 'apoc.text.hammingDistance', + category: '', + description: 'Compares the two given `STRING` values using the Hamming distance algorithm.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'text1', - documentation: 'text1 :: STRING', + isDeprecated: false, + description: 'text1 :: STRING', + name: 'text1', + type: 'STRING', }, { - label: 'text2', - documentation: 'text2 :: STRING', + isDeprecated: false, + description: 'text2 :: STRING', + name: 'text2', + type: 'STRING', }, ], + signature: + 'apoc.text.hammingDistance(text1 :: STRING, text2 :: STRING) :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, 'apoc.text.hexCharAt': { - label: 'apoc.text.hexCharAt', - documentation: + name: 'apoc.text.hexCharAt', + category: '', + description: 'Returns the hexadecimal value of the given `STRING` at the given index.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'text', - documentation: 'text :: STRING', + isDeprecated: false, + description: 'text :: STRING', + name: 'text', + type: 'STRING', }, { - label: 'index', - documentation: 'index :: INTEGER', + isDeprecated: false, + description: 'index :: INTEGER', + name: 'index', + type: 'INTEGER', }, ], + signature: + 'apoc.text.hexCharAt(text :: STRING, index :: INTEGER) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.text.hexValue': { - label: 'apoc.text.hexValue', - documentation: 'Returns the hexadecimal value of the given value.', - parameters: [ + name: 'apoc.text.hexValue', + category: '', + description: 'Returns the hexadecimal value of the given value.', + isBuiltIn: false, + argumentDescription: [ { - label: 'value', - documentation: 'value :: INTEGER', + isDeprecated: false, + description: 'value :: INTEGER', + name: 'value', + type: 'INTEGER', }, ], + signature: 'apoc.text.hexValue(value :: INTEGER) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.text.indexOf': { - label: 'apoc.text.indexOf', - documentation: + name: 'apoc.text.indexOf', + category: '', + description: 'Returns the first occurrence of the lookup `STRING` in the given `STRING`, or -1 if not found.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'text', - documentation: 'text :: STRING', + isDeprecated: false, + description: 'text :: STRING', + name: 'text', + type: 'STRING', }, { - label: 'lookup', - documentation: 'lookup :: STRING', + isDeprecated: false, + description: 'lookup :: STRING', + name: 'lookup', + type: 'STRING', }, { - label: 'from', - documentation: 'from = 0 :: INTEGER', + isDeprecated: false, + default: 'DefaultParameterValue{value=0, type=INTEGER}', + description: 'from = 0 :: INTEGER', + name: 'from', + type: 'INTEGER', }, { - label: 'to', - documentation: 'to = -1 :: INTEGER', + isDeprecated: false, + default: 'DefaultParameterValue{value=-1, type=INTEGER}', + description: 'to = -1 :: INTEGER', + name: 'to', + type: 'INTEGER', }, ], + signature: + 'apoc.text.indexOf(text :: STRING, lookup :: STRING, from = 0 :: INTEGER, to = -1 :: INTEGER) :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, 'apoc.text.indexesOf': { - label: 'apoc.text.indexesOf', - documentation: + name: 'apoc.text.indexesOf', + category: '', + description: 'Returns all occurrences of the lookup `STRING` in the given `STRING`, or an empty list if not found.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'text', - documentation: 'text :: STRING', + isDeprecated: false, + description: 'text :: STRING', + name: 'text', + type: 'STRING', }, { - label: 'lookup', - documentation: 'lookup :: STRING', + isDeprecated: false, + description: 'lookup :: STRING', + name: 'lookup', + type: 'STRING', }, { - label: 'from', - documentation: 'from = 0 :: INTEGER', + isDeprecated: false, + default: 'DefaultParameterValue{value=0, type=INTEGER}', + description: 'from = 0 :: INTEGER', + name: 'from', + type: 'INTEGER', }, { - label: 'to', - documentation: 'to = -1 :: INTEGER', + isDeprecated: false, + default: 'DefaultParameterValue{value=-1, type=INTEGER}', + description: 'to = -1 :: INTEGER', + name: 'to', + type: 'INTEGER', }, ], + signature: + 'apoc.text.indexesOf(text :: STRING, lookup :: STRING, from = 0 :: INTEGER, to = -1 :: INTEGER) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.text.jaroWinklerDistance': { - label: 'apoc.text.jaroWinklerDistance', - documentation: + name: 'apoc.text.jaroWinklerDistance', + category: '', + description: 'Compares the two given `STRING` values using the Jaro-Winkler distance algorithm.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'text1', - documentation: 'text1 :: STRING', + isDeprecated: false, + description: 'text1 :: STRING', + name: 'text1', + type: 'STRING', }, { - label: 'text2', - documentation: 'text2 :: STRING', + isDeprecated: false, + description: 'text2 :: STRING', + name: 'text2', + type: 'STRING', }, ], + signature: + 'apoc.text.jaroWinklerDistance(text1 :: STRING, text2 :: STRING) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, 'apoc.text.join': { - label: 'apoc.text.join', - documentation: - 'Joins the given `STRING` values using the given delimiter.', - parameters: [ + name: 'apoc.text.join', + category: '', + description: 'Joins the given `STRING` values using the given delimiter.', + isBuiltIn: false, + argumentDescription: [ { - label: 'texts', - documentation: 'texts :: LIST', + isDeprecated: false, + description: 'texts :: LIST', + name: 'texts', + type: 'LIST', }, { - label: 'delimiter', - documentation: 'delimiter :: STRING', + isDeprecated: false, + description: 'delimiter :: STRING', + name: 'delimiter', + type: 'STRING', }, ], + signature: + 'apoc.text.join(texts :: LIST, delimiter :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.text.levenshteinDistance': { - label: 'apoc.text.levenshteinDistance', - documentation: + name: 'apoc.text.levenshteinDistance', + category: '', + description: 'Compares the given `STRING` values using the Levenshtein distance algorithm.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'text1', - documentation: 'text1 :: STRING', + isDeprecated: false, + description: 'text1 :: STRING', + name: 'text1', + type: 'STRING', }, { - label: 'text2', - documentation: 'text2 :: STRING', + isDeprecated: false, + description: 'text2 :: STRING', + name: 'text2', + type: 'STRING', }, ], + signature: + 'apoc.text.levenshteinDistance(text1 :: STRING, text2 :: STRING) :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, 'apoc.text.levenshteinSimilarity': { - label: 'apoc.text.levenshteinSimilarity', - documentation: + name: 'apoc.text.levenshteinSimilarity', + category: '', + description: 'Returns the similarity (a value within 0 and 1) between the two given `STRING` values based on the Levenshtein distance algorithm.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'text1', - documentation: 'text1 :: STRING', + isDeprecated: false, + description: 'text1 :: STRING', + name: 'text1', + type: 'STRING', }, { - label: 'text2', - documentation: 'text2 :: STRING', + isDeprecated: false, + description: 'text2 :: STRING', + name: 'text2', + type: 'STRING', }, ], + signature: + 'apoc.text.levenshteinSimilarity(text1 :: STRING, text2 :: STRING) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, 'apoc.text.lpad': { - label: 'apoc.text.lpad', - documentation: 'Left pads the given `STRING` by the given width.', - parameters: [ + name: 'apoc.text.lpad', + category: '', + description: 'Left pads the given `STRING` by the given width.', + isBuiltIn: false, + argumentDescription: [ { - label: 'text', - documentation: 'text :: STRING', + isDeprecated: false, + description: 'text :: STRING', + name: 'text', + type: 'STRING', }, { - label: 'count', - documentation: 'count :: INTEGER', + isDeprecated: false, + description: 'count :: INTEGER', + name: 'count', + type: 'INTEGER', }, { - label: 'delimiter', - documentation: 'delimiter = :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value= , type=STRING}', + description: 'delimiter = :: STRING', + name: 'delimiter', + type: 'STRING', }, ], + signature: + 'apoc.text.lpad(text :: STRING, count :: INTEGER, delimiter = :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.text.phonetic': { - label: 'apoc.text.phonetic', - documentation: + name: 'apoc.text.phonetic', + category: '', + description: 'Returns the US_ENGLISH phonetic soundex encoding of all words of the `STRING`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'text', - documentation: 'text :: STRING', + isDeprecated: false, + description: 'text :: STRING', + name: 'text', + type: 'STRING', }, ], + signature: 'apoc.text.phonetic(text :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.text.random': { - label: 'apoc.text.random', - documentation: + name: 'apoc.text.random', + category: '', + description: 'Generates a random `STRING` to the given length using a length parameter and an optional `STRING` of valid characters.\nUnsuitable for cryptographic use-cases.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'length', - documentation: 'length :: INTEGER', + isDeprecated: false, + description: 'length :: INTEGER', + name: 'length', + type: 'INTEGER', }, { - label: 'valid', - documentation: 'valid = A-Za-z0-9 :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=A-Za-z0-9, type=STRING}', + description: 'valid = A-Za-z0-9 :: STRING', + name: 'valid', + type: 'STRING', }, ], + signature: + 'apoc.text.random(length :: INTEGER, valid = A-Za-z0-9 :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.text.regexGroups': { - label: 'apoc.text.regexGroups', - documentation: + name: 'apoc.text.regexGroups', + category: '', + description: 'Returns all groups matching the given regular expression in the given text.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'text', - documentation: 'text :: STRING', + isDeprecated: false, + description: 'text :: STRING', + name: 'text', + type: 'STRING', }, { - label: 'regex', - documentation: 'regex :: STRING', + isDeprecated: false, + description: 'regex :: STRING', + name: 'regex', + type: 'STRING', }, ], + signature: + 'apoc.text.regexGroups(text :: STRING, regex :: STRING) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.text.regreplace': { - label: 'apoc.text.regreplace', - documentation: + name: 'apoc.text.regreplace', + category: '', + description: 'Finds and replaces all matches found by the given regular expression with the given replacement.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'text', - documentation: 'text :: STRING', + isDeprecated: false, + description: 'text :: STRING', + name: 'text', + type: 'STRING', }, { - label: 'regex', - documentation: 'regex :: STRING', + isDeprecated: false, + description: 'regex :: STRING', + name: 'regex', + type: 'STRING', }, { - label: 'replacement', - documentation: 'replacement :: STRING', + isDeprecated: false, + description: 'replacement :: STRING', + name: 'replacement', + type: 'STRING', }, ], + signature: + 'apoc.text.regreplace(text :: STRING, regex :: STRING, replacement :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.text.repeat': { - label: 'apoc.text.repeat', - documentation: + name: 'apoc.text.repeat', + category: '', + description: 'Returns the result of the given item multiplied by the given count.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'item', - documentation: 'item :: STRING', + isDeprecated: false, + description: 'item :: STRING', + name: 'item', + type: 'STRING', }, { - label: 'count', - documentation: 'count :: INTEGER', + isDeprecated: false, + description: 'count :: INTEGER', + name: 'count', + type: 'INTEGER', }, ], + signature: 'apoc.text.repeat(item :: STRING, count :: INTEGER) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.text.replace': { - label: 'apoc.text.replace', - documentation: + name: 'apoc.text.replace', + category: '', + description: 'Finds and replaces all matches found by the given regular expression with the given replacement.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'text', - documentation: 'text :: STRING', + isDeprecated: false, + description: 'text :: STRING', + name: 'text', + type: 'STRING', }, { - label: 'regex', - documentation: 'regex :: STRING', + isDeprecated: false, + description: 'regex :: STRING', + name: 'regex', + type: 'STRING', }, { - label: 'replacement', - documentation: 'replacement :: STRING', + isDeprecated: false, + description: 'replacement :: STRING', + name: 'replacement', + type: 'STRING', }, ], + signature: + 'apoc.text.replace(text :: STRING, regex :: STRING, replacement :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.text.rpad': { - label: 'apoc.text.rpad', - documentation: 'Right pads the given `STRING` by the given width.', - parameters: [ + name: 'apoc.text.rpad', + category: '', + description: 'Right pads the given `STRING` by the given width.', + isBuiltIn: false, + argumentDescription: [ { - label: 'text', - documentation: 'text :: STRING', + isDeprecated: false, + description: 'text :: STRING', + name: 'text', + type: 'STRING', }, { - label: 'count', - documentation: 'count :: INTEGER', + isDeprecated: false, + description: 'count :: INTEGER', + name: 'count', + type: 'INTEGER', }, { - label: 'delimiter', - documentation: 'delimiter = :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value= , type=STRING}', + description: 'delimiter = :: STRING', + name: 'delimiter', + type: 'STRING', }, ], + signature: + 'apoc.text.rpad(text :: STRING, count :: INTEGER, delimiter = :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.text.slug': { - label: 'apoc.text.slug', - documentation: + name: 'apoc.text.slug', + category: '', + description: 'Replaces the whitespace in the given `STRING` with the given delimiter.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'text', - documentation: 'text :: STRING', + isDeprecated: false, + description: 'text :: STRING', + name: 'text', + type: 'STRING', }, { - label: 'delimiter', - documentation: 'delimiter = - :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=-, type=STRING}', + description: 'delimiter = - :: STRING', + name: 'delimiter', + type: 'STRING', }, ], + signature: + 'apoc.text.slug(text :: STRING, delimiter = - :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.text.snakeCase': { - label: 'apoc.text.snakeCase', - documentation: 'Converts the given `STRING` to snake case.', - parameters: [ + name: 'apoc.text.snakeCase', + category: '', + description: 'Converts the given `STRING` to snake case.', + isBuiltIn: false, + argumentDescription: [ { - label: 'text', - documentation: 'text :: STRING', + isDeprecated: false, + description: 'text :: STRING', + name: 'text', + type: 'STRING', }, ], + signature: 'apoc.text.snakeCase(text :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.text.sorensenDiceSimilarity': { - label: 'apoc.text.sorensenDiceSimilarity', - documentation: + name: 'apoc.text.sorensenDiceSimilarity', + category: '', + description: 'Compares the two given `STRING` values using the Sørensen–Dice coefficient formula, with the provided IETF language tag.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'text1', - documentation: 'text1 :: STRING', + isDeprecated: false, + description: 'text1 :: STRING', + name: 'text1', + type: 'STRING', }, { - label: 'text2', - documentation: 'text2 :: STRING', + isDeprecated: false, + description: 'text2 :: STRING', + name: 'text2', + type: 'STRING', }, { - label: 'languageTag', - documentation: 'languageTag = en :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=en, type=STRING}', + description: 'languageTag = en :: STRING', + name: 'languageTag', + type: 'STRING', }, ], + signature: + 'apoc.text.sorensenDiceSimilarity(text1 :: STRING, text2 :: STRING, languageTag = en :: STRING) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, 'apoc.text.split': { - label: 'apoc.text.split', - documentation: + name: 'apoc.text.split', + category: '', + description: 'Splits the given `STRING` using a given regular expression as a separator.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'text', - documentation: 'text :: STRING', + isDeprecated: false, + description: 'text :: STRING', + name: 'text', + type: 'STRING', }, { - label: 'regex', - documentation: 'regex :: STRING', + isDeprecated: false, + description: 'regex :: STRING', + name: 'regex', + type: 'STRING', }, { - label: 'limit', - documentation: 'limit = 0 :: INTEGER', + isDeprecated: false, + default: 'DefaultParameterValue{value=0, type=INTEGER}', + description: 'limit = 0 :: INTEGER', + name: 'limit', + type: 'INTEGER', }, ], + signature: + 'apoc.text.split(text :: STRING, regex :: STRING, limit = 0 :: INTEGER) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'apoc.text.swapCase': { - label: 'apoc.text.swapCase', - documentation: 'Swaps the cases in the given `STRING`.', - parameters: [ + name: 'apoc.text.swapCase', + category: '', + description: 'Swaps the cases in the given `STRING`.', + isBuiltIn: false, + argumentDescription: [ { - label: 'text', - documentation: 'text :: STRING', + isDeprecated: false, + description: 'text :: STRING', + name: 'text', + type: 'STRING', }, ], + signature: 'apoc.text.swapCase(text :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.text.toCypher': { - label: 'apoc.text.toCypher', - documentation: 'Converts the given value to a Cypher property `STRING`.', - parameters: [ + name: 'apoc.text.toCypher', + category: '', + description: 'Converts the given value to a Cypher property `STRING`.', + isBuiltIn: false, + argumentDescription: [ { - label: 'value', - documentation: 'value :: ANY', + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', }, ], + signature: + 'apoc.text.toCypher(value :: ANY, config = {} :: MAP) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.text.toUpperCase': { - label: 'apoc.text.toUpperCase', - documentation: 'Converts the given `STRING` to upper case.', - parameters: [ + name: 'apoc.text.toUpperCase', + category: '', + description: 'Converts the given `STRING` to upper case.', + isBuiltIn: false, + argumentDescription: [ { - label: 'text', - documentation: 'text :: STRING', + isDeprecated: false, + description: 'text :: STRING', + name: 'text', + type: 'STRING', }, ], + signature: 'apoc.text.toUpperCase(text :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.text.upperCamelCase': { - label: 'apoc.text.upperCamelCase', - documentation: 'Converts the given `STRING` to upper camel case.', - parameters: [ + name: 'apoc.text.upperCamelCase', + category: '', + description: 'Converts the given `STRING` to upper camel case.', + isBuiltIn: false, + argumentDescription: [ { - label: 'text', - documentation: 'text :: STRING', + isDeprecated: false, + description: 'text :: STRING', + name: 'text', + type: 'STRING', }, ], + signature: 'apoc.text.upperCamelCase(text :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.text.urldecode': { - label: 'apoc.text.urldecode', - documentation: 'Decodes the given URL encoded `STRING`.', - parameters: [ + name: 'apoc.text.urldecode', + category: '', + description: 'Decodes the given URL encoded `STRING`.', + isBuiltIn: false, + argumentDescription: [ { - label: 'text', - documentation: 'text :: STRING', + isDeprecated: false, + description: 'text :: STRING', + name: 'text', + type: 'STRING', }, ], + signature: 'apoc.text.urldecode(text :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.text.urlencode': { - label: 'apoc.text.urlencode', - documentation: 'Encodes the given URL `STRING`.', - parameters: [ + name: 'apoc.text.urlencode', + category: '', + description: 'Encodes the given URL `STRING`.', + isBuiltIn: false, + argumentDescription: [ { - label: 'text', - documentation: 'text :: STRING', + isDeprecated: false, + description: 'text :: STRING', + name: 'text', + type: 'STRING', }, ], + signature: 'apoc.text.urlencode(text :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.util.compress': { - label: 'apoc.util.compress', - documentation: 'Zips the given `STRING`.', - parameters: [ + name: 'apoc.util.compress', + category: '', + description: 'Zips the given `STRING`.', + isBuiltIn: false, + argumentDescription: [ { - label: 'data', - documentation: 'data :: STRING', + isDeprecated: false, + description: 'data :: STRING', + name: 'data', + type: 'STRING', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', }, ], + signature: + 'apoc.util.compress(data :: STRING, config = {} :: MAP) :: BYTEARRAY', + returnDescription: 'BYTEARRAY', + aggregating: false, }, 'apoc.util.decompress': { - label: 'apoc.util.decompress', - documentation: 'Unzips the given byte array.', - parameters: [ + name: 'apoc.util.decompress', + category: '', + description: 'Unzips the given byte array.', + isBuiltIn: false, + argumentDescription: [ { - label: 'data', - documentation: 'data :: BYTEARRAY', + isDeprecated: false, + description: 'data :: BYTEARRAY', + name: 'data', + type: 'BYTEARRAY', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', }, ], + signature: + 'apoc.util.decompress(data :: BYTEARRAY, config = {} :: MAP) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.util.md5': { - label: 'apoc.util.md5', - documentation: + name: 'apoc.util.md5', + category: '', + description: 'Returns the MD5 checksum of the concatenation of all `STRING` values in the given `LIST`.\nMD5 is a weak hashing algorithm which is unsuitable for cryptographic use-cases.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'values', - documentation: 'values :: LIST', + isDeprecated: false, + description: 'values :: LIST', + name: 'values', + type: 'LIST', }, ], + signature: 'apoc.util.md5(values :: LIST) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.util.sha1': { - label: 'apoc.util.sha1', - documentation: + name: 'apoc.util.sha1', + category: '', + description: 'Returns the SHA1 of the concatenation of all `STRING` values in the given `LIST`.\nSHA1 is a weak hashing algorithm which is unsuitable for cryptographic use-cases.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'values', - documentation: 'values :: LIST', + isDeprecated: false, + description: 'values :: LIST', + name: 'values', + type: 'LIST', }, ], + signature: 'apoc.util.sha1(values :: LIST) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.util.sha256': { - label: 'apoc.util.sha256', - documentation: + name: 'apoc.util.sha256', + category: '', + description: 'Returns the SHA256 of the concatenation of all `STRING` values in the given `LIST`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'values', - documentation: 'values :: LIST', + isDeprecated: false, + description: 'values :: LIST', + name: 'values', + type: 'LIST', }, ], + signature: 'apoc.util.sha256(values :: LIST) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.util.sha384': { - label: 'apoc.util.sha384', - documentation: + name: 'apoc.util.sha384', + category: '', + description: 'Returns the SHA384 of the concatenation of all `STRING` values in the given `LIST`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'values', - documentation: 'values :: LIST', + isDeprecated: false, + description: 'values :: LIST', + name: 'values', + type: 'LIST', }, ], + signature: 'apoc.util.sha384(values :: LIST) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.util.sha512': { - label: 'apoc.util.sha512', - documentation: + name: 'apoc.util.sha512', + category: '', + description: 'Returns the SHA512 of the concatenation of all `STRING` values in the `LIST`.', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'values', - documentation: 'values :: LIST', + isDeprecated: false, + description: 'values :: LIST', + name: 'values', + type: 'LIST', }, ], + signature: 'apoc.util.sha512(values :: LIST) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.util.validatePredicate': { - label: 'apoc.util.validatePredicate', - documentation: + name: 'apoc.util.validatePredicate', + category: '', + description: 'If the given predicate is true an exception is thrown, otherwise it returns true (for use inside `WHERE` subclauses).', - parameters: [ + isBuiltIn: false, + argumentDescription: [ { - label: 'predicate', - documentation: 'predicate :: BOOLEAN', + isDeprecated: false, + description: 'predicate :: BOOLEAN', + name: 'predicate', + type: 'BOOLEAN', }, { - label: 'message', - documentation: 'message :: STRING', + isDeprecated: false, + description: 'message :: STRING', + name: 'message', + type: 'STRING', }, { - label: 'params', - documentation: 'params :: LIST', + isDeprecated: false, + description: 'params :: LIST', + name: 'params', + type: 'LIST', }, ], + signature: + 'apoc.util.validatePredicate(predicate :: BOOLEAN, message :: STRING, params :: LIST) :: BOOLEAN', + returnDescription: 'BOOLEAN', + aggregating: false, }, 'apoc.version': { - label: 'apoc.version', - documentation: 'Returns the APOC version currently installed.', - parameters: [], + name: 'apoc.version', + category: '', + description: 'Returns the APOC version currently installed.', + isBuiltIn: false, + argumentDescription: [], + signature: 'apoc.version() :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'apoc.xml.parse': { - label: 'apoc.xml.parse', - documentation: 'Parses the given XML `STRING` as a `MAP`.', - parameters: [ + name: 'apoc.xml.parse', + category: '', + description: 'Parses the given XML `STRING` as a `MAP`.', + isBuiltIn: false, + argumentDescription: [ { - label: 'data', - documentation: 'data :: STRING', + isDeprecated: false, + description: 'data :: STRING', + name: 'data', + type: 'STRING', }, { - label: 'path', - documentation: 'path = / :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=/, type=STRING}', + description: 'path = / :: STRING', + name: 'path', + type: 'STRING', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', }, { - label: 'simple', - documentation: 'simple = false :: BOOLEAN', + isDeprecated: false, + default: 'DefaultParameterValue{value=false, type=BOOLEAN}', + description: 'simple = false :: BOOLEAN', + name: 'simple', + type: 'BOOLEAN', }, ], + signature: + 'apoc.xml.parse(data :: STRING, path = / :: STRING, config = {} :: MAP, simple = false :: BOOLEAN) :: MAP', + returnDescription: 'MAP', + aggregating: false, }, asin: { - label: 'asin', - documentation: 'Returns the arcsine of a `FLOAT` in radians.', - parameters: [ + name: 'asin', + category: 'Trigonometric', + description: 'Returns the arcsine of a `FLOAT` in radians.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: FLOAT', + isDeprecated: false, + description: 'input :: FLOAT', + name: 'input', + type: 'FLOAT', }, ], + signature: 'asin(input :: FLOAT) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, atan: { - label: 'atan', - documentation: 'Returns the arctangent of a `FLOAT` in radians.', - parameters: [ + name: 'atan', + category: 'Trigonometric', + description: 'Returns the arctangent of a `FLOAT` in radians.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: FLOAT', + isDeprecated: false, + description: 'input :: FLOAT', + name: 'input', + type: 'FLOAT', }, ], + signature: 'atan(input :: FLOAT) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, atan2: { - label: 'atan2', - documentation: + name: 'atan2', + category: 'Trigonometric', + description: 'Returns the arctangent2 of a set of coordinates in radians.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'y', - documentation: 'y :: FLOAT', + isDeprecated: false, + description: 'y :: FLOAT', + name: 'y', + type: 'FLOAT', }, { - label: 'x', - documentation: 'x :: FLOAT', + isDeprecated: false, + description: 'x :: FLOAT', + name: 'x', + type: 'FLOAT', }, ], + signature: 'atan2(y :: FLOAT, x :: FLOAT) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, avg: { - label: 'avg', - documentation: + name: 'avg', + category: 'Aggregating', + description: 'Returns the average of a set of `INTEGER`, `FLOAT` or `DURATION` values.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: INTEGER | FLOAT | DURATION', + isDeprecated: false, + description: 'input :: INTEGER | FLOAT | DURATION', + name: 'input', + type: 'INTEGER | FLOAT | DURATION', }, ], + signature: + 'avg(input :: INTEGER | FLOAT | DURATION) :: INTEGER | FLOAT | DURATION', + returnDescription: 'INTEGER | FLOAT | DURATION', + aggregating: true, }, ceil: { - label: 'ceil', - documentation: + name: 'ceil', + category: 'Numeric', + description: 'Returns the smallest `FLOAT` that is greater than or equal to a number and equal to an `INTEGER`.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: FLOAT', + isDeprecated: false, + description: 'input :: FLOAT', + name: 'input', + type: 'FLOAT', }, ], + signature: 'ceil(input :: FLOAT) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, char_length: { - label: 'char_length', - documentation: 'Returns the number of Unicode characters in a `STRING`.', - parameters: [ + name: 'char_length', + category: 'Scalar', + description: 'Returns the number of Unicode characters in a `STRING`.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: STRING', + isDeprecated: false, + description: 'input :: STRING', + name: 'input', + type: 'STRING', }, ], + signature: 'char_length(input :: STRING) :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, character_length: { - label: 'character_length', - documentation: 'Returns the number of Unicode characters in a `STRING`.', - parameters: [ + name: 'character_length', + category: 'Scalar', + description: 'Returns the number of Unicode characters in a `STRING`.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: STRING', + isDeprecated: false, + description: 'input :: STRING', + name: 'input', + type: 'STRING', }, ], + signature: 'character_length(input :: STRING) :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, coalesce: { - label: 'coalesce', - documentation: - 'Returns the first non-null value in a list of expressions.', - parameters: [ + name: 'coalesce', + category: 'Scalar', + description: 'Returns the first non-null value in a list of expressions.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: ANY', + isDeprecated: false, + description: 'input :: ANY', + name: 'input', + type: 'ANY', }, ], + signature: 'coalesce(input :: ANY) :: ANY', + returnDescription: 'ANY', + aggregating: false, }, collect: { - label: 'collect', - documentation: + name: 'collect', + category: 'Aggregating', + description: 'Returns a list containing the values returned by an expression.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: ANY', + isDeprecated: false, + description: 'input :: ANY', + name: 'input', + type: 'ANY', }, ], + signature: 'collect(input :: ANY) :: LIST', + returnDescription: 'LIST', + aggregating: true, }, cos: { - label: 'cos', - documentation: 'Returns the cosine of a `FLOAT`.', - parameters: [ + name: 'cos', + category: 'Trigonometric', + description: 'Returns the cosine of a `FLOAT`.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: FLOAT', + isDeprecated: false, + description: 'input :: FLOAT', + name: 'input', + type: 'FLOAT', }, ], + signature: 'cos(input :: FLOAT) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, cot: { - label: 'cot', - documentation: 'Returns the cotangent of a `FLOAT`.', - parameters: [ + name: 'cot', + category: 'Trigonometric', + description: 'Returns the cotangent of a `FLOAT`.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: FLOAT', + isDeprecated: false, + description: 'input :: FLOAT', + name: 'input', + type: 'FLOAT', }, ], + signature: 'cot(input :: FLOAT) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, count: { - label: 'count', - documentation: 'Returns the number of values or rows.', - parameters: [ + name: 'count', + category: 'Aggregating', + description: 'Returns the number of values or rows.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: ANY', + isDeprecated: false, + description: 'input :: ANY', + name: 'input', + type: 'ANY', }, ], + signature: 'count(input :: ANY) :: INTEGER', + returnDescription: 'INTEGER', + aggregating: true, }, date: { - label: 'date', - documentation: 'Creates a `DATE` instant.', - parameters: [ + name: 'date', + category: 'Temporal', + description: 'Creates a `DATE` instant.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + isDeprecated: false, + default: + 'DefaultParameterValue{value=DEFAULT_TEMPORAL_ARGUMENT, type=ANY}', + description: 'input = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + name: 'input', + type: 'ANY', }, ], + signature: 'date(input = DEFAULT_TEMPORAL_ARGUMENT :: ANY) :: DATE', + returnDescription: 'DATE', + aggregating: false, }, 'date.realtime': { - label: 'date.realtime', - documentation: + name: 'date.realtime', + category: 'Temporal', + description: 'Returns the current `DATE` instant using the realtime clock.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'timezone', - documentation: 'timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + isDeprecated: false, + default: + 'DefaultParameterValue{value=DEFAULT_TEMPORAL_ARGUMENT, type=ANY}', + description: 'timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + name: 'timezone', + type: 'ANY', }, ], + signature: + 'date.realtime(timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY) :: DATE', + returnDescription: 'DATE', + aggregating: false, }, 'date.statement': { - label: 'date.statement', - documentation: + name: 'date.statement', + category: 'Temporal', + description: 'Returns the current `DATE` instant using the statement clock.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'timezone', - documentation: 'timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + isDeprecated: false, + default: + 'DefaultParameterValue{value=DEFAULT_TEMPORAL_ARGUMENT, type=ANY}', + description: 'timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + name: 'timezone', + type: 'ANY', }, ], + signature: + 'date.statement(timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY) :: DATE', + returnDescription: 'DATE', + aggregating: false, }, 'date.transaction': { - label: 'date.transaction', - documentation: + name: 'date.transaction', + category: 'Temporal', + description: 'Returns the current `DATE` instant using the transaction clock.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'timezone', - documentation: 'timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + isDeprecated: false, + default: + 'DefaultParameterValue{value=DEFAULT_TEMPORAL_ARGUMENT, type=ANY}', + description: 'timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + name: 'timezone', + type: 'ANY', }, ], + signature: + 'date.transaction(timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY) :: DATE', + returnDescription: 'DATE', + aggregating: false, }, 'date.truncate': { - label: 'date.truncate', - documentation: + name: 'date.truncate', + category: 'Temporal', + description: 'Truncates the given temporal value to a `DATE` instant using the specified unit.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'unit', - documentation: 'unit :: STRING', + isDeprecated: false, + description: 'unit :: STRING', + name: 'unit', + type: 'STRING', }, { - label: 'input', - documentation: 'input = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + isDeprecated: false, + default: + 'DefaultParameterValue{value=DEFAULT_TEMPORAL_ARGUMENT, type=ANY}', + description: 'input = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + name: 'input', + type: 'ANY', }, { - label: 'fields', - documentation: 'fields = null :: MAP', + isDeprecated: false, + default: 'DefaultParameterValue{value=null, type=MAP}', + description: 'fields = null :: MAP', + name: 'fields', + type: 'MAP', }, ], + signature: + 'date.truncate(unit :: STRING, input = DEFAULT_TEMPORAL_ARGUMENT :: ANY, fields = null :: MAP) :: DATE', + returnDescription: 'DATE', + aggregating: false, }, datetime: { - label: 'datetime', - documentation: 'Creates a `ZONED DATETIME` instant.', - parameters: [ + name: 'datetime', + category: 'Temporal', + description: 'Creates a `ZONED DATETIME` instant.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + isDeprecated: false, + default: + 'DefaultParameterValue{value=DEFAULT_TEMPORAL_ARGUMENT, type=ANY}', + description: 'input = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + name: 'input', + type: 'ANY', }, ], + signature: + 'datetime(input = DEFAULT_TEMPORAL_ARGUMENT :: ANY) :: ZONED DATETIME', + returnDescription: 'ZONED DATETIME', + aggregating: false, }, 'datetime.fromepoch': { - label: 'datetime.fromepoch', - documentation: + name: 'datetime.fromepoch', + category: 'Temporal', + description: 'Creates a `ZONED DATETIME` given the seconds and nanoseconds since the start of the epoch.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'seconds', - documentation: 'seconds :: INTEGER | FLOAT', + isDeprecated: false, + description: 'seconds :: INTEGER | FLOAT', + name: 'seconds', + type: 'INTEGER | FLOAT', }, { - label: 'nanoseconds', - documentation: 'nanoseconds :: INTEGER | FLOAT', + isDeprecated: false, + description: 'nanoseconds :: INTEGER | FLOAT', + name: 'nanoseconds', + type: 'INTEGER | FLOAT', }, ], + signature: + 'datetime.fromepoch(seconds :: INTEGER | FLOAT, nanoseconds :: INTEGER | FLOAT) :: ZONED DATETIME', + returnDescription: 'ZONED DATETIME', + aggregating: false, }, 'datetime.fromepochmillis': { - label: 'datetime.fromepochmillis', - documentation: + name: 'datetime.fromepochmillis', + category: 'Temporal', + description: 'Creates a `ZONED DATETIME` given the milliseconds since the start of the epoch.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'milliseconds', - documentation: 'milliseconds :: INTEGER | FLOAT', + isDeprecated: false, + description: 'milliseconds :: INTEGER | FLOAT', + name: 'milliseconds', + type: 'INTEGER | FLOAT', }, ], + signature: + 'datetime.fromepochmillis(milliseconds :: INTEGER | FLOAT) :: ZONED DATETIME', + returnDescription: 'ZONED DATETIME', + aggregating: false, }, 'datetime.realtime': { - label: 'datetime.realtime', - documentation: + name: 'datetime.realtime', + category: 'Temporal', + description: 'Returns the current `ZONED DATETIME` instant using the realtime clock.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'timezone', - documentation: 'timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + isDeprecated: false, + default: + 'DefaultParameterValue{value=DEFAULT_TEMPORAL_ARGUMENT, type=ANY}', + description: 'timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + name: 'timezone', + type: 'ANY', }, ], + signature: + 'datetime.realtime(timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY) :: ZONED DATETIME', + returnDescription: 'ZONED DATETIME', + aggregating: false, }, 'datetime.statement': { - label: 'datetime.statement', - documentation: + name: 'datetime.statement', + category: 'Temporal', + description: 'Returns the current `ZONED DATETIME` instant using the statement clock.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'timezone', - documentation: 'timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + isDeprecated: false, + default: + 'DefaultParameterValue{value=DEFAULT_TEMPORAL_ARGUMENT, type=ANY}', + description: 'timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + name: 'timezone', + type: 'ANY', }, ], + signature: + 'datetime.statement(timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY) :: ZONED DATETIME', + returnDescription: 'ZONED DATETIME', + aggregating: false, }, 'datetime.transaction': { - label: 'datetime.transaction', - documentation: + name: 'datetime.transaction', + category: 'Temporal', + description: 'Returns the current `ZONED DATETIME` instant using the transaction clock.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'timezone', - documentation: 'timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + isDeprecated: false, + default: + 'DefaultParameterValue{value=DEFAULT_TEMPORAL_ARGUMENT, type=ANY}', + description: 'timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + name: 'timezone', + type: 'ANY', }, ], + signature: + 'datetime.transaction(timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY) :: ZONED DATETIME', + returnDescription: 'ZONED DATETIME', + aggregating: false, }, 'datetime.truncate': { - label: 'datetime.truncate', - documentation: + name: 'datetime.truncate', + category: 'Temporal', + description: 'Truncates the given temporal value to a `ZONED DATETIME` instant using the specified unit.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'unit', - documentation: 'unit :: STRING', + isDeprecated: false, + description: 'unit :: STRING', + name: 'unit', + type: 'STRING', }, { - label: 'input', - documentation: 'input = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + isDeprecated: false, + default: + 'DefaultParameterValue{value=DEFAULT_TEMPORAL_ARGUMENT, type=ANY}', + description: 'input = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + name: 'input', + type: 'ANY', }, { - label: 'fields', - documentation: 'fields = null :: MAP', + isDeprecated: false, + default: 'DefaultParameterValue{value=null, type=MAP}', + description: 'fields = null :: MAP', + name: 'fields', + type: 'MAP', }, ], + signature: + 'datetime.truncate(unit :: STRING, input = DEFAULT_TEMPORAL_ARGUMENT :: ANY, fields = null :: MAP) :: ZONED DATETIME', + returnDescription: 'ZONED DATETIME', + aggregating: false, }, 'db.nameFromElementId': { - label: 'db.nameFromElementId', - documentation: 'Resolves the database name for the given element id', - parameters: [ + name: 'db.nameFromElementId', + category: 'Database', + description: 'Resolves the database name for the given element id', + isBuiltIn: true, + argumentDescription: [ { - label: 'elementId', - documentation: 'elementId :: STRING', + isDeprecated: false, + description: 'elementId :: STRING', + name: 'elementId', + type: 'STRING', }, ], + signature: 'db.nameFromElementId(elementId :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, degrees: { - label: 'degrees', - documentation: 'Converts radians to degrees.', - parameters: [ + name: 'degrees', + category: 'Trigonometric', + description: 'Converts radians to degrees.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: FLOAT', + isDeprecated: false, + description: 'input :: FLOAT', + name: 'input', + type: 'FLOAT', }, ], + signature: 'degrees(input :: FLOAT) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, duration: { - label: 'duration', - documentation: 'Creates a `DURATION` value.', - parameters: [ + name: 'duration', + category: 'Temporal', + description: 'Creates a `DURATION` value.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: ANY', + isDeprecated: false, + description: 'input :: ANY', + name: 'input', + type: 'ANY', }, ], + signature: 'duration(input :: ANY) :: DURATION', + returnDescription: 'DURATION', + aggregating: false, }, 'duration.between': { - label: 'duration.between', - documentation: + name: 'duration.between', + category: 'Temporal', + description: 'Computes the `DURATION` between the `from` instant (inclusive) and the `to` instant (exclusive) in logical units.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'from', - documentation: 'from :: ANY', + isDeprecated: false, + description: 'from :: ANY', + name: 'from', + type: 'ANY', }, { - label: 'to', - documentation: 'to :: ANY', + isDeprecated: false, + description: 'to :: ANY', + name: 'to', + type: 'ANY', }, ], + signature: 'duration.between(from :: ANY, to :: ANY) :: DURATION', + returnDescription: 'DURATION', + aggregating: false, }, 'duration.inDays': { - label: 'duration.inDays', - documentation: + name: 'duration.inDays', + category: 'Temporal', + description: 'Computes the `DURATION` between the `from` instant (inclusive) and the `to` instant (exclusive) in days.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'from', - documentation: 'from :: ANY', + isDeprecated: false, + description: 'from :: ANY', + name: 'from', + type: 'ANY', }, { - label: 'to', - documentation: 'to :: ANY', + isDeprecated: false, + description: 'to :: ANY', + name: 'to', + type: 'ANY', }, ], + signature: 'duration.inDays(from :: ANY, to :: ANY) :: DURATION', + returnDescription: 'DURATION', + aggregating: false, }, 'duration.inMonths': { - label: 'duration.inMonths', - documentation: + name: 'duration.inMonths', + category: 'Temporal', + description: 'Computes the `DURATION` between the `from` instant (inclusive) and the `to` instant (exclusive) in months.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'from', - documentation: 'from :: ANY', + isDeprecated: false, + description: 'from :: ANY', + name: 'from', + type: 'ANY', }, { - label: 'to', - documentation: 'to :: ANY', + isDeprecated: false, + description: 'to :: ANY', + name: 'to', + type: 'ANY', }, ], + signature: 'duration.inMonths(from :: ANY, to :: ANY) :: DURATION', + returnDescription: 'DURATION', + aggregating: false, }, 'duration.inSeconds': { - label: 'duration.inSeconds', - documentation: + name: 'duration.inSeconds', + category: 'Temporal', + description: 'Computes the `DURATION` between the `from` instant (inclusive) and the `to` instant (exclusive) in seconds.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'from', - documentation: 'from :: ANY', + isDeprecated: false, + description: 'from :: ANY', + name: 'from', + type: 'ANY', }, { - label: 'to', - documentation: 'to :: ANY', + isDeprecated: false, + description: 'to :: ANY', + name: 'to', + type: 'ANY', }, ], + signature: 'duration.inSeconds(from :: ANY, to :: ANY) :: DURATION', + returnDescription: 'DURATION', + aggregating: false, }, e: { - label: 'e', - documentation: 'Returns the base of the natural logarithm, e.', - parameters: [], + name: 'e', + category: 'Logarithmic', + description: 'Returns the base of the natural logarithm, e.', + isBuiltIn: true, + argumentDescription: [], + signature: 'e() :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, elementId: { - label: 'elementId', - documentation: 'Returns the element id of a `NODE` or `RELATIONSHIP`.', - parameters: [ + name: 'elementId', + category: 'Scalar', + description: 'Returns the element id of a `NODE` or `RELATIONSHIP`.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: NODE | RELATIONSHIP', + isDeprecated: false, + description: 'input :: NODE | RELATIONSHIP', + name: 'input', + type: 'NODE | RELATIONSHIP', }, ], + signature: 'elementId(input :: NODE | RELATIONSHIP) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, endNode: { - label: 'endNode', - documentation: 'Returns the end `NODE` of a `RELATIONSHIP`.', - parameters: [ + name: 'endNode', + category: 'Scalar', + description: 'Returns the end `NODE` of a `RELATIONSHIP`.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: RELATIONSHIP', + isDeprecated: false, + description: 'input :: RELATIONSHIP', + name: 'input', + type: 'RELATIONSHIP', }, ], + signature: 'endNode(input :: RELATIONSHIP) :: NODE', + returnDescription: 'NODE', + aggregating: false, }, exists: { - label: 'exists', - documentation: + name: 'exists', + category: 'Predicate', + description: 'Returns true if a match for the pattern exists in the graph.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: ANY', + isDeprecated: false, + description: 'input :: ANY', + name: 'input', + type: 'ANY', }, ], + signature: 'exists(input :: ANY) :: BOOLEAN', + returnDescription: 'BOOLEAN', + aggregating: false, }, exp: { - label: 'exp', - documentation: + name: 'exp', + category: 'Logarithmic', + description: 'Returns e^n, where e is the base of the natural logarithm, and n is the value of the argument expression.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: FLOAT', + isDeprecated: false, + description: 'input :: FLOAT', + name: 'input', + type: 'FLOAT', }, ], + signature: 'exp(input :: FLOAT) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, file: { - label: 'file', - documentation: + name: 'file', + category: 'Scalar', + description: 'Returns the absolute path of the file that LOAD CSV is using.', - parameters: [], + isBuiltIn: true, + argumentDescription: [], + signature: 'file() :: STRING', + returnDescription: 'STRING', + aggregating: false, }, floor: { - label: 'floor', - documentation: + name: 'floor', + category: 'Numeric', + description: 'Returns the largest `FLOAT` that is less than or equal to a number and equal to an `INTEGER`.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ + { + isDeprecated: false, + description: 'input :: FLOAT', + name: 'input', + type: 'FLOAT', + }, + ], + signature: 'floor(input :: FLOAT) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, + }, + 'gds.alpha.linkprediction.adamicAdar': { + name: 'gds.alpha.linkprediction.adamicAdar', + category: '', + description: 'Given two nodes, calculate Adamic Adar similarity', + isBuiltIn: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'node1 :: NODE', + name: 'node1', + type: 'NODE', + }, + { + isDeprecated: false, + description: 'node2 :: NODE', + name: 'node2', + type: 'NODE', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'gds.alpha.linkprediction.adamicAdar(node1 :: NODE, node2 :: NODE, config = {} :: MAP) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, + }, + 'gds.alpha.linkprediction.commonNeighbors': { + name: 'gds.alpha.linkprediction.commonNeighbors', + category: '', + description: 'Given two nodes, returns the number of common neighbors', + isBuiltIn: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'node1 :: NODE', + name: 'node1', + type: 'NODE', + }, + { + isDeprecated: false, + description: 'node2 :: NODE', + name: 'node2', + type: 'NODE', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'gds.alpha.linkprediction.commonNeighbors(node1 :: NODE, node2 :: NODE, config = {} :: MAP) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, + }, + 'gds.alpha.linkprediction.preferentialAttachment': { + name: 'gds.alpha.linkprediction.preferentialAttachment', + category: '', + description: 'Given two nodes, calculate Preferential Attachment', + isBuiltIn: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'node1 :: NODE', + name: 'node1', + type: 'NODE', + }, + { + isDeprecated: false, + description: 'node2 :: NODE', + name: 'node2', + type: 'NODE', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'gds.alpha.linkprediction.preferentialAttachment(node1 :: NODE, node2 :: NODE, config = {} :: MAP) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, + }, + 'gds.alpha.linkprediction.resourceAllocation': { + name: 'gds.alpha.linkprediction.resourceAllocation', + category: '', + description: 'Given two nodes, calculate Resource Allocation similarity', + isBuiltIn: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'node1 :: NODE', + name: 'node1', + type: 'NODE', + }, + { + isDeprecated: false, + description: 'node2 :: NODE', + name: 'node2', + type: 'NODE', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'gds.alpha.linkprediction.resourceAllocation(node1 :: NODE, node2 :: NODE, config = {} :: MAP) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, + }, + 'gds.alpha.linkprediction.sameCommunity': { + name: 'gds.alpha.linkprediction.sameCommunity', + category: '', + description: 'Given two nodes, indicates if they have the same community', + isBuiltIn: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'node1 :: NODE', + name: 'node1', + type: 'NODE', + }, + { + isDeprecated: false, + description: 'node2 :: NODE', + name: 'node2', + type: 'NODE', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=community, type=STRING}', + description: 'communityProperty = community :: STRING', + name: 'communityProperty', + type: 'STRING', + }, + ], + signature: + 'gds.alpha.linkprediction.sameCommunity(node1 :: NODE, node2 :: NODE, communityProperty = community :: STRING) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, + }, + 'gds.alpha.linkprediction.totalNeighbors': { + name: 'gds.alpha.linkprediction.totalNeighbors', + category: '', + description: 'Given two nodes, calculate Total Neighbors', + isBuiltIn: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'node1 :: NODE', + name: 'node1', + type: 'NODE', + }, + { + isDeprecated: false, + description: 'node2 :: NODE', + name: 'node2', + type: 'NODE', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'gds.alpha.linkprediction.totalNeighbors(node1 :: NODE, node2 :: NODE, config = {} :: MAP) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, + }, + 'gds.alpha.ml.oneHotEncoding': { + name: 'gds.alpha.ml.oneHotEncoding', + category: '', + description: + 'RETURN gds.alpha.ml.oneHotEncoding(availableValues, selectedValues) - return a list of selected values in a one hot encoding format.', + isBuiltIn: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'availableValues :: LIST', + name: 'availableValues', + type: 'LIST', + }, { - label: 'input', - documentation: 'input :: FLOAT', + isDeprecated: false, + description: 'selectedValues :: LIST', + name: 'selectedValues', + type: 'LIST', }, ], + signature: + 'gds.alpha.ml.oneHotEncoding(availableValues :: LIST, selectedValues :: LIST) :: LIST', + returnDescription: 'LIST', + aggregating: false, + }, + 'gds.graph.exists': { + name: 'gds.graph.exists', + category: '', + description: 'Checks if a graph exists in the catalog.', + isBuiltIn: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + ], + signature: 'gds.graph.exists(graphName :: STRING) :: BOOLEAN', + returnDescription: 'BOOLEAN', + aggregating: false, + }, + 'gds.graph.project': { + name: 'gds.graph.project', + category: '', + description: + 'Creates a named graph in the catalog for use by algorithms.', + isBuiltIn: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'sourceNode :: ANY', + name: 'sourceNode', + type: 'ANY', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=null, type=ANY}', + description: 'targetNode = null :: ANY', + name: 'targetNode', + type: 'ANY', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=null, type=ANY}', + description: 'dataConfig = null :: ANY', + name: 'dataConfig', + type: 'ANY', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=null, type=ANY}', + description: 'configuration = null :: ANY', + name: 'configuration', + type: 'ANY', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=null, type=ANY}', + description: 'alphaMigrationConfig = null :: ANY', + name: 'alphaMigrationConfig', + type: 'ANY', + }, + ], + signature: + 'gds.graph.project(graphName :: STRING, sourceNode :: ANY, targetNode = null :: ANY, dataConfig = null :: ANY, configuration = null :: ANY, alphaMigrationConfig = null :: ANY) :: MAP', + returnDescription: 'MAP', + aggregating: true, + }, + 'gds.isLicensed': { + name: 'gds.isLicensed', + category: '', + description: + 'RETURN gds.isLicensed - Return if GDS is licensed. For more details use the procedure gds.license.state.', + isBuiltIn: false, + argumentDescription: [], + signature: 'gds.isLicensed() :: BOOLEAN', + returnDescription: 'BOOLEAN', + aggregating: false, + }, + 'gds.similarity.cosine': { + name: 'gds.similarity.cosine', + category: '', + description: + 'RETURN gds.similarity.cosine(vector1, vector2) - Given two collection vectors, calculate cosine similarity', + isBuiltIn: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'vector1 :: LIST', + name: 'vector1', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'vector2 :: LIST', + name: 'vector2', + type: 'LIST', + }, + ], + signature: + 'gds.similarity.cosine(vector1 :: LIST, vector2 :: LIST) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, + }, + 'gds.similarity.euclidean': { + name: 'gds.similarity.euclidean', + category: '', + description: + 'RETURN gds.similarity.euclidean(vector1, vector2) - Given two collection vectors, calculate similarity based on euclidean distance', + isBuiltIn: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'vector1 :: LIST', + name: 'vector1', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'vector2 :: LIST', + name: 'vector2', + type: 'LIST', + }, + ], + signature: + 'gds.similarity.euclidean(vector1 :: LIST, vector2 :: LIST) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, + }, + 'gds.similarity.euclideanDistance': { + name: 'gds.similarity.euclideanDistance', + category: '', + description: + 'RETURN gds.similarity.euclideanDistance(vector1, vector2) - Given two collection vectors, calculate the euclidean distance (square root of the sum of the squared differences)', + isBuiltIn: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'vector1 :: LIST', + name: 'vector1', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'vector2 :: LIST', + name: 'vector2', + type: 'LIST', + }, + ], + signature: + 'gds.similarity.euclideanDistance(vector1 :: LIST, vector2 :: LIST) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, + }, + 'gds.similarity.jaccard': { + name: 'gds.similarity.jaccard', + category: '', + description: + 'RETURN gds.similarity.jaccard(vector1, vector2) - Given two collection vectors, calculate Jaccard similarity', + isBuiltIn: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'vector1 :: LIST', + name: 'vector1', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'vector2 :: LIST', + name: 'vector2', + type: 'LIST', + }, + ], + signature: + 'gds.similarity.jaccard(vector1 :: LIST, vector2 :: LIST) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, + }, + 'gds.similarity.overlap': { + name: 'gds.similarity.overlap', + category: '', + description: + 'RETURN gds.similarity.overlap(vector1, vector2) - Given two collection vectors, calculate overlap similarity', + isBuiltIn: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'vector1 :: LIST', + name: 'vector1', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'vector2 :: LIST', + name: 'vector2', + type: 'LIST', + }, + ], + signature: + 'gds.similarity.overlap(vector1 :: LIST, vector2 :: LIST) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, + }, + 'gds.similarity.pearson': { + name: 'gds.similarity.pearson', + category: '', + description: + 'RETURN gds.similarity.pearson(vector1, vector2) - Given two collection vectors, calculate pearson similarity', + isBuiltIn: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'vector1 :: LIST', + name: 'vector1', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'vector2 :: LIST', + name: 'vector2', + type: 'LIST', + }, + ], + signature: + 'gds.similarity.pearson(vector1 :: LIST, vector2 :: LIST) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, + }, + 'gds.util.NaN': { + name: 'gds.util.NaN', + category: '', + description: 'RETURN gds.util.NaN() - Returns NaN as a Cypher value.', + isBuiltIn: false, + argumentDescription: [], + signature: 'gds.util.NaN() :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, + }, + 'gds.util.asNode': { + name: 'gds.util.asNode', + category: '', + description: + 'RETURN gds.util.asNode(nodeId) - Return the node objects for the given node id or null if none exists.', + isBuiltIn: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'nodeId :: INTEGER | FLOAT', + name: 'nodeId', + type: 'INTEGER | FLOAT', + }, + ], + signature: 'gds.util.asNode(nodeId :: INTEGER | FLOAT) :: NODE', + returnDescription: 'NODE', + aggregating: false, + }, + 'gds.util.asNodes': { + name: 'gds.util.asNodes', + category: '', + description: + 'RETURN gds.util.asNodes(nodeIds) - Return the node objects for the given node ids or an empty list if none exists.', + isBuiltIn: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'nodeIds :: LIST', + name: 'nodeIds', + type: 'LIST', + }, + ], + signature: + 'gds.util.asNodes(nodeIds :: LIST) :: LIST', + returnDescription: 'LIST', + aggregating: false, + }, + 'gds.util.infinity': { + name: 'gds.util.infinity', + category: '', + description: + 'RETURN gds.util.infinity() - Return infinity as a Cypher value.', + isBuiltIn: false, + argumentDescription: [], + signature: 'gds.util.infinity() :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, + }, + 'gds.util.isFinite': { + name: 'gds.util.isFinite', + category: '', + description: + 'RETURN gds.util.isFinite(value) - Return true iff the given argument is a finite value (not ±Infinity, NaN, or null).', + isBuiltIn: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'value :: INTEGER | FLOAT', + name: 'value', + type: 'INTEGER | FLOAT', + }, + ], + signature: 'gds.util.isFinite(value :: INTEGER | FLOAT) :: BOOLEAN', + returnDescription: 'BOOLEAN', + aggregating: false, + }, + 'gds.util.isInfinite': { + name: 'gds.util.isInfinite', + category: '', + description: + 'RETURN gds.util.isInfinite(value) - Return true iff the given argument is not a finite value (not ±Infinity, NaN, or null).', + isBuiltIn: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'value :: INTEGER | FLOAT', + name: 'value', + type: 'INTEGER | FLOAT', + }, + ], + signature: 'gds.util.isInfinite(value :: INTEGER | FLOAT) :: BOOLEAN', + returnDescription: 'BOOLEAN', + aggregating: false, + }, + 'gds.util.nodeProperty': { + name: 'gds.util.nodeProperty', + category: '', + description: + 'Returns a node property value from a named in-memory graph.', + isBuiltIn: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodeId :: ANY', + name: 'nodeId', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'propertyKey :: STRING', + name: 'propertyKey', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=*, type=STRING}', + description: 'nodeLabel = * :: STRING', + name: 'nodeLabel', + type: 'STRING', + }, + ], + signature: + 'gds.util.nodeProperty(graphName :: STRING, nodeId :: ANY, propertyKey :: STRING, nodeLabel = * :: STRING) :: ANY', + returnDescription: 'ANY', + aggregating: false, + }, + 'gds.version': { + name: 'gds.version', + category: '', + description: + 'RETURN gds.version() | Return the installed graph data science library version.', + isBuiltIn: false, + argumentDescription: [], + signature: 'gds.version() :: STRING', + returnDescription: 'STRING', + aggregating: false, }, 'graph.names': { - label: 'graph.names', - documentation: 'Lists the names of graphs in the current database.', - parameters: [], + name: 'graph.names', + category: 'Graph', + description: 'Lists the names of graphs in the current database.', + isBuiltIn: true, + argumentDescription: [], + signature: 'graph.names() :: LIST', + returnDescription: 'LIST', + aggregating: false, }, 'graph.propertiesByName': { - label: 'graph.propertiesByName', - documentation: 'Returns the `MAP` of properties associated with a graph.', - parameters: [ + name: 'graph.propertiesByName', + category: 'Graph', + description: 'Returns the `MAP` of properties associated with a graph.', + isBuiltIn: true, + argumentDescription: [ { - label: 'graphName', - documentation: 'graphName :: STRING', + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', }, ], + signature: 'graph.propertiesByName(graphName :: STRING) :: MAP', + returnDescription: 'MAP', + aggregating: false, }, haversin: { - label: 'haversin', - documentation: 'Returns half the versine of a number.', - parameters: [ + name: 'haversin', + category: 'Trigonometric', + description: 'Returns half the versine of a number.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: FLOAT', + isDeprecated: false, + description: 'input :: FLOAT', + name: 'input', + type: 'FLOAT', }, ], + signature: 'haversin(input :: FLOAT) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, head: { - label: 'head', - documentation: 'Returns the first element in a `LIST`.', - parameters: [ + name: 'head', + category: 'Scalar', + description: 'Returns the first element in a `LIST`.', + isBuiltIn: true, + argumentDescription: [ { - label: 'list', - documentation: 'list :: LIST', + isDeprecated: false, + description: 'list :: LIST', + name: 'list', + type: 'LIST', }, ], + signature: 'head(list :: LIST) :: ANY', + returnDescription: 'ANY', + aggregating: false, }, id: { - label: 'id', - documentation: 'Returns the id of a `NODE` or `RELATIONSHIP`.', - parameters: [ + name: 'id', + category: 'Scalar', + description: 'Returns the id of a `NODE` or `RELATIONSHIP`.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: NODE | RELATIONSHIP', + isDeprecated: false, + description: 'input :: NODE | RELATIONSHIP', + name: 'input', + type: 'NODE | RELATIONSHIP', }, ], + signature: 'id(input :: NODE | RELATIONSHIP) :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, isEmpty: { - label: 'isEmpty', - documentation: - 'Checks whether a `STRING`, `MAP` or `LIST` is empty.', - parameters: [ + name: 'isEmpty', + category: 'Predicate', + description: 'Checks whether a `STRING`, `MAP` or `LIST` is empty.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: STRING | MAP | LIST', + isDeprecated: false, + description: 'input :: STRING | MAP | LIST', + name: 'input', + type: 'STRING | MAP | LIST', }, ], + signature: 'isEmpty(input :: STRING | MAP | LIST) :: BOOLEAN', + returnDescription: 'BOOLEAN', + aggregating: false, }, isNaN: { - label: 'isNaN', - documentation: 'Returns whether the given `INTEGER` or `FLOAT` is NaN.', - parameters: [ + name: 'isNaN', + category: 'Numeric', + description: 'Returns whether the given `INTEGER` or `FLOAT` is NaN.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: INTEGER | FLOAT', + isDeprecated: false, + description: 'input :: INTEGER | FLOAT', + name: 'input', + type: 'INTEGER | FLOAT', }, ], + signature: 'isNaN(input :: INTEGER | FLOAT) :: BOOLEAN', + returnDescription: 'BOOLEAN', + aggregating: false, }, keys: { - label: 'keys', - documentation: + name: 'keys', + category: 'List', + description: 'Returns a `LIST` containing the `STRING` representations for all the property names of a `NODE`, `RELATIONSHIP` or `MAP`.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: NODE | RELATIONSHIP | MAP', + isDeprecated: false, + description: 'input :: NODE | RELATIONSHIP | MAP', + name: 'input', + type: 'NODE | RELATIONSHIP | MAP', }, ], + signature: 'keys(input :: NODE | RELATIONSHIP | MAP) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, labels: { - label: 'labels', - documentation: + name: 'labels', + category: 'List', + description: 'Returns a `LIST` containing the `STRING` representations for all the labels of a `NODE`.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: NODE', + isDeprecated: false, + description: 'input :: NODE', + name: 'input', + type: 'NODE', }, ], + signature: 'labels(input :: NODE) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, last: { - label: 'last', - documentation: 'Returns the last element in a `LIST`.', - parameters: [ + name: 'last', + category: 'Scalar', + description: 'Returns the last element in a `LIST`.', + isBuiltIn: true, + argumentDescription: [ { - label: 'list', - documentation: 'list :: LIST', + isDeprecated: false, + description: 'list :: LIST', + name: 'list', + type: 'LIST', }, ], + signature: 'last(list :: LIST) :: ANY', + returnDescription: 'ANY', + aggregating: false, }, left: { - label: 'left', - documentation: + name: 'left', + category: 'String', + description: 'Returns a `STRING` containing the specified number (`INTEGER`) of leftmost characters in the given `STRING`.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'original', - documentation: 'original :: STRING', + isDeprecated: false, + description: 'original :: STRING', + name: 'original', + type: 'STRING', }, { - label: 'length', - documentation: 'length :: INTEGER', + isDeprecated: false, + description: 'length :: INTEGER', + name: 'length', + type: 'INTEGER', }, ], + signature: 'left(original :: STRING, length :: INTEGER) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, length: { - label: 'length', - documentation: 'Returns the length of a `PATH`.', - parameters: [ + name: 'length', + category: 'Scalar', + description: 'Returns the length of a `PATH`.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: PATH', + isDeprecated: false, + description: 'input :: PATH', + name: 'input', + type: 'PATH', }, ], + signature: 'length(input :: PATH) :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, linenumber: { - label: 'linenumber', - documentation: - 'Returns the line number that LOAD CSV is currently using.', - parameters: [], + name: 'linenumber', + category: 'Scalar', + description: 'Returns the line number that LOAD CSV is currently using.', + isBuiltIn: true, + argumentDescription: [], + signature: 'linenumber() :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, localdatetime: { - label: 'localdatetime', - documentation: 'Creates a `LOCAL DATETIME` instant.', - parameters: [ + name: 'localdatetime', + category: 'Temporal', + description: 'Creates a `LOCAL DATETIME` instant.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + isDeprecated: false, + default: + 'DefaultParameterValue{value=DEFAULT_TEMPORAL_ARGUMENT, type=ANY}', + description: 'input = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + name: 'input', + type: 'ANY', }, ], + signature: + 'localdatetime(input = DEFAULT_TEMPORAL_ARGUMENT :: ANY) :: LOCAL DATETIME', + returnDescription: 'LOCAL DATETIME', + aggregating: false, }, 'localdatetime.realtime': { - label: 'localdatetime.realtime', - documentation: + name: 'localdatetime.realtime', + category: 'Temporal', + description: 'Returns the current `LOCAL DATETIME` instant using the realtime clock.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'timezone', - documentation: 'timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + isDeprecated: false, + default: + 'DefaultParameterValue{value=DEFAULT_TEMPORAL_ARGUMENT, type=ANY}', + description: 'timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + name: 'timezone', + type: 'ANY', }, ], + signature: + 'localdatetime.realtime(timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY) :: LOCAL DATETIME', + returnDescription: 'LOCAL DATETIME', + aggregating: false, }, 'localdatetime.statement': { - label: 'localdatetime.statement', - documentation: + name: 'localdatetime.statement', + category: 'Temporal', + description: 'Returns the current `LOCAL DATETIME` instant using the statement clock.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'timezone', - documentation: 'timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + isDeprecated: false, + default: + 'DefaultParameterValue{value=DEFAULT_TEMPORAL_ARGUMENT, type=ANY}', + description: 'timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + name: 'timezone', + type: 'ANY', }, ], + signature: + 'localdatetime.statement(timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY) :: LOCAL DATETIME', + returnDescription: 'LOCAL DATETIME', + aggregating: false, }, 'localdatetime.transaction': { - label: 'localdatetime.transaction', - documentation: + name: 'localdatetime.transaction', + category: 'Temporal', + description: 'Returns the current `LOCAL DATETIME` instant using the transaction clock.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'timezone', - documentation: 'timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + isDeprecated: false, + default: + 'DefaultParameterValue{value=DEFAULT_TEMPORAL_ARGUMENT, type=ANY}', + description: 'timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + name: 'timezone', + type: 'ANY', }, ], + signature: + 'localdatetime.transaction(timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY) :: LOCAL DATETIME', + returnDescription: 'LOCAL DATETIME', + aggregating: false, }, 'localdatetime.truncate': { - label: 'localdatetime.truncate', - documentation: + name: 'localdatetime.truncate', + category: 'Temporal', + description: 'Truncates the given temporal value to a `LOCAL DATETIME` instant using the specified unit.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'unit', - documentation: 'unit :: STRING', + isDeprecated: false, + description: 'unit :: STRING', + name: 'unit', + type: 'STRING', }, { - label: 'input', - documentation: 'input = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + isDeprecated: false, + default: + 'DefaultParameterValue{value=DEFAULT_TEMPORAL_ARGUMENT, type=ANY}', + description: 'input = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + name: 'input', + type: 'ANY', }, { - label: 'fields', - documentation: 'fields = null :: MAP', + isDeprecated: false, + default: 'DefaultParameterValue{value=null, type=MAP}', + description: 'fields = null :: MAP', + name: 'fields', + type: 'MAP', }, ], + signature: + 'localdatetime.truncate(unit :: STRING, input = DEFAULT_TEMPORAL_ARGUMENT :: ANY, fields = null :: MAP) :: LOCAL DATETIME', + returnDescription: 'LOCAL DATETIME', + aggregating: false, }, localtime: { - label: 'localtime', - documentation: 'Creates a `LOCAL TIME` instant.', - parameters: [ + name: 'localtime', + category: 'Temporal', + description: 'Creates a `LOCAL TIME` instant.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + isDeprecated: false, + default: + 'DefaultParameterValue{value=DEFAULT_TEMPORAL_ARGUMENT, type=ANY}', + description: 'input = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + name: 'input', + type: 'ANY', }, ], + signature: + 'localtime(input = DEFAULT_TEMPORAL_ARGUMENT :: ANY) :: LOCAL TIME', + returnDescription: 'LOCAL TIME', + aggregating: false, }, 'localtime.realtime': { - label: 'localtime.realtime', - documentation: + name: 'localtime.realtime', + category: 'Temporal', + description: 'Returns the current `LOCAL TIME` instant using the realtime clock.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'timezone', - documentation: 'timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + isDeprecated: false, + default: + 'DefaultParameterValue{value=DEFAULT_TEMPORAL_ARGUMENT, type=ANY}', + description: 'timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + name: 'timezone', + type: 'ANY', }, ], + signature: + 'localtime.realtime(timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY) :: LOCAL TIME', + returnDescription: 'LOCAL TIME', + aggregating: false, }, 'localtime.statement': { - label: 'localtime.statement', - documentation: + name: 'localtime.statement', + category: 'Temporal', + description: 'Returns the current `LOCAL TIME` instant using the statement clock.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'timezone', - documentation: 'timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + isDeprecated: false, + default: + 'DefaultParameterValue{value=DEFAULT_TEMPORAL_ARGUMENT, type=ANY}', + description: 'timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + name: 'timezone', + type: 'ANY', }, ], + signature: + 'localtime.statement(timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY) :: LOCAL TIME', + returnDescription: 'LOCAL TIME', + aggregating: false, }, 'localtime.transaction': { - label: 'localtime.transaction', - documentation: + name: 'localtime.transaction', + category: 'Temporal', + description: 'Returns the current `LOCAL TIME` instant using the transaction clock.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'timezone', - documentation: 'timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + isDeprecated: false, + default: + 'DefaultParameterValue{value=DEFAULT_TEMPORAL_ARGUMENT, type=ANY}', + description: 'timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + name: 'timezone', + type: 'ANY', }, ], + signature: + 'localtime.transaction(timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY) :: LOCAL TIME', + returnDescription: 'LOCAL TIME', + aggregating: false, }, 'localtime.truncate': { - label: 'localtime.truncate', - documentation: + name: 'localtime.truncate', + category: 'Temporal', + description: 'Truncates the given temporal value to a `LOCAL TIME` instant using the specified unit.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'unit', - documentation: 'unit :: STRING', + isDeprecated: false, + description: 'unit :: STRING', + name: 'unit', + type: 'STRING', }, { - label: 'input', - documentation: 'input = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + isDeprecated: false, + default: + 'DefaultParameterValue{value=DEFAULT_TEMPORAL_ARGUMENT, type=ANY}', + description: 'input = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + name: 'input', + type: 'ANY', }, { - label: 'fields', - documentation: 'fields = null :: MAP', + isDeprecated: false, + default: 'DefaultParameterValue{value=null, type=MAP}', + description: 'fields = null :: MAP', + name: 'fields', + type: 'MAP', }, ], + signature: + 'localtime.truncate(unit :: STRING, input = DEFAULT_TEMPORAL_ARGUMENT :: ANY, fields = null :: MAP) :: LOCAL TIME', + returnDescription: 'LOCAL TIME', + aggregating: false, }, log: { - label: 'log', - documentation: 'Returns the natural logarithm of a `FLOAT`.', - parameters: [ + name: 'log', + category: 'Logarithmic', + description: 'Returns the natural logarithm of a `FLOAT`.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: FLOAT', + isDeprecated: false, + description: 'input :: FLOAT', + name: 'input', + type: 'FLOAT', }, ], + signature: 'log(input :: FLOAT) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, log10: { - label: 'log10', - documentation: 'Returns the common logarithm (base 10) of a `FLOAT`.', - parameters: [ + name: 'log10', + category: 'Logarithmic', + description: 'Returns the common logarithm (base 10) of a `FLOAT`.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: FLOAT', + isDeprecated: false, + description: 'input :: FLOAT', + name: 'input', + type: 'FLOAT', }, ], + signature: 'log10(input :: FLOAT) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, ltrim: { - label: 'ltrim', - documentation: + name: 'ltrim', + category: 'String', + description: 'Returns the given `STRING` with leading whitespace removed.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: STRING', + isDeprecated: false, + description: 'input :: STRING', + name: 'input', + type: 'STRING', }, ], + signature: 'ltrim(input :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, max: { - label: 'max', - documentation: 'Returns the maximum value in a set of values.', - parameters: [ + name: 'max', + category: 'Aggregating', + description: 'Returns the maximum value in a set of values.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: ANY', + isDeprecated: false, + description: 'input :: ANY', + name: 'input', + type: 'ANY', }, ], + signature: 'max(input :: ANY) :: ANY', + returnDescription: 'ANY', + aggregating: true, }, min: { - label: 'min', - documentation: 'Returns the minimum value in a set of values.', - parameters: [ + name: 'min', + category: 'Aggregating', + description: 'Returns the minimum value in a set of values.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: ANY', + isDeprecated: false, + description: 'input :: ANY', + name: 'input', + type: 'ANY', }, ], + signature: 'min(input :: ANY) :: ANY', + returnDescription: 'ANY', + aggregating: true, }, nodes: { - label: 'nodes', - documentation: + name: 'nodes', + category: 'List', + description: 'Returns a `LIST` containing all the `NODE` values in a `PATH`.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: PATH', + isDeprecated: false, + description: 'input :: PATH', + name: 'input', + type: 'PATH', }, ], + signature: 'nodes(input :: PATH) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, none: { - label: 'none', - documentation: + name: 'none', + category: 'Predicate', + description: 'Returns true if the predicate holds for no element in the given `LIST`.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'variable', - documentation: 'variable :: ANY', + isDeprecated: false, + description: 'variable :: ANY', + name: 'variable', + type: 'ANY', }, { - label: 'list', - documentation: 'list :: LIST', + isDeprecated: false, + description: 'list :: LIST', + name: 'list', + type: 'LIST', }, ], + signature: + 'none(variable :: VARIABLE IN list :: LIST WHERE predicate :: ANY) :: BOOLEAN', + returnDescription: 'BOOLEAN', + aggregating: false, }, nullIf: { - label: 'nullIf', - documentation: + name: 'nullIf', + category: 'Scalar', + description: 'Returns null if the two given parameters are equivalent, otherwise returns the value of the first parameter.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'v1', - documentation: 'v1 :: ANY', + isDeprecated: false, + description: 'v1 :: ANY', + name: 'v1', + type: 'ANY', }, { - label: 'v2', - documentation: 'v2 :: ANY', + isDeprecated: false, + description: 'v2 :: ANY', + name: 'v2', + type: 'ANY', }, ], + signature: 'nullIf(v1 :: ANY, v2 :: ANY) :: ANY', + returnDescription: 'ANY', + aggregating: false, }, percentileCont: { - label: 'percentileCont', - documentation: + name: 'percentileCont', + category: 'Aggregating', + description: 'Returns the percentile of a value over a group using linear interpolation.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: FLOAT', + isDeprecated: false, + description: 'input :: FLOAT', + name: 'input', + type: 'FLOAT', }, { - label: 'percentile', - documentation: 'percentile :: FLOAT', + isDeprecated: false, + description: 'percentile :: FLOAT', + name: 'percentile', + type: 'FLOAT', }, ], + signature: 'percentileCont(input :: FLOAT, percentile :: FLOAT) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: true, }, percentileDisc: { - label: 'percentileDisc', - documentation: + name: 'percentileDisc', + category: 'Aggregating', + description: 'Returns the nearest `INTEGER` or `FLOAT` value to the given percentile over a group using a rounding method.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: INTEGER | FLOAT', + isDeprecated: false, + description: 'input :: INTEGER | FLOAT', + name: 'input', + type: 'INTEGER | FLOAT', }, { - label: 'percentile', - documentation: 'percentile :: FLOAT', + isDeprecated: false, + description: 'percentile :: FLOAT', + name: 'percentile', + type: 'FLOAT', }, ], + signature: + 'percentileDisc(input :: INTEGER | FLOAT, percentile :: FLOAT) :: INTEGER | FLOAT', + returnDescription: 'INTEGER | FLOAT', + aggregating: true, }, pi: { - label: 'pi', - documentation: 'Returns the mathematical constant pi.', - parameters: [], + name: 'pi', + category: 'Trigonometric', + description: 'Returns the mathematical constant pi.', + isBuiltIn: true, + argumentDescription: [], + signature: 'pi() :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, point: { - label: 'point', - documentation: + name: 'point', + category: 'Spatial', + description: 'Returns a 2D or 3D point object, given two or respectively three coordinate values in the Cartesian coordinate system or WGS 84 geographic coordinate system.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: MAP', + isDeprecated: false, + description: 'input :: MAP', + name: 'input', + type: 'MAP', }, ], + signature: 'point(input :: MAP) :: POINT', + returnDescription: 'POINT', + aggregating: false, }, 'point.distance': { - label: 'point.distance', - documentation: + name: 'point.distance', + category: 'Spatial', + description: 'Returns a `FLOAT` representing the geodesic distance between any two points in the same CRS.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'from', - documentation: 'from :: POINT', + isDeprecated: false, + description: 'from :: POINT', + name: 'from', + type: 'POINT', }, { - label: 'to', - documentation: 'to :: POINT', + isDeprecated: false, + description: 'to :: POINT', + name: 'to', + type: 'POINT', }, ], + signature: 'point.distance(from :: POINT, to :: POINT) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, 'point.withinBBox': { - label: 'point.withinBBox', - documentation: + name: 'point.withinBBox', + category: 'Spatial', + description: 'Returns true if the provided point is within the bounding box defined by the two provided points.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'point', - documentation: 'point :: POINT', + isDeprecated: false, + description: 'point :: POINT', + name: 'point', + type: 'POINT', }, { - label: 'lowerLeft', - documentation: 'lowerLeft :: POINT', + isDeprecated: false, + description: 'lowerLeft :: POINT', + name: 'lowerLeft', + type: 'POINT', }, { - label: 'upperRight', - documentation: 'upperRight :: POINT', + isDeprecated: false, + description: 'upperRight :: POINT', + name: 'upperRight', + type: 'POINT', }, ], + signature: + 'point.withinBBox(point :: POINT, lowerLeft :: POINT, upperRight :: POINT) :: BOOLEAN', + returnDescription: 'BOOLEAN', + aggregating: false, }, properties: { - label: 'properties', - documentation: + name: 'properties', + category: 'Scalar', + description: 'Returns a `MAP` containing all the properties of a `NODE`, `RELATIONSHIP` or `MAP`.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: NODE | RELATIONSHIP | MAP', + isDeprecated: false, + description: 'input :: NODE | RELATIONSHIP | MAP', + name: 'input', + type: 'NODE | RELATIONSHIP | MAP', }, ], + signature: 'properties(input :: NODE | RELATIONSHIP | MAP) :: MAP', + returnDescription: 'MAP', + aggregating: false, }, radians: { - label: 'radians', - documentation: 'Converts degrees to radians.', - parameters: [ + name: 'radians', + category: 'Trigonometric', + description: 'Converts degrees to radians.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: FLOAT', + isDeprecated: false, + description: 'input :: FLOAT', + name: 'input', + type: 'FLOAT', }, ], + signature: 'radians(input :: FLOAT) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, rand: { - label: 'rand', - documentation: + name: 'rand', + category: 'Numeric', + description: 'Returns a random `FLOAT` in the range from 0 (inclusive) to 1 (exclusive).', - parameters: [], + isBuiltIn: true, + argumentDescription: [], + signature: 'rand() :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, randomUUID: { - label: 'randomUUID', - documentation: 'Generates a random UUID.', - parameters: [], + name: 'randomUUID', + category: 'Scalar', + description: 'Generates a random UUID.', + isBuiltIn: true, + argumentDescription: [], + signature: 'randomUUID() :: STRING', + returnDescription: 'STRING', + aggregating: false, }, range: { - label: 'range', - documentation: + name: 'range', + category: 'List', + description: 'Returns a `LIST` comprising all `INTEGER` values within a specified range created with step length.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'start', - documentation: 'start :: INTEGER', + isDeprecated: false, + description: 'start :: INTEGER', + name: 'start', + type: 'INTEGER', }, { - label: 'end', - documentation: 'end :: INTEGER', + isDeprecated: false, + description: 'end :: INTEGER', + name: 'end', + type: 'INTEGER', }, { - label: 'step', - documentation: 'step :: INTEGER', + isDeprecated: false, + description: 'step :: INTEGER', + name: 'step', + type: 'INTEGER', }, ], + signature: + 'range(start :: INTEGER, end :: INTEGER, step :: INTEGER) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, reduce: { - label: 'reduce', - documentation: + name: 'reduce', + category: 'List', + description: 'Runs an expression against individual elements of a `LIST`, storing the result of the expression in an accumulator.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'accumulator', - documentation: 'accumulator :: ANY', + isDeprecated: false, + description: 'accumulator :: ANY', + name: 'accumulator', + type: 'ANY', }, { - label: 'variable', - documentation: 'variable :: LIST', + isDeprecated: false, + description: 'variable :: LIST', + name: 'variable', + type: 'LIST', }, ], + signature: + 'reduce(accumulator :: VARIABLE = initial :: ANY, variable :: VARIABLE IN list :: LIST | expression :: ANY) :: ANY', + returnDescription: 'ANY', + aggregating: false, }, relationships: { - label: 'relationships', - documentation: + name: 'relationships', + category: 'List', + description: 'Returns a `LIST` containing all the `RELATIONSHIP` values in a `PATH`.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: PATH', + isDeprecated: false, + description: 'input :: PATH', + name: 'input', + type: 'PATH', }, ], + signature: 'relationships(input :: PATH) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, replace: { - label: 'replace', - documentation: + name: 'replace', + category: 'String', + description: 'Returns a `STRING` in which all occurrences of a specified search `STRING` in the given `STRING` have been replaced by another (specified) replacement `STRING`.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'original', - documentation: 'original :: STRING', + isDeprecated: false, + description: 'original :: STRING', + name: 'original', + type: 'STRING', }, { - label: 'search', - documentation: 'search :: STRING', + isDeprecated: false, + description: 'search :: STRING', + name: 'search', + type: 'STRING', }, { - label: 'replace', - documentation: 'replace :: STRING', + isDeprecated: false, + description: 'replace :: STRING', + name: 'replace', + type: 'STRING', }, ], + signature: + 'replace(original :: STRING, search :: STRING, replace :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, reverse: { - label: 'reverse', - documentation: + name: 'reverse', + category: 'String', + description: 'Returns a `STRING` or `LIST` in which the order of all characters or elements in the given `STRING` or `LIST` have been reversed.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: STRING | LIST', + isDeprecated: false, + description: 'input :: STRING | LIST', + name: 'input', + type: 'STRING | LIST', }, ], + signature: 'reverse(input :: STRING | LIST) :: STRING | LIST', + returnDescription: 'STRING | LIST', + aggregating: false, }, right: { - label: 'right', - documentation: + name: 'right', + category: 'String', + description: 'Returns a `STRING` containing the specified number of rightmost characters in the given `STRING`.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'original', - documentation: 'original :: STRING', + isDeprecated: false, + description: 'original :: STRING', + name: 'original', + type: 'STRING', }, { - label: 'length', - documentation: 'length :: INTEGER', + isDeprecated: false, + description: 'length :: INTEGER', + name: 'length', + type: 'INTEGER', }, ], + signature: 'right(original :: STRING, length :: INTEGER) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, round: { - label: 'round', - documentation: + name: 'round', + category: 'Numeric', + description: 'Returns the value of a number rounded to the specified precision with the specified rounding mode.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'value', - documentation: 'value :: FLOAT', + isDeprecated: false, + description: 'value :: FLOAT', + name: 'value', + type: 'FLOAT', }, { - label: 'precision', - documentation: 'precision :: INTEGER | FLOAT', + isDeprecated: false, + description: 'precision :: INTEGER | FLOAT', + name: 'precision', + type: 'INTEGER | FLOAT', }, { - label: 'mode', - documentation: 'mode :: STRING', + isDeprecated: false, + description: 'mode :: STRING', + name: 'mode', + type: 'STRING', }, ], + signature: + 'round(value :: FLOAT, precision :: INTEGER | FLOAT, mode :: STRING) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, rtrim: { - label: 'rtrim', - documentation: + name: 'rtrim', + category: 'String', + description: 'Returns the given `STRING` with trailing whitespace removed.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: STRING', + isDeprecated: false, + description: 'input :: STRING', + name: 'input', + type: 'STRING', }, ], + signature: 'rtrim(input :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, sign: { - label: 'sign', - documentation: + name: 'sign', + category: 'Numeric', + description: 'Returns the signum of an `INTEGER` or `FLOAT`: 0 if the number is 0, -1 for any negative number, and 1 for any positive number.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: INTEGER | FLOAT', + isDeprecated: false, + description: 'input :: INTEGER | FLOAT', + name: 'input', + type: 'INTEGER | FLOAT', }, ], + signature: 'sign(input :: INTEGER | FLOAT) :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, sin: { - label: 'sin', - documentation: 'Returns the sine of a `FLOAT`.', - parameters: [ + name: 'sin', + category: 'Trigonometric', + description: 'Returns the sine of a `FLOAT`.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: FLOAT', + isDeprecated: false, + description: 'input :: FLOAT', + name: 'input', + type: 'FLOAT', }, ], + signature: 'sin(input :: FLOAT) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, single: { - label: 'single', - documentation: + name: 'single', + category: 'Predicate', + description: 'Returns true if the predicate holds for exactly one of the elements in the given `LIST`.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'variable', - documentation: 'variable :: ANY', + isDeprecated: false, + description: 'variable :: ANY', + name: 'variable', + type: 'ANY', }, { - label: 'list', - documentation: 'list :: LIST', + isDeprecated: false, + description: 'list :: LIST', + name: 'list', + type: 'LIST', }, ], + signature: + 'single(variable :: VARIABLE IN list :: LIST WHERE predicate :: ANY) :: BOOLEAN', + returnDescription: 'BOOLEAN', + aggregating: false, }, size: { - label: 'size', - documentation: + name: 'size', + category: 'Scalar', + description: 'Returns the number of items in a `LIST` or the number of Unicode characters in a `STRING`.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: STRING | LIST', + isDeprecated: false, + description: 'input :: STRING | LIST', + name: 'input', + type: 'STRING | LIST', }, ], + signature: 'size(input :: STRING | LIST) :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, split: { - label: 'split', - documentation: + name: 'split', + category: 'String', + description: 'Returns a `LIST` resulting from the splitting of the given `STRING` around matches of the given delimiter(s).', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'original', - documentation: 'original :: STRING', + isDeprecated: false, + description: 'original :: STRING', + name: 'original', + type: 'STRING', }, { - label: 'splitDelimiters', - documentation: 'splitDelimiters :: STRING | LIST', + isDeprecated: false, + description: 'splitDelimiters :: STRING | LIST', + name: 'splitDelimiters', + type: 'STRING | LIST', }, ], + signature: + 'split(original :: STRING, splitDelimiters :: STRING | LIST) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, sqrt: { - label: 'sqrt', - documentation: 'Returns the square root of a `FLOAT`.', - parameters: [ + name: 'sqrt', + category: 'Logarithmic', + description: 'Returns the square root of a `FLOAT`.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: FLOAT', + isDeprecated: false, + description: 'input :: FLOAT', + name: 'input', + type: 'FLOAT', }, ], + signature: 'sqrt(input :: FLOAT) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, startNode: { - label: 'startNode', - documentation: 'Returns the start `NODE` of a `RELATIONSHIP`.', - parameters: [ + name: 'startNode', + category: 'Scalar', + description: 'Returns the start `NODE` of a `RELATIONSHIP`.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: RELATIONSHIP', + isDeprecated: false, + description: 'input :: RELATIONSHIP', + name: 'input', + type: 'RELATIONSHIP', }, ], + signature: 'startNode(input :: RELATIONSHIP) :: NODE', + returnDescription: 'NODE', + aggregating: false, }, stdev: { - label: 'stdev', - documentation: + name: 'stdev', + category: 'Aggregating', + description: 'Returns the standard deviation for the given value over a group for a sample of a population.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: FLOAT', + isDeprecated: false, + description: 'input :: FLOAT', + name: 'input', + type: 'FLOAT', }, ], + signature: 'stdev(input :: FLOAT) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: true, }, stdevp: { - label: 'stdevp', - documentation: + name: 'stdevp', + category: 'Aggregating', + description: 'Returns the standard deviation for the given value over a group for an entire population.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: FLOAT', + isDeprecated: false, + description: 'input :: FLOAT', + name: 'input', + type: 'FLOAT', }, ], + signature: 'stdevp(input :: FLOAT) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: true, }, substring: { - label: 'substring', - documentation: + name: 'substring', + category: 'String', + description: 'Returns a substring of a given `length` from the given `STRING`, beginning with a 0-based index start.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'original', - documentation: 'original :: STRING', + isDeprecated: false, + description: 'original :: STRING', + name: 'original', + type: 'STRING', }, { - label: 'start', - documentation: 'start :: INTEGER', + isDeprecated: false, + description: 'start :: INTEGER', + name: 'start', + type: 'INTEGER', }, { - label: 'length', - documentation: 'length :: INTEGER', + isDeprecated: false, + description: 'length :: INTEGER', + name: 'length', + type: 'INTEGER', }, ], + signature: + 'substring(original :: STRING, start :: INTEGER, length :: INTEGER) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, sum: { - label: 'sum', - documentation: + name: 'sum', + category: 'Aggregating', + description: 'Returns the sum of a set of `INTEGER`, `FLOAT` or `DURATION` values', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: INTEGER | FLOAT | DURATION', + isDeprecated: false, + description: 'input :: INTEGER | FLOAT | DURATION', + name: 'input', + type: 'INTEGER | FLOAT | DURATION', }, ], + signature: + 'sum(input :: INTEGER | FLOAT | DURATION) :: INTEGER | FLOAT | DURATION', + returnDescription: 'INTEGER | FLOAT | DURATION', + aggregating: true, }, tail: { - label: 'tail', - documentation: 'Returns all but the first element in a `LIST`.', - parameters: [ + name: 'tail', + category: 'List', + description: 'Returns all but the first element in a `LIST`.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: LIST', + isDeprecated: false, + description: 'input :: LIST', + name: 'input', + type: 'LIST', }, ], + signature: 'tail(input :: LIST) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, tan: { - label: 'tan', - documentation: 'Returns the tangent of a `FLOAT`.', - parameters: [ + name: 'tan', + category: 'Trigonometric', + description: 'Returns the tangent of a `FLOAT`.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: FLOAT', + isDeprecated: false, + description: 'input :: FLOAT', + name: 'input', + type: 'FLOAT', }, ], + signature: 'tan(input :: FLOAT) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, time: { - label: 'time', - documentation: 'Creates a `ZONED TIME` instant.', - parameters: [ + name: 'time', + category: 'Temporal', + description: 'Creates a `ZONED TIME` instant.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + isDeprecated: false, + default: + 'DefaultParameterValue{value=DEFAULT_TEMPORAL_ARGUMENT, type=ANY}', + description: 'input = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + name: 'input', + type: 'ANY', }, ], + signature: 'time(input = DEFAULT_TEMPORAL_ARGUMENT :: ANY) :: ZONED TIME', + returnDescription: 'ZONED TIME', + aggregating: false, }, 'time.realtime': { - label: 'time.realtime', - documentation: + name: 'time.realtime', + category: 'Temporal', + description: 'Returns the current `ZONED TIME` instant using the realtime clock.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'timezone', - documentation: 'timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + isDeprecated: false, + default: + 'DefaultParameterValue{value=DEFAULT_TEMPORAL_ARGUMENT, type=ANY}', + description: 'timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + name: 'timezone', + type: 'ANY', }, ], + signature: + 'time.realtime(timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY) :: ZONED TIME', + returnDescription: 'ZONED TIME', + aggregating: false, }, 'time.statement': { - label: 'time.statement', - documentation: + name: 'time.statement', + category: 'Temporal', + description: 'Returns the current `ZONED TIME` instant using the statement clock.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'timezone', - documentation: 'timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + isDeprecated: false, + default: + 'DefaultParameterValue{value=DEFAULT_TEMPORAL_ARGUMENT, type=ANY}', + description: 'timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + name: 'timezone', + type: 'ANY', }, ], + signature: + 'time.statement(timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY) :: ZONED TIME', + returnDescription: 'ZONED TIME', + aggregating: false, }, 'time.transaction': { - label: 'time.transaction', - documentation: + name: 'time.transaction', + category: 'Temporal', + description: 'Returns the current `ZONED TIME` instant using the transaction clock.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'timezone', - documentation: 'timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + isDeprecated: false, + default: + 'DefaultParameterValue{value=DEFAULT_TEMPORAL_ARGUMENT, type=ANY}', + description: 'timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + name: 'timezone', + type: 'ANY', }, ], + signature: + 'time.transaction(timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY) :: ZONED TIME', + returnDescription: 'ZONED TIME', + aggregating: false, }, 'time.truncate': { - label: 'time.truncate', - documentation: + name: 'time.truncate', + category: 'Temporal', + description: 'Truncates the given temporal value to a `ZONED TIME` instant using the specified unit.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'unit', - documentation: 'unit :: STRING', + isDeprecated: false, + description: 'unit :: STRING', + name: 'unit', + type: 'STRING', }, { - label: 'input', - documentation: 'input = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + isDeprecated: false, + default: + 'DefaultParameterValue{value=DEFAULT_TEMPORAL_ARGUMENT, type=ANY}', + description: 'input = DEFAULT_TEMPORAL_ARGUMENT :: ANY', + name: 'input', + type: 'ANY', }, { - label: 'fields', - documentation: 'fields = null :: MAP', + isDeprecated: false, + default: 'DefaultParameterValue{value=null, type=MAP}', + description: 'fields = null :: MAP', + name: 'fields', + type: 'MAP', }, ], + signature: + 'time.truncate(unit :: STRING, input = DEFAULT_TEMPORAL_ARGUMENT :: ANY, fields = null :: MAP) :: ZONED TIME', + returnDescription: 'ZONED TIME', + aggregating: false, }, timestamp: { - label: 'timestamp', - documentation: + name: 'timestamp', + category: 'Scalar', + description: 'Returns the difference, measured in milliseconds, between the current time and midnight, January 1, 1970 UTC', - parameters: [], + isBuiltIn: true, + argumentDescription: [], + signature: 'timestamp() :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, toBoolean: { - label: 'toBoolean', - documentation: + name: 'toBoolean', + category: 'Scalar', + description: 'Converts a `BOOLEAN`, `STRING` or `INTEGER` value to a `BOOLEAN` value. For `INTEGER` values, 0 is defined to be false and any other `INTEGER` is defined to be true.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: BOOLEAN | STRING | INTEGER', + isDeprecated: false, + description: 'input :: BOOLEAN | STRING | INTEGER', + name: 'input', + type: 'BOOLEAN | STRING | INTEGER', }, ], + signature: 'toBoolean(input :: BOOLEAN | STRING | INTEGER) :: BOOLEAN', + returnDescription: 'BOOLEAN', + aggregating: false, }, toBooleanList: { - label: 'toBooleanList', - documentation: + name: 'toBooleanList', + category: 'List', + description: 'Converts a `LIST` of values to a `LIST` values. If any values are not convertible to `BOOLEAN` they will be null in the `LIST` returned.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: LIST', + isDeprecated: false, + description: 'input :: LIST', + name: 'input', + type: 'LIST', }, ], + signature: 'toBooleanList(input :: LIST) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, toBooleanOrNull: { - label: 'toBooleanOrNull', - documentation: + name: 'toBooleanOrNull', + category: 'Scalar', + description: 'Converts a value to a `BOOLEAN` value, or null if the value cannot be converted.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: ANY', + isDeprecated: false, + description: 'input :: ANY', + name: 'input', + type: 'ANY', }, ], + signature: 'toBooleanOrNull(input :: ANY) :: BOOLEAN', + returnDescription: 'BOOLEAN', + aggregating: false, }, toFloat: { - label: 'toFloat', - documentation: + name: 'toFloat', + category: 'Scalar', + description: 'Converts a `STRING`, `INTEGER` or `FLOAT` value to a `FLOAT` value.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: STRING | INTEGER | FLOAT', + isDeprecated: false, + description: 'input :: STRING | INTEGER | FLOAT', + name: 'input', + type: 'STRING | INTEGER | FLOAT', }, ], + signature: 'toFloat(input :: STRING | INTEGER | FLOAT) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, toFloatList: { - label: 'toFloatList', - documentation: + name: 'toFloatList', + category: 'List', + description: 'Converts a `LIST` to a `LIST` values. If any values are not convertible to `FLOAT` they will be null in the `LIST` returned.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: LIST', + isDeprecated: false, + description: 'input :: LIST', + name: 'input', + type: 'LIST', }, ], + signature: 'toFloatList(input :: LIST) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, toFloatOrNull: { - label: 'toFloatOrNull', - documentation: + name: 'toFloatOrNull', + category: 'Scalar', + description: 'Converts a value to a `FLOAT` value, or null if the value cannot be converted.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: ANY', + isDeprecated: false, + description: 'input :: ANY', + name: 'input', + type: 'ANY', }, ], + signature: 'toFloatOrNull(input :: ANY) :: FLOAT', + returnDescription: 'FLOAT', + aggregating: false, }, toInteger: { - label: 'toInteger', - documentation: + name: 'toInteger', + category: 'Scalar', + description: 'Converts a `BOOLEAN`, `STRING`, `INTEGER` or `FLOAT` value to an `INTEGER` value. For `BOOLEAN` values, true is defined to be 1 and false is defined to be 0.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: BOOLEAN | STRING | INTEGER | FLOAT', + isDeprecated: false, + description: 'input :: BOOLEAN | STRING | INTEGER | FLOAT', + name: 'input', + type: 'BOOLEAN | STRING | INTEGER | FLOAT', }, ], + signature: + 'toInteger(input :: BOOLEAN | STRING | INTEGER | FLOAT) :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, toIntegerList: { - label: 'toIntegerList', - documentation: + name: 'toIntegerList', + category: 'List', + description: 'Converts a `LIST` to a `LIST` values. If any values are not convertible to `INTEGER` they will be null in the `LIST` returned.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: LIST', + isDeprecated: false, + description: 'input :: LIST', + name: 'input', + type: 'LIST', }, ], + signature: 'toIntegerList(input :: LIST) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, toIntegerOrNull: { - label: 'toIntegerOrNull', - documentation: + name: 'toIntegerOrNull', + category: 'Scalar', + description: 'Converts a value to an `INTEGER` value, or null if the value cannot be converted.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: ANY', + isDeprecated: false, + description: 'input :: ANY', + name: 'input', + type: 'ANY', }, ], + signature: 'toIntegerOrNull(input :: ANY) :: INTEGER', + returnDescription: 'INTEGER', + aggregating: false, }, toLower: { - label: 'toLower', - documentation: 'Returns the given `STRING` in lowercase.', - parameters: [ + name: 'toLower', + category: 'String', + description: 'Returns the given `STRING` in lowercase.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: STRING', + isDeprecated: false, + description: 'input :: STRING', + name: 'input', + type: 'STRING', }, ], + signature: 'toLower(input :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, toString: { - label: 'toString', - documentation: + name: 'toString', + category: 'String', + description: 'Converts an `INTEGER`, `FLOAT`, `BOOLEAN`, `POINT` or temporal type (i.e. `DATE`, `ZONED TIME`, `LOCAL TIME`, `ZONED DATETIME`, `LOCAL DATETIME` or `DURATION`) value to a `STRING`.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: ANY', + isDeprecated: false, + description: 'input :: ANY', + name: 'input', + type: 'ANY', }, ], + signature: 'toString(input :: ANY) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, toStringList: { - label: 'toStringList', - documentation: + name: 'toStringList', + category: 'List', + description: 'Converts a `LIST` to a `LIST` values. If any values are not convertible to `STRING` they will be null in the `LIST` returned.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: LIST', + isDeprecated: false, + description: 'input :: LIST', + name: 'input', + type: 'LIST', }, ], + signature: 'toStringList(input :: LIST) :: LIST', + returnDescription: 'LIST', + aggregating: false, }, toStringOrNull: { - label: 'toStringOrNull', - documentation: + name: 'toStringOrNull', + category: 'String', + description: 'Converts an `INTEGER`, `FLOAT`, `BOOLEAN`, `POINT` or temporal type (i.e. `DATE`, `ZONED TIME`, `LOCAL TIME`, `ZONED DATETIME`, `LOCAL DATETIME` or `DURATION`) value to a `STRING`, or null if the value cannot be converted.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: ANY', + isDeprecated: false, + description: 'input :: ANY', + name: 'input', + type: 'ANY', }, ], + signature: 'toStringOrNull(input :: ANY) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, toUpper: { - label: 'toUpper', - documentation: 'Returns the given `STRING` in uppercase.', - parameters: [ + name: 'toUpper', + category: 'String', + description: 'Returns the given `STRING` in uppercase.', + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: STRING', + isDeprecated: false, + description: 'input :: STRING', + name: 'input', + type: 'STRING', }, ], + signature: 'toUpper(input :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, trim: { - label: 'trim', - documentation: + name: 'trim', + category: 'String', + description: 'Returns the given `STRING` with leading and trailing whitespace removed.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: STRING', + isDeprecated: false, + description: 'input :: STRING', + name: 'input', + type: 'STRING', }, ], + signature: 'trim(input :: STRING) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, type: { - label: 'type', - documentation: + name: 'type', + category: 'Scalar', + description: 'Returns a `STRING` representation of the `RELATIONSHIP` type.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: RELATIONSHIP', + isDeprecated: false, + description: 'input :: RELATIONSHIP', + name: 'input', + type: 'RELATIONSHIP', }, ], + signature: 'type(input :: RELATIONSHIP) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, valueType: { - label: 'valueType', - documentation: + name: 'valueType', + category: 'Scalar', + description: 'Returns a `STRING` representation of the most precise value type that the given expression evaluates to.', - parameters: [ + isBuiltIn: true, + argumentDescription: [ { - label: 'input', - documentation: 'input :: ANY', + isDeprecated: false, + description: 'input :: ANY', + name: 'input', + type: 'ANY', }, ], + signature: 'valueType(input :: ANY) :: STRING', + returnDescription: 'STRING', + aggregating: false, }, }, - procedureSignatures: { + procedures: { 'apoc.algo.aStar': { - label: 'apoc.algo.aStar', - documentation: + name: 'apoc.algo.aStar', + description: 'Runs the A* search algorithm to find the optimal path between two `NODE` values, using the given `RELATIONSHIP` property name for the cost function.', - parameters: [ + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'startNode :: NODE', + name: 'startNode', + type: 'NODE', + }, { - label: 'startNode', - documentation: 'startNode :: NODE', + isDeprecated: false, + description: 'endNode :: NODE', + name: 'endNode', + type: 'NODE', }, { - label: 'endNode', - documentation: 'endNode :: NODE', + isDeprecated: false, + description: 'relTypesAndDirections :: STRING', + name: 'relTypesAndDirections', + type: 'STRING', }, { - label: 'relTypesAndDirections', - documentation: 'relTypesAndDirections :: STRING', + isDeprecated: false, + description: 'weightPropertyName :: STRING', + name: 'weightPropertyName', + type: 'STRING', }, { - label: 'weightPropertyName', - documentation: 'weightPropertyName :: STRING', + isDeprecated: false, + description: 'latPropertyName :: STRING', + name: 'latPropertyName', + type: 'STRING', }, { - label: 'latPropertyName', - documentation: 'latPropertyName :: STRING', + isDeprecated: false, + description: 'lonPropertyName :: STRING', + name: 'lonPropertyName', + type: 'STRING', + }, + ], + signature: + 'apoc.algo.aStar(startNode :: NODE, endNode :: NODE, relTypesAndDirections :: STRING, weightPropertyName :: STRING, latPropertyName :: STRING, lonPropertyName :: STRING) :: (path :: PATH, weight :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'path :: PATH', + name: 'path', + type: 'PATH', }, { - label: 'lonPropertyName', - documentation: 'lonPropertyName :: STRING', + isDeprecated: false, + description: 'weight :: FLOAT', + name: 'weight', + type: 'FLOAT', }, ], + admin: false, + option: { + deprecated: false, + }, }, 'apoc.algo.aStarConfig': { - label: 'apoc.algo.aStarConfig', - documentation: + name: 'apoc.algo.aStarConfig', + description: 'Runs the A* search algorithm to find the optimal path between two `NODE` values, using the given `RELATIONSHIP` property name for the cost function.\nThis procedure looks for weight, latitude and longitude properties in the config.', - parameters: [ + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'startNode :: NODE', + name: 'startNode', + type: 'NODE', + }, + { + isDeprecated: false, + description: 'endNode :: NODE', + name: 'endNode', + type: 'NODE', + }, { - label: 'startNode', - documentation: 'startNode :: NODE', + isDeprecated: false, + description: 'relTypesAndDirections :: STRING', + name: 'relTypesAndDirections', + type: 'STRING', }, { - label: 'endNode', - documentation: 'endNode :: NODE', + isDeprecated: false, + description: 'config :: MAP', + name: 'config', + type: 'MAP', }, + ], + signature: + 'apoc.algo.aStarConfig(startNode :: NODE, endNode :: NODE, relTypesAndDirections :: STRING, config :: MAP) :: (path :: PATH, weight :: FLOAT)', + returnDescription: [ { - label: 'relTypesAndDirections', - documentation: 'relTypesAndDirections :: STRING', + isDeprecated: false, + description: 'path :: PATH', + name: 'path', + type: 'PATH', }, { - label: 'config', - documentation: 'config :: MAP', + isDeprecated: false, + description: 'weight :: FLOAT', + name: 'weight', + type: 'FLOAT', }, ], + admin: false, + option: { + deprecated: false, + }, }, 'apoc.algo.allSimplePaths': { - label: 'apoc.algo.allSimplePaths', - documentation: + name: 'apoc.algo.allSimplePaths', + description: 'Runs a search algorithm to find all of the simple paths between the given `RELATIONSHIP` values, up to a max depth described by `maxNodes`.\nThe returned paths will not contain loops.', - parameters: [ + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ { - label: 'startNode', - documentation: 'startNode :: NODE', + isDeprecated: false, + description: 'startNode :: NODE', + name: 'startNode', + type: 'NODE', }, { - label: 'endNode', - documentation: 'endNode :: NODE', + isDeprecated: false, + description: 'endNode :: NODE', + name: 'endNode', + type: 'NODE', }, { - label: 'relTypesAndDirections', - documentation: 'relTypesAndDirections :: STRING', + isDeprecated: false, + description: 'relTypesAndDirections :: STRING', + name: 'relTypesAndDirections', + type: 'STRING', }, { - label: 'maxNodes', - documentation: 'maxNodes :: INTEGER', + isDeprecated: false, + description: 'maxNodes :: INTEGER', + name: 'maxNodes', + type: 'INTEGER', }, ], + signature: + 'apoc.algo.allSimplePaths(startNode :: NODE, endNode :: NODE, relTypesAndDirections :: STRING, maxNodes :: INTEGER) :: (path :: PATH)', + returnDescription: [ + { + isDeprecated: false, + description: 'path :: PATH', + name: 'path', + type: 'PATH', + }, + ], + admin: false, + option: { + deprecated: false, + }, }, 'apoc.algo.cover': { - label: 'apoc.algo.cover', - documentation: + name: 'apoc.algo.cover', + description: 'Returns all `RELATIONSHIP` values connecting the given set of `NODE` values.', - parameters: [ + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'nodes :: ANY', + name: 'nodes', + type: 'ANY', + }, + ], + signature: 'apoc.algo.cover(nodes :: ANY) :: (rel :: RELATIONSHIP)', + returnDescription: [ { - label: 'nodes', - documentation: 'nodes :: ANY', + isDeprecated: false, + description: 'rel :: RELATIONSHIP', + name: 'rel', + type: 'RELATIONSHIP', }, ], + admin: false, + option: { + deprecated: false, + }, }, 'apoc.algo.dijkstra': { - label: 'apoc.algo.dijkstra', - documentation: + name: 'apoc.algo.dijkstra', + description: "Runs Dijkstra's algorithm using the given `RELATIONSHIP` property as the cost function.", - parameters: [ + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'startNode :: NODE', + name: 'startNode', + type: 'NODE', + }, { - label: 'startNode', - documentation: 'startNode :: NODE', + isDeprecated: false, + description: 'endNode :: NODE', + name: 'endNode', + type: 'NODE', }, { - label: 'endNode', - documentation: 'endNode :: NODE', + isDeprecated: false, + description: 'relTypesAndDirections :: STRING', + name: 'relTypesAndDirections', + type: 'STRING', }, { - label: 'relTypesAndDirections', - documentation: 'relTypesAndDirections :: STRING', + isDeprecated: false, + description: 'weightPropertyName :: STRING', + name: 'weightPropertyName', + type: 'STRING', }, { - label: 'weightPropertyName', - documentation: 'weightPropertyName :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=NaN, type=FLOAT}', + description: 'defaultWeight = NaN :: FLOAT', + name: 'defaultWeight', + type: 'FLOAT', }, { - label: 'defaultWeight', - documentation: 'defaultWeight = NaN :: FLOAT', + isDeprecated: false, + default: 'DefaultParameterValue{value=1, type=INTEGER}', + description: 'numberOfWantedPaths = 1 :: INTEGER', + name: 'numberOfWantedPaths', + type: 'INTEGER', + }, + ], + signature: + 'apoc.algo.dijkstra(startNode :: NODE, endNode :: NODE, relTypesAndDirections :: STRING, weightPropertyName :: STRING, defaultWeight = NaN :: FLOAT, numberOfWantedPaths = 1 :: INTEGER) :: (path :: PATH, weight :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'path :: PATH', + name: 'path', + type: 'PATH', }, { - label: 'numberOfWantedPaths', - documentation: 'numberOfWantedPaths = 1 :: INTEGER', + isDeprecated: false, + description: 'weight :: FLOAT', + name: 'weight', + type: 'FLOAT', }, ], + admin: false, + option: { + deprecated: false, + }, }, 'apoc.atomic.add': { - label: 'apoc.atomic.add', - documentation: + name: 'apoc.atomic.add', + description: 'Sets the given property to the sum of itself and the given `INTEGER` or `FLOAT` value.\nThe procedure then sets the property to the returned sum.', - parameters: [ + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ { - label: 'container', - documentation: 'container :: ANY', + isDeprecated: false, + description: 'container :: ANY', + name: 'container', + type: 'ANY', }, { - label: 'propertyName', - documentation: 'propertyName :: STRING', + isDeprecated: false, + description: 'propertyName :: STRING', + name: 'propertyName', + type: 'STRING', }, { - label: 'number', - documentation: 'number :: INTEGER | FLOAT', + isDeprecated: false, + description: 'number :: INTEGER | FLOAT', + name: 'number', + type: 'INTEGER | FLOAT', }, { - label: 'retryAttempts', - documentation: 'retryAttempts = 5 :: INTEGER', + isDeprecated: false, + default: 'DefaultParameterValue{value=5, type=INTEGER}', + description: 'retryAttempts = 5 :: INTEGER', + name: 'retryAttempts', + type: 'INTEGER', }, ], - }, - 'apoc.atomic.concat': { - label: 'apoc.atomic.concat', - documentation: - 'Sets the given property to the concatenation of itself and the `STRING` value.\nThe procedure then sets the property to the returned `STRING`.', - parameters: [ + signature: + 'apoc.atomic.add(container :: ANY, propertyName :: STRING, number :: INTEGER | FLOAT, retryAttempts = 5 :: INTEGER) :: (container :: ANY, property :: STRING, oldValue :: ANY, newValue :: ANY)', + returnDescription: [ { - label: 'container', - documentation: 'container :: ANY', + isDeprecated: false, + description: 'container :: ANY', + name: 'container', + type: 'ANY', }, { - label: 'propertyName', - documentation: 'propertyName :: STRING', + isDeprecated: false, + description: 'property :: STRING', + name: 'property', + type: 'STRING', }, { - label: 'string', - documentation: 'string :: STRING', + isDeprecated: false, + description: 'oldValue :: ANY', + name: 'oldValue', + type: 'ANY', }, { - label: 'retryAttempts', - documentation: 'retryAttempts = 5 :: INTEGER', + isDeprecated: false, + description: 'newValue :: ANY', + name: 'newValue', + type: 'ANY', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.atomic.insert': { - label: 'apoc.atomic.insert', - documentation: - 'Inserts a value at position into the `LIST` value of a property.\nThe procedure then sets the result back on the property.', - parameters: [ - { - label: 'container', - documentation: 'container :: ANY', - }, + 'apoc.atomic.concat': { + name: 'apoc.atomic.concat', + description: + 'Sets the given property to the concatenation of itself and the `STRING` value.\nThe procedure then sets the property to the returned `STRING`.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ { - label: 'propertyName', - documentation: 'propertyName :: STRING', + isDeprecated: false, + description: 'container :: ANY', + name: 'container', + type: 'ANY', }, { - label: 'position', - documentation: 'position :: INTEGER', + isDeprecated: false, + description: 'propertyName :: STRING', + name: 'propertyName', + type: 'STRING', }, { - label: 'value', - documentation: 'value :: ANY', + isDeprecated: false, + description: 'string :: STRING', + name: 'string', + type: 'STRING', }, { - label: 'retryAttempts', - documentation: 'retryAttempts = 5 :: INTEGER', + isDeprecated: false, + default: 'DefaultParameterValue{value=5, type=INTEGER}', + description: 'retryAttempts = 5 :: INTEGER', + name: 'retryAttempts', + type: 'INTEGER', }, ], - }, - 'apoc.atomic.remove': { - label: 'apoc.atomic.remove', - documentation: - 'Removes the element at position from the `LIST` value of a property.\nThe procedure then sets the property to the resulting `LIST` value.', - parameters: [ + signature: + 'apoc.atomic.concat(container :: ANY, propertyName :: STRING, string :: STRING, retryAttempts = 5 :: INTEGER) :: (container :: ANY, property :: STRING, oldValue :: ANY, newValue :: ANY)', + returnDescription: [ { - label: 'container', - documentation: 'container :: ANY', + isDeprecated: false, + description: 'container :: ANY', + name: 'container', + type: 'ANY', }, { - label: 'propertyName', - documentation: 'propertyName :: STRING', + isDeprecated: false, + description: 'property :: STRING', + name: 'property', + type: 'STRING', }, { - label: 'position', - documentation: 'position :: INTEGER', + isDeprecated: false, + description: 'oldValue :: ANY', + name: 'oldValue', + type: 'ANY', }, { - label: 'retryAttempts', - documentation: 'retryAttempts = 5 :: INTEGER', + isDeprecated: false, + description: 'newValue :: ANY', + name: 'newValue', + type: 'ANY', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.atomic.subtract': { - label: 'apoc.atomic.subtract', - documentation: - 'Sets the property of a value to itself minus the given `INTEGER` or `FLOAT` value.\nThe procedure then sets the property to the returned sum.', - parameters: [ + 'apoc.atomic.insert': { + name: 'apoc.atomic.insert', + description: + 'Inserts a value at position into the `LIST` value of a property.\nThe procedure then sets the result back on the property.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'container :: ANY', + name: 'container', + type: 'ANY', + }, { - label: 'container', - documentation: 'container :: ANY', + isDeprecated: false, + description: 'propertyName :: STRING', + name: 'propertyName', + type: 'STRING', }, { - label: 'propertyName', - documentation: 'propertyName :: STRING', + isDeprecated: false, + description: 'position :: INTEGER', + name: 'position', + type: 'INTEGER', }, { - label: 'number', - documentation: 'number :: INTEGER | FLOAT', + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', }, { - label: 'retryAttempts', - documentation: 'retryAttempts = 5 :: INTEGER', + isDeprecated: false, + default: 'DefaultParameterValue{value=5, type=INTEGER}', + description: 'retryAttempts = 5 :: INTEGER', + name: 'retryAttempts', + type: 'INTEGER', }, ], - }, - 'apoc.atomic.update': { - label: 'apoc.atomic.update', - documentation: 'Updates the value of a property with a Cypher operation.', - parameters: [ + signature: + 'apoc.atomic.insert(container :: ANY, propertyName :: STRING, position :: INTEGER, value :: ANY, retryAttempts = 5 :: INTEGER) :: (container :: ANY, property :: STRING, oldValue :: ANY, newValue :: ANY)', + returnDescription: [ { - label: 'container', - documentation: 'container :: ANY', + isDeprecated: false, + description: 'container :: ANY', + name: 'container', + type: 'ANY', }, { - label: 'propertyName', - documentation: 'propertyName :: STRING', + isDeprecated: false, + description: 'property :: STRING', + name: 'property', + type: 'STRING', }, { - label: 'operation', - documentation: 'operation :: STRING', + isDeprecated: false, + description: 'oldValue :: ANY', + name: 'oldValue', + type: 'ANY', }, { - label: 'retryAttempts', - documentation: 'retryAttempts = 5 :: INTEGER', + isDeprecated: false, + description: 'newValue :: ANY', + name: 'newValue', + type: 'ANY', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.case': { - label: 'apoc.case', - documentation: - 'For each pair of conditional and read-only queries in the given `LIST`, this procedure will run the first query for which the conditional is evaluated to true. If none of the conditionals are true, the `ELSE` query will run instead.', - parameters: [ + 'apoc.atomic.remove': { + name: 'apoc.atomic.remove', + description: + 'Removes the element at position from the `LIST` value of a property.\nThe procedure then sets the property to the resulting `LIST` value.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'container :: ANY', + name: 'container', + type: 'ANY', + }, { - label: 'conditionals', - documentation: 'conditionals :: LIST', + isDeprecated: false, + description: 'propertyName :: STRING', + name: 'propertyName', + type: 'STRING', }, { - label: 'elseQuery', - documentation: 'elseQuery = :: STRING', + isDeprecated: false, + description: 'position :: INTEGER', + name: 'position', + type: 'INTEGER', }, { - label: 'params', - documentation: 'params = {} :: MAP', + isDeprecated: false, + default: 'DefaultParameterValue{value=5, type=INTEGER}', + description: 'retryAttempts = 5 :: INTEGER', + name: 'retryAttempts', + type: 'INTEGER', }, ], - }, - 'apoc.coll.elements': { - label: 'apoc.coll.elements', - documentation: - 'Deconstructs a `LIST` into identifiers indicating their specific type.', - parameters: [ + signature: + 'apoc.atomic.remove(container :: ANY, propertyName :: STRING, position :: INTEGER, retryAttempts = 5 :: INTEGER) :: (container :: ANY, property :: STRING, oldValue :: ANY, newValue :: ANY)', + returnDescription: [ { - label: 'coll', - documentation: 'coll :: LIST', + isDeprecated: false, + description: 'container :: ANY', + name: 'container', + type: 'ANY', }, { - label: 'limit', - documentation: 'limit = -1 :: INTEGER', + isDeprecated: false, + description: 'property :: STRING', + name: 'property', + type: 'STRING', }, { - label: 'offset', - documentation: 'offset = 0 :: INTEGER', + isDeprecated: false, + description: 'oldValue :: ANY', + name: 'oldValue', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'newValue :: ANY', + name: 'newValue', + type: 'ANY', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.coll.pairWithOffset': { - label: 'apoc.coll.pairWithOffset', - documentation: 'Returns a `LIST` of pairs defined by the offset.', - parameters: [ + 'apoc.atomic.subtract': { + name: 'apoc.atomic.subtract', + description: + 'Sets the property of a value to itself minus the given `INTEGER` or `FLOAT` value.\nThe procedure then sets the property to the returned sum.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ { - label: 'coll', - documentation: 'coll :: LIST', + isDeprecated: false, + description: 'container :: ANY', + name: 'container', + type: 'ANY', }, { - label: 'offset', - documentation: 'offset :: INTEGER', + isDeprecated: false, + description: 'propertyName :: STRING', + name: 'propertyName', + type: 'STRING', }, - ], - }, - 'apoc.coll.partition': { - label: 'apoc.coll.partition', - documentation: - 'Partitions the original `LIST` into a new `LIST` of the given batch size.\nThe final `LIST` may be smaller than the given batch size.', - parameters: [ { - label: 'coll', - documentation: 'coll :: LIST', + isDeprecated: false, + description: 'number :: INTEGER | FLOAT', + name: 'number', + type: 'INTEGER | FLOAT', }, { - label: 'batchSize', - documentation: 'batchSize :: INTEGER', + isDeprecated: false, + default: 'DefaultParameterValue{value=5, type=INTEGER}', + description: 'retryAttempts = 5 :: INTEGER', + name: 'retryAttempts', + type: 'INTEGER', }, ], - }, - 'apoc.coll.split': { - label: 'apoc.coll.split', - documentation: - 'Splits a collection by the given value.\nThe value itself will not be part of the resulting `LIST` values.', - parameters: [ + signature: + 'apoc.atomic.subtract(container :: ANY, propertyName :: STRING, number :: INTEGER | FLOAT, retryAttempts = 5 :: INTEGER) :: (container :: ANY, property :: STRING, oldValue :: ANY, newValue :: ANY)', + returnDescription: [ { - label: 'coll', - documentation: 'coll :: LIST', + isDeprecated: false, + description: 'container :: ANY', + name: 'container', + type: 'ANY', }, { - label: 'value', - documentation: 'value :: ANY', + isDeprecated: false, + description: 'property :: STRING', + name: 'property', + type: 'STRING', }, - ], - }, - 'apoc.coll.zipToRows': { - label: 'apoc.coll.zipToRows', - documentation: - 'Returns the two `LIST` values zipped together, with one row per zipped pair.', - parameters: [ { - label: 'list1', - documentation: 'list1 :: LIST', + isDeprecated: false, + description: 'oldValue :: ANY', + name: 'oldValue', + type: 'ANY', }, { - label: 'list2', - documentation: 'list2 :: LIST', + isDeprecated: false, + description: 'newValue :: ANY', + name: 'newValue', + type: 'ANY', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.convert.setJsonProperty': { - label: 'apoc.convert.setJsonProperty', - documentation: - 'Serializes the given JSON object and sets it as a property on the given `NODE`.', - parameters: [ + 'apoc.atomic.update': { + name: 'apoc.atomic.update', + description: 'Updates the value of a property with a Cypher operation.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'container :: ANY', + name: 'container', + type: 'ANY', + }, { - label: 'node', - documentation: 'node :: NODE', + isDeprecated: false, + description: 'propertyName :: STRING', + name: 'propertyName', + type: 'STRING', }, { - label: 'key', - documentation: 'key :: STRING', + isDeprecated: false, + description: 'operation :: STRING', + name: 'operation', + type: 'STRING', }, { - label: 'value', - documentation: 'value :: ANY', + isDeprecated: false, + default: 'DefaultParameterValue{value=5, type=INTEGER}', + description: 'retryAttempts = 5 :: INTEGER', + name: 'retryAttempts', + type: 'INTEGER', }, ], - }, - 'apoc.convert.toTree': { - label: 'apoc.convert.toTree', - documentation: - 'Returns a stream of `MAP` values, representing the given `PATH` values as a tree with at least one root.', - parameters: [ + signature: + 'apoc.atomic.update(container :: ANY, propertyName :: STRING, operation :: STRING, retryAttempts = 5 :: INTEGER) :: (container :: ANY, property :: STRING, oldValue :: ANY, newValue :: ANY)', + returnDescription: [ { - label: 'paths', - documentation: 'paths :: LIST', + isDeprecated: false, + description: 'container :: ANY', + name: 'container', + type: 'ANY', }, { - label: 'lowerCaseRels', - documentation: 'lowerCaseRels = true :: BOOLEAN', + isDeprecated: false, + description: 'property :: STRING', + name: 'property', + type: 'STRING', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'oldValue :: ANY', + name: 'oldValue', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'newValue :: ANY', + name: 'newValue', + type: 'ANY', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.create.addLabels': { - label: 'apoc.create.addLabels', - documentation: 'Adds the given labels to the given `NODE` values.', - parameters: [ + 'apoc.case': { + name: 'apoc.case', + description: + 'For each pair of conditional and read-only queries in the given `LIST`, this procedure will run the first query for which the conditional is evaluated to true. If none of the conditionals are true, the `ELSE` query will run instead.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ { - label: 'nodes', - documentation: 'nodes :: ANY', + isDeprecated: false, + description: 'conditionals :: LIST', + name: 'conditionals', + type: 'LIST', }, { - label: 'labels', - documentation: 'labels :: LIST', + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'elseQuery = :: STRING', + name: 'elseQuery', + type: 'STRING', }, - ], - }, - 'apoc.create.clonePathToVirtual': { - label: 'apoc.create.clonePathToVirtual', - documentation: - 'Takes the given `PATH` and returns a virtual representation of it.', - parameters: [ { - label: 'path', - documentation: 'path :: PATH', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'params = {} :: MAP', + name: 'params', + type: 'MAP', }, ], - }, - 'apoc.create.clonePathsToVirtual': { - label: 'apoc.create.clonePathsToVirtual', - documentation: - 'Takes the given `LIST` and returns a virtual representation of them.', - parameters: [ + signature: + 'apoc.case(conditionals :: LIST, elseQuery = :: STRING, params = {} :: MAP) :: (value :: MAP)', + returnDescription: [ { - label: 'paths', - documentation: 'paths :: LIST', + isDeprecated: false, + description: 'value :: MAP', + name: 'value', + type: 'MAP', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.create.node': { - label: 'apoc.create.node', - documentation: 'Creates a `NODE` with the given dynamic labels.', - parameters: [ + 'apoc.coll.elements': { + name: 'apoc.coll.elements', + description: + 'Deconstructs a `LIST` into identifiers indicating their specific type.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'coll :: LIST', + name: 'coll', + type: 'LIST', + }, { - label: 'labels', - documentation: 'labels :: LIST', + isDeprecated: false, + default: 'DefaultParameterValue{value=-1, type=INTEGER}', + description: 'limit = -1 :: INTEGER', + name: 'limit', + type: 'INTEGER', }, { - label: 'props', - documentation: 'props :: MAP', + isDeprecated: false, + default: 'DefaultParameterValue{value=0, type=INTEGER}', + description: 'offset = 0 :: INTEGER', + name: 'offset', + type: 'INTEGER', }, ], - }, - 'apoc.create.nodes': { - label: 'apoc.create.nodes', - documentation: 'Creates `NODE` values with the given dynamic labels.', - parameters: [ + signature: + 'apoc.coll.elements(coll :: LIST, limit = -1 :: INTEGER, offset = 0 :: INTEGER) :: (_1 :: ANY, _2 :: ANY, _3 :: ANY, _4 :: ANY, _5 :: ANY, _6 :: ANY, _7 :: ANY, _8 :: ANY, _9 :: ANY, _10 :: ANY, _1s :: STRING, _2s :: STRING, _3s :: STRING, _4s :: STRING, _5s :: STRING, _6s :: STRING, _7s :: STRING, _8s :: STRING, _9s :: STRING, _10s :: STRING, _1i :: INTEGER, _2i :: INTEGER, _3i :: INTEGER, _4i :: INTEGER, _5i :: INTEGER, _6i :: INTEGER, _7i :: INTEGER, _8i :: INTEGER, _9i :: INTEGER, _10i :: INTEGER, _1f :: FLOAT, _2f :: FLOAT, _3f :: FLOAT, _4f :: FLOAT, _5f :: FLOAT, _6f :: FLOAT, _7f :: FLOAT, _8f :: FLOAT, _9f :: FLOAT, _10f :: FLOAT, _1b :: BOOLEAN, _2b :: BOOLEAN, _3b :: BOOLEAN, _4b :: BOOLEAN, _5b :: BOOLEAN, _6b :: BOOLEAN, _7b :: BOOLEAN, _8b :: BOOLEAN, _9b :: BOOLEAN, _10b :: BOOLEAN, _1l :: LIST, _2l :: LIST, _3l :: LIST, _4l :: LIST, _5l :: LIST, _6l :: LIST, _7l :: LIST, _8l :: LIST, _9l :: LIST, _10l :: LIST, _1m :: MAP, _2m :: MAP, _3m :: MAP, _4m :: MAP, _5m :: MAP, _6m :: MAP, _7m :: MAP, _8m :: MAP, _9m :: MAP, _10m :: MAP, _1n :: NODE, _2n :: NODE, _3n :: NODE, _4n :: NODE, _5n :: NODE, _6n :: NODE, _7n :: NODE, _8n :: NODE, _9n :: NODE, _10n :: NODE, _1r :: RELATIONSHIP, _2r :: RELATIONSHIP, _3r :: RELATIONSHIP, _4r :: RELATIONSHIP, _5r :: RELATIONSHIP, _6r :: RELATIONSHIP, _7r :: RELATIONSHIP, _8r :: RELATIONSHIP, _9r :: RELATIONSHIP, _10r :: RELATIONSHIP, _1p :: PATH, _2p :: PATH, _3p :: PATH, _4p :: PATH, _5p :: PATH, _6p :: PATH, _7p :: PATH, _8p :: PATH, _9p :: PATH, _10p :: PATH, elements :: INTEGER)', + returnDescription: [ { - label: 'labels', - documentation: 'labels :: LIST', + isDeprecated: false, + description: '_1 :: ANY', + name: '_1', + type: 'ANY', }, { - label: 'props', - documentation: 'props :: LIST', + isDeprecated: false, + description: '_2 :: ANY', + name: '_2', + type: 'ANY', }, - ], - }, - 'apoc.create.relationship': { - label: 'apoc.create.relationship', - documentation: - 'Creates a `RELATIONSHIP` with the given dynamic relationship type.', - parameters: [ { - label: 'from', - documentation: 'from :: NODE', + isDeprecated: false, + description: '_3 :: ANY', + name: '_3', + type: 'ANY', }, { - label: 'relType', - documentation: 'relType :: STRING', + isDeprecated: false, + description: '_4 :: ANY', + name: '_4', + type: 'ANY', }, { - label: 'props', - documentation: 'props :: MAP', + isDeprecated: false, + description: '_5 :: ANY', + name: '_5', + type: 'ANY', }, { - label: 'to', - documentation: 'to :: NODE', + isDeprecated: false, + description: '_6 :: ANY', + name: '_6', + type: 'ANY', }, - ], - }, - 'apoc.create.removeLabels': { - label: 'apoc.create.removeLabels', - documentation: 'Removes the given labels from the given `NODE` values.', - parameters: [ { - label: 'nodes', - documentation: 'nodes :: ANY', + isDeprecated: false, + description: '_7 :: ANY', + name: '_7', + type: 'ANY', }, { - label: 'labels', - documentation: 'labels :: LIST', + isDeprecated: false, + description: '_8 :: ANY', + name: '_8', + type: 'ANY', }, - ], - }, - 'apoc.create.removeProperties': { - label: 'apoc.create.removeProperties', - documentation: - 'Removes the given properties from the given `NODE` values.', - parameters: [ { - label: 'nodes', - documentation: 'nodes :: ANY', + isDeprecated: false, + description: '_9 :: ANY', + name: '_9', + type: 'ANY', }, { - label: 'keys', - documentation: 'keys :: LIST', + isDeprecated: false, + description: '_10 :: ANY', + name: '_10', + type: 'ANY', }, - ], - }, - 'apoc.create.removeRelProperties': { - label: 'apoc.create.removeRelProperties', - documentation: - 'Removes the given properties from the given `RELATIONSHIP` values.', - parameters: [ { - label: 'rels', - documentation: 'rels :: ANY', + isDeprecated: false, + description: '_1s :: STRING', + name: '_1s', + type: 'STRING', }, { - label: 'keys', - documentation: 'keys :: LIST', + isDeprecated: false, + description: '_2s :: STRING', + name: '_2s', + type: 'STRING', }, - ], - }, - 'apoc.create.setLabels': { - label: 'apoc.create.setLabels', - documentation: - 'Sets the given labels to the given `NODE` values. Non-matching labels are removed from the nodes.', - parameters: [ { - label: 'nodes', - documentation: 'nodes :: ANY', + isDeprecated: false, + description: '_3s :: STRING', + name: '_3s', + type: 'STRING', }, { - label: 'labels', - documentation: 'labels :: LIST', + isDeprecated: false, + description: '_4s :: STRING', + name: '_4s', + type: 'STRING', }, - ], - }, - 'apoc.create.setProperties': { - label: 'apoc.create.setProperties', - documentation: 'Sets the given properties to the given `NODE` values.', - parameters: [ { - label: 'nodes', - documentation: 'nodes :: ANY', + isDeprecated: false, + description: '_5s :: STRING', + name: '_5s', + type: 'STRING', }, { - label: 'keys', - documentation: 'keys :: LIST', + isDeprecated: false, + description: '_6s :: STRING', + name: '_6s', + type: 'STRING', }, { - label: 'values', - documentation: 'values :: LIST', + isDeprecated: false, + description: '_7s :: STRING', + name: '_7s', + type: 'STRING', }, - ], - }, - 'apoc.create.setProperty': { - label: 'apoc.create.setProperty', - documentation: 'Sets the given property to the given `NODE` values.', - parameters: [ { - label: 'nodes', - documentation: 'nodes :: ANY', + isDeprecated: false, + description: '_8s :: STRING', + name: '_8s', + type: 'STRING', }, { - label: 'key', - documentation: 'key :: STRING', + isDeprecated: false, + description: '_9s :: STRING', + name: '_9s', + type: 'STRING', }, { - label: 'value', - documentation: 'value :: ANY', + isDeprecated: false, + description: '_10s :: STRING', + name: '_10s', + type: 'STRING', }, - ], - }, - 'apoc.create.setRelProperties': { - label: 'apoc.create.setRelProperties', - documentation: 'Sets the given properties on the `RELATIONSHIP` values.', - parameters: [ { - label: 'rels', - documentation: 'rels :: ANY', + isDeprecated: false, + description: '_1i :: INTEGER', + name: '_1i', + type: 'INTEGER', }, { - label: 'keys', - documentation: 'keys :: LIST', + isDeprecated: false, + description: '_2i :: INTEGER', + name: '_2i', + type: 'INTEGER', }, { - label: 'values', - documentation: 'values :: LIST', + isDeprecated: false, + description: '_3i :: INTEGER', + name: '_3i', + type: 'INTEGER', }, - ], - }, - 'apoc.create.setRelProperty': { - label: 'apoc.create.setRelProperty', - documentation: 'Sets the given property on the `RELATIONSHIP` values.', - parameters: [ { - label: 'rels', - documentation: 'rels :: ANY', + isDeprecated: false, + description: '_4i :: INTEGER', + name: '_4i', + type: 'INTEGER', }, { - label: 'key', - documentation: 'key :: STRING', + isDeprecated: false, + description: '_5i :: INTEGER', + name: '_5i', + type: 'INTEGER', }, { - label: 'value', - documentation: 'value :: ANY', + isDeprecated: false, + description: '_6i :: INTEGER', + name: '_6i', + type: 'INTEGER', }, - ], - }, - 'apoc.create.uuids': { - label: 'apoc.create.uuids', - documentation: 'Returns a stream of UUIDs.', - parameters: [ { - label: 'count', - documentation: 'count :: INTEGER', + isDeprecated: false, + description: '_7i :: INTEGER', + name: '_7i', + type: 'INTEGER', }, - ], - }, - 'apoc.create.vNode': { - label: 'apoc.create.vNode', - documentation: 'Returns a virtual `NODE`.', - parameters: [ { - label: 'labels', - documentation: 'labels :: LIST', + isDeprecated: false, + description: '_8i :: INTEGER', + name: '_8i', + type: 'INTEGER', }, { - label: 'props', - documentation: 'props :: MAP', + isDeprecated: false, + description: '_9i :: INTEGER', + name: '_9i', + type: 'INTEGER', }, - ], - }, - 'apoc.create.vNodes': { - label: 'apoc.create.vNodes', - documentation: 'Returns virtual `NODE` values.', - parameters: [ { - label: 'labels', - documentation: 'labels :: LIST', + isDeprecated: false, + description: '_10i :: INTEGER', + name: '_10i', + type: 'INTEGER', }, { - label: 'props', - documentation: 'props :: LIST', + isDeprecated: false, + description: '_1f :: FLOAT', + name: '_1f', + type: 'FLOAT', }, - ], - }, - 'apoc.create.vRelationship': { - label: 'apoc.create.vRelationship', - documentation: 'Returns a virtual `RELATIONSHIP`.', - parameters: [ { - label: 'from', - documentation: 'from :: NODE', + isDeprecated: false, + description: '_2f :: FLOAT', + name: '_2f', + type: 'FLOAT', }, { - label: 'relType', - documentation: 'relType :: STRING', + isDeprecated: false, + description: '_3f :: FLOAT', + name: '_3f', + type: 'FLOAT', }, { - label: 'props', - documentation: 'props :: MAP', + isDeprecated: false, + description: '_4f :: FLOAT', + name: '_4f', + type: 'FLOAT', }, { - label: 'to', - documentation: 'to :: NODE', + isDeprecated: false, + description: '_5f :: FLOAT', + name: '_5f', + type: 'FLOAT', }, - ], - }, - 'apoc.create.virtualPath': { - label: 'apoc.create.virtualPath', - documentation: 'Returns a virtual `PATH`.', - parameters: [ { - label: 'labelsN', - documentation: 'labelsN :: LIST', + isDeprecated: false, + description: '_6f :: FLOAT', + name: '_6f', + type: 'FLOAT', }, { - label: 'n', - documentation: 'n :: MAP', + isDeprecated: false, + description: '_7f :: FLOAT', + name: '_7f', + type: 'FLOAT', }, { - label: 'relType', - documentation: 'relType :: STRING', + isDeprecated: false, + description: '_8f :: FLOAT', + name: '_8f', + type: 'FLOAT', }, { - label: 'props', - documentation: 'props :: MAP', + isDeprecated: false, + description: '_9f :: FLOAT', + name: '_9f', + type: 'FLOAT', }, { - label: 'labelsM', - documentation: 'labelsM :: LIST', + isDeprecated: false, + description: '_10f :: FLOAT', + name: '_10f', + type: 'FLOAT', }, { - label: 'm', - documentation: 'm :: MAP', + isDeprecated: false, + description: '_1b :: BOOLEAN', + name: '_1b', + type: 'BOOLEAN', }, - ], - }, - 'apoc.cypher.doIt': { - label: 'apoc.cypher.doIt', - documentation: - 'Runs a dynamically constructed statement with the given parameters. This procedure allows for both read and write statements.', - parameters: [ { - label: 'statement', - documentation: 'statement :: STRING', + isDeprecated: false, + description: '_2b :: BOOLEAN', + name: '_2b', + type: 'BOOLEAN', }, { - label: 'params', - documentation: 'params :: MAP', + isDeprecated: false, + description: '_3b :: BOOLEAN', + name: '_3b', + type: 'BOOLEAN', }, - ], - }, - 'apoc.cypher.run': { - label: 'apoc.cypher.run', - documentation: - 'Runs a dynamically constructed read-only statement with the given parameters.', - parameters: [ { - label: 'statement', - documentation: 'statement :: STRING', + isDeprecated: false, + description: '_4b :: BOOLEAN', + name: '_4b', + type: 'BOOLEAN', }, { - label: 'params', - documentation: 'params :: MAP', + isDeprecated: false, + description: '_5b :: BOOLEAN', + name: '_5b', + type: 'BOOLEAN', }, - ], - }, - 'apoc.cypher.runMany': { - label: 'apoc.cypher.runMany', - documentation: - 'Runs each semicolon separated statement and returns a summary of the statement outcomes.', - parameters: [ { - label: 'statement', - documentation: 'statement :: STRING', + isDeprecated: false, + description: '_6b :: BOOLEAN', + name: '_6b', + type: 'BOOLEAN', }, { - label: 'params', - documentation: 'params :: MAP', + isDeprecated: false, + description: '_7b :: BOOLEAN', + name: '_7b', + type: 'BOOLEAN', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: '_8b :: BOOLEAN', + name: '_8b', + type: 'BOOLEAN', }, - ], - }, - 'apoc.cypher.runManyReadOnly': { - label: 'apoc.cypher.runManyReadOnly', - documentation: - 'Runs each semicolon separated read-only statement and returns a summary of the statement outcomes.', - parameters: [ { - label: 'statement', - documentation: 'statement :: STRING', + isDeprecated: false, + description: '_9b :: BOOLEAN', + name: '_9b', + type: 'BOOLEAN', }, { - label: 'params', - documentation: 'params :: MAP', + isDeprecated: false, + description: '_10b :: BOOLEAN', + name: '_10b', + type: 'BOOLEAN', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: '_1l :: LIST', + name: '_1l', + type: 'LIST', }, - ], - }, - 'apoc.cypher.runSchema': { - label: 'apoc.cypher.runSchema', - documentation: - 'Runs the given query schema statement with the given parameters.', - parameters: [ { - label: 'statement', - documentation: 'statement :: STRING', + isDeprecated: false, + description: '_2l :: LIST', + name: '_2l', + type: 'LIST', }, { - label: 'params', - documentation: 'params :: MAP', + isDeprecated: false, + description: '_3l :: LIST', + name: '_3l', + type: 'LIST', }, - ], - }, - 'apoc.cypher.runTimeboxed': { - label: 'apoc.cypher.runTimeboxed', - documentation: - 'Terminates a Cypher statement if it has not finished before the set timeout (ms).', - parameters: [ { - label: 'statement', - documentation: 'statement :: STRING', + isDeprecated: false, + description: '_4l :: LIST', + name: '_4l', + type: 'LIST', }, { - label: 'params', - documentation: 'params :: MAP', + isDeprecated: false, + description: '_5l :: LIST', + name: '_5l', + type: 'LIST', }, { - label: 'timeout', - documentation: 'timeout :: INTEGER', + isDeprecated: false, + description: '_6l :: LIST', + name: '_6l', + type: 'LIST', }, - ], - }, - 'apoc.cypher.runWrite': { - label: 'apoc.cypher.runWrite', - documentation: 'Alias for `apoc.cypher.doIt`.', - parameters: [ { - label: 'statement', - documentation: 'statement :: STRING', + isDeprecated: false, + description: '_7l :: LIST', + name: '_7l', + type: 'LIST', }, { - label: 'params', - documentation: 'params :: MAP', + isDeprecated: false, + description: '_8l :: LIST', + name: '_8l', + type: 'LIST', }, - ], - }, - 'apoc.do.case': { - label: 'apoc.do.case', - documentation: - 'For each pair of conditional queries in the given `LIST`, this procedure will run the first query for which the conditional is evaluated to true.\nIf none of the conditionals are true, the `ELSE` query will run instead.', - parameters: [ { - label: 'conditionals', - documentation: 'conditionals :: LIST', + isDeprecated: false, + description: '_9l :: LIST', + name: '_9l', + type: 'LIST', }, { - label: 'elseQuery', - documentation: 'elseQuery = :: STRING', + isDeprecated: false, + description: '_10l :: LIST', + name: '_10l', + type: 'LIST', }, { - label: 'params', - documentation: 'params = {} :: MAP', + isDeprecated: false, + description: '_1m :: MAP', + name: '_1m', + type: 'MAP', }, - ], - }, - 'apoc.do.when': { - label: 'apoc.do.when', - documentation: - 'Runs the given read/write `ifQuery` if the conditional has evaluated to true, otherwise the `elseQuery` will run.', - parameters: [ { - label: 'condition', - documentation: 'condition :: BOOLEAN', + isDeprecated: false, + description: '_2m :: MAP', + name: '_2m', + type: 'MAP', }, { - label: 'ifQuery', - documentation: 'ifQuery :: STRING', + isDeprecated: false, + description: '_3m :: MAP', + name: '_3m', + type: 'MAP', }, { - label: 'elseQuery', - documentation: 'elseQuery = :: STRING', + isDeprecated: false, + description: '_4m :: MAP', + name: '_4m', + type: 'MAP', }, { - label: 'params', - documentation: 'params = {} :: MAP', + isDeprecated: false, + description: '_5m :: MAP', + name: '_5m', + type: 'MAP', }, - ], - }, - 'apoc.example.movies': { - label: 'apoc.example.movies', - documentation: 'Seeds the database with the Neo4j movie dataset.', - parameters: [], - }, - 'apoc.export.arrow.all': { - label: 'apoc.export.arrow.all', - documentation: 'Exports the full database as an arrow file.', - parameters: [ { - label: 'file', - documentation: 'file :: STRING', + isDeprecated: false, + description: '_6m :: MAP', + name: '_6m', + type: 'MAP', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: '_7m :: MAP', + name: '_7m', + type: 'MAP', }, - ], - }, - 'apoc.export.arrow.graph': { - label: 'apoc.export.arrow.graph', - documentation: 'Exports the given graph as an arrow file.', - parameters: [ { - label: 'file', - documentation: 'file :: STRING', + isDeprecated: false, + description: '_8m :: MAP', + name: '_8m', + type: 'MAP', }, { - label: 'graph', - documentation: 'graph :: ANY', + isDeprecated: false, + description: '_9m :: MAP', + name: '_9m', + type: 'MAP', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: '_10m :: MAP', + name: '_10m', + type: 'MAP', }, - ], - }, - 'apoc.export.arrow.query': { - label: 'apoc.export.arrow.query', - documentation: - 'Exports the results from the given Cypher query as an arrow file.', - parameters: [ { - label: 'file', - documentation: 'file :: STRING', + isDeprecated: false, + description: '_1n :: NODE', + name: '_1n', + type: 'NODE', }, { - label: 'query', - documentation: 'query :: STRING', + isDeprecated: false, + description: '_2n :: NODE', + name: '_2n', + type: 'NODE', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: '_3n :: NODE', + name: '_3n', + type: 'NODE', }, - ], - }, - 'apoc.export.arrow.stream.all': { - label: 'apoc.export.arrow.stream.all', - documentation: 'Exports the full database as an arrow byte array.', - parameters: [ { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: '_4n :: NODE', + name: '_4n', + type: 'NODE', }, - ], - }, - 'apoc.export.arrow.stream.graph': { - label: 'apoc.export.arrow.stream.graph', - documentation: 'Exports the given graph as an arrow byte array.', - parameters: [ { - label: 'graph', - documentation: 'graph :: ANY', + isDeprecated: false, + description: '_5n :: NODE', + name: '_5n', + type: 'NODE', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: '_6n :: NODE', + name: '_6n', + type: 'NODE', }, - ], - }, - 'apoc.export.arrow.stream.query': { - label: 'apoc.export.arrow.stream.query', - documentation: 'Exports the given Cypher query as an arrow byte array.', - parameters: [ { - label: 'query', - documentation: 'query :: STRING', + isDeprecated: false, + description: '_7n :: NODE', + name: '_7n', + type: 'NODE', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: '_8n :: NODE', + name: '_8n', + type: 'NODE', }, - ], - }, - 'apoc.export.csv.all': { - label: 'apoc.export.csv.all', - documentation: 'Exports the full database to the provided CSV file.', - parameters: [ { - label: 'file', - documentation: 'file :: STRING', + isDeprecated: false, + description: '_9n :: NODE', + name: '_9n', + type: 'NODE', }, { - label: 'config', - documentation: 'config :: MAP', + isDeprecated: false, + description: '_10n :: NODE', + name: '_10n', + type: 'NODE', }, - ], - }, - 'apoc.export.csv.data': { - label: 'apoc.export.csv.data', - documentation: - 'Exports the given `NODE` and `RELATIONSHIP` values to the provided CSV file.', - parameters: [ { - label: 'nodes', - documentation: 'nodes :: LIST', + isDeprecated: false, + description: '_1r :: RELATIONSHIP', + name: '_1r', + type: 'RELATIONSHIP', }, { - label: 'rels', - documentation: 'rels :: LIST', + isDeprecated: false, + description: '_2r :: RELATIONSHIP', + name: '_2r', + type: 'RELATIONSHIP', }, { - label: 'file', - documentation: 'file :: STRING', + isDeprecated: false, + description: '_3r :: RELATIONSHIP', + name: '_3r', + type: 'RELATIONSHIP', }, { - label: 'config', - documentation: 'config :: MAP', + isDeprecated: false, + description: '_4r :: RELATIONSHIP', + name: '_4r', + type: 'RELATIONSHIP', + }, + { + isDeprecated: false, + description: '_5r :: RELATIONSHIP', + name: '_5r', + type: 'RELATIONSHIP', + }, + { + isDeprecated: false, + description: '_6r :: RELATIONSHIP', + name: '_6r', + type: 'RELATIONSHIP', + }, + { + isDeprecated: false, + description: '_7r :: RELATIONSHIP', + name: '_7r', + type: 'RELATIONSHIP', + }, + { + isDeprecated: false, + description: '_8r :: RELATIONSHIP', + name: '_8r', + type: 'RELATIONSHIP', + }, + { + isDeprecated: false, + description: '_9r :: RELATIONSHIP', + name: '_9r', + type: 'RELATIONSHIP', + }, + { + isDeprecated: false, + description: '_10r :: RELATIONSHIP', + name: '_10r', + type: 'RELATIONSHIP', + }, + { + isDeprecated: false, + description: '_1p :: PATH', + name: '_1p', + type: 'PATH', + }, + { + isDeprecated: false, + description: '_2p :: PATH', + name: '_2p', + type: 'PATH', + }, + { + isDeprecated: false, + description: '_3p :: PATH', + name: '_3p', + type: 'PATH', + }, + { + isDeprecated: false, + description: '_4p :: PATH', + name: '_4p', + type: 'PATH', + }, + { + isDeprecated: false, + description: '_5p :: PATH', + name: '_5p', + type: 'PATH', + }, + { + isDeprecated: false, + description: '_6p :: PATH', + name: '_6p', + type: 'PATH', + }, + { + isDeprecated: false, + description: '_7p :: PATH', + name: '_7p', + type: 'PATH', }, - ], - }, - 'apoc.export.csv.graph': { - label: 'apoc.export.csv.graph', - documentation: 'Exports the given graph to the provided CSV file.', - parameters: [ { - label: 'graph', - documentation: 'graph :: MAP', + isDeprecated: false, + description: '_8p :: PATH', + name: '_8p', + type: 'PATH', }, { - label: 'file', - documentation: 'file :: STRING', + isDeprecated: false, + description: '_9p :: PATH', + name: '_9p', + type: 'PATH', }, { - label: 'config', - documentation: 'config :: MAP', + isDeprecated: false, + description: '_10p :: PATH', + name: '_10p', + type: 'PATH', + }, + { + isDeprecated: false, + description: 'elements :: INTEGER', + name: 'elements', + type: 'INTEGER', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.export.csv.query': { - label: 'apoc.export.csv.query', - documentation: - 'Exports the results from running the given Cypher query to the provided CSV file.', - parameters: [ + 'apoc.coll.pairWithOffset': { + name: 'apoc.coll.pairWithOffset', + description: 'Returns a `LIST` of pairs defined by the offset.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ { - label: 'query', - documentation: 'query :: STRING', + isDeprecated: false, + description: 'coll :: LIST', + name: 'coll', + type: 'LIST', }, { - label: 'file', - documentation: 'file :: STRING', + isDeprecated: false, + description: 'offset :: INTEGER', + name: 'offset', + type: 'INTEGER', }, + ], + signature: + 'apoc.coll.pairWithOffset(coll :: LIST, offset :: INTEGER) :: (value :: LIST)', + returnDescription: [ { - label: 'config', - documentation: 'config :: MAP', + isDeprecated: false, + description: 'value :: LIST', + name: 'value', + type: 'LIST', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.export.cypher.all': { - label: 'apoc.export.cypher.all', - documentation: - 'Exports the full database (incl. indexes) as Cypher statements to the provided file (default: Cypher Shell).', - parameters: [ + 'apoc.coll.partition': { + name: 'apoc.coll.partition', + description: + 'Partitions the original `LIST` into a new `LIST` of the given batch size.\nThe final `LIST` may be smaller than the given batch size.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ { - label: 'file', - documentation: 'file = :: STRING', + isDeprecated: false, + description: 'coll :: LIST', + name: 'coll', + type: 'LIST', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'batchSize :: INTEGER', + name: 'batchSize', + type: 'INTEGER', }, ], - }, - 'apoc.export.cypher.data': { - label: 'apoc.export.cypher.data', - documentation: - 'Exports the given `NODE` and `RELATIONSHIP` values (incl. indexes) as Cypher statements to the provided file (default: Cypher Shell).', - parameters: [ + signature: + 'apoc.coll.partition(coll :: LIST, batchSize :: INTEGER) :: (value :: LIST)', + returnDescription: [ { - label: 'nodes', - documentation: 'nodes :: LIST', + isDeprecated: false, + description: 'value :: LIST', + name: 'value', + type: 'LIST', }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.coll.split': { + name: 'apoc.coll.split', + description: + 'Splits a collection by the given value.\nThe value itself will not be part of the resulting `LIST` values.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ { - label: 'rels', - documentation: 'rels :: LIST', + isDeprecated: false, + description: 'coll :: LIST', + name: 'coll', + type: 'LIST', }, { - label: 'file', - documentation: 'file = :: STRING', + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', }, + ], + signature: + 'apoc.coll.split(coll :: LIST, value :: ANY) :: (value :: LIST)', + returnDescription: [ { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'value :: LIST', + name: 'value', + type: 'LIST', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.export.cypher.graph': { - label: 'apoc.export.cypher.graph', - documentation: - 'Exports the given graph (incl. indexes) as Cypher statements to the provided file (default: Cypher Shell).', - parameters: [ + 'apoc.coll.zipToRows': { + name: 'apoc.coll.zipToRows', + description: + 'Returns the two `LIST` values zipped together, with one row per zipped pair.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ { - label: 'graph', - documentation: 'graph :: MAP', + isDeprecated: false, + description: 'list1 :: LIST', + name: 'list1', + type: 'LIST', }, { - label: 'file', - documentation: 'file = :: STRING', + isDeprecated: false, + description: 'list2 :: LIST', + name: 'list2', + type: 'LIST', }, + ], + signature: + 'apoc.coll.zipToRows(list1 :: LIST, list2 :: LIST) :: (value :: LIST)', + returnDescription: [ { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'value :: LIST', + name: 'value', + type: 'LIST', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.export.cypher.query': { - label: 'apoc.export.cypher.query', - documentation: - 'Exports the `NODE` and `RELATIONSHIP` values from the given Cypher query (incl. indexes) as Cypher statements to the provided file (default: Cypher Shell).', - parameters: [ + 'apoc.convert.setJsonProperty': { + name: 'apoc.convert.setJsonProperty', + description: + 'Serializes the given JSON object and sets it as a property on the given `NODE`.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ { - label: 'statement', - documentation: 'statement :: STRING', + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', }, { - label: 'file', - documentation: 'file = :: STRING', + isDeprecated: false, + description: 'key :: STRING', + name: 'key', + type: 'STRING', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', }, ], + signature: + 'apoc.convert.setJsonProperty(node :: NODE, key :: STRING, value :: ANY)', + returnDescription: [], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.export.cypher.schema': { - label: 'apoc.export.cypher.schema', - documentation: - 'Exports all schema indexes and constraints to Cypher statements.', - parameters: [ + 'apoc.convert.toTree': { + name: 'apoc.convert.toTree', + description: + 'Returns a stream of `MAP` values, representing the given `PATH` values as a tree with at least one root.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'paths :: LIST', + name: 'paths', + type: 'LIST', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=true, type=BOOLEAN}', + description: 'lowerCaseRels = true :: BOOLEAN', + name: 'lowerCaseRels', + type: 'BOOLEAN', + }, { - label: 'file', - documentation: 'file = :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', }, + ], + signature: + 'apoc.convert.toTree(paths :: LIST, lowerCaseRels = true :: BOOLEAN, config = {} :: MAP) :: (value :: MAP)', + returnDescription: [ { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'value :: MAP', + name: 'value', + type: 'MAP', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.export.graphml.all': { - label: 'apoc.export.graphml.all', - documentation: 'Exports the full database to the provided GraphML file.', - parameters: [ + 'apoc.create.addLabels': { + name: 'apoc.create.addLabels', + description: 'Adds the given labels to the given `NODE` values.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'nodes :: ANY', + name: 'nodes', + type: 'ANY', + }, { - label: 'file', - documentation: 'file :: STRING', + isDeprecated: false, + description: 'labels :: LIST', + name: 'labels', + type: 'LIST', }, + ], + signature: + 'apoc.create.addLabels(nodes :: ANY, labels :: LIST) :: (node :: NODE)', + returnDescription: [ { - label: 'config', - documentation: 'config :: MAP', + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.export.graphml.data': { - label: 'apoc.export.graphml.data', - documentation: - 'Exports the given `NODE` and `RELATIONSHIP` values to the provided GraphML file.', - parameters: [ + 'apoc.create.clonePathToVirtual': { + name: 'apoc.create.clonePathToVirtual', + description: + 'Takes the given `PATH` and returns a virtual representation of it.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ { - label: 'nodes', - documentation: 'nodes :: LIST', + isDeprecated: false, + description: 'path :: PATH', + name: 'path', + type: 'PATH', }, + ], + signature: + 'apoc.create.clonePathToVirtual(path :: PATH) :: (path :: PATH)', + returnDescription: [ { - label: 'rels', - documentation: 'rels :: LIST', + isDeprecated: false, + description: 'path :: PATH', + name: 'path', + type: 'PATH', }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.create.clonePathsToVirtual': { + name: 'apoc.create.clonePathsToVirtual', + description: + 'Takes the given `LIST` and returns a virtual representation of them.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ { - label: 'file', - documentation: 'file :: STRING', + isDeprecated: false, + description: 'paths :: LIST', + name: 'paths', + type: 'LIST', }, + ], + signature: + 'apoc.create.clonePathsToVirtual(paths :: LIST) :: (path :: PATH)', + returnDescription: [ { - label: 'config', - documentation: 'config :: MAP', + isDeprecated: false, + description: 'path :: PATH', + name: 'path', + type: 'PATH', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.export.graphml.graph': { - label: 'apoc.export.graphml.graph', - documentation: 'Exports the given graph to the provided GraphML file.', - parameters: [ + 'apoc.create.node': { + name: 'apoc.create.node', + description: 'Creates a `NODE` with the given dynamic labels.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ { - label: 'graph', - documentation: 'graph :: MAP', + isDeprecated: false, + description: 'labels :: LIST', + name: 'labels', + type: 'LIST', }, { - label: 'file', - documentation: 'file :: STRING', + isDeprecated: false, + description: 'props :: MAP', + name: 'props', + type: 'MAP', }, + ], + signature: + 'apoc.create.node(labels :: LIST, props :: MAP) :: (node :: NODE)', + returnDescription: [ { - label: 'config', - documentation: 'config :: MAP', + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.export.graphml.query': { - label: 'apoc.export.graphml.query', - documentation: - 'Exports the given `NODE` and `RELATIONSHIP` values from the Cypher statement to the provided GraphML file.', - parameters: [ + 'apoc.create.nodes': { + name: 'apoc.create.nodes', + description: 'Creates `NODE` values with the given dynamic labels.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ { - label: 'statement', - documentation: 'statement :: STRING', + isDeprecated: false, + description: 'labels :: LIST', + name: 'labels', + type: 'LIST', }, { - label: 'file', - documentation: 'file :: STRING', + isDeprecated: false, + description: 'props :: LIST', + name: 'props', + type: 'LIST', }, + ], + signature: + 'apoc.create.nodes(labels :: LIST, props :: LIST) :: (node :: NODE)', + returnDescription: [ { - label: 'config', - documentation: 'config :: MAP', + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.export.json.all': { - label: 'apoc.export.json.all', - documentation: 'Exports the full database to the provided JSON file.', - parameters: [ + 'apoc.create.relationship': { + name: 'apoc.create.relationship', + description: + 'Creates a `RELATIONSHIP` with the given dynamic relationship type.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'from :: NODE', + name: 'from', + type: 'NODE', + }, + { + isDeprecated: false, + description: 'relType :: STRING', + name: 'relType', + type: 'STRING', + }, { - label: 'file', - documentation: 'file :: STRING', + isDeprecated: false, + description: 'props :: MAP', + name: 'props', + type: 'MAP', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'to :: NODE', + name: 'to', + type: 'NODE', }, ], - }, - 'apoc.export.json.data': { - label: 'apoc.export.json.data', - documentation: - 'Exports the given `NODE` and `RELATIONSHIP` values to the provided JSON file.', - parameters: [ + signature: + 'apoc.create.relationship(from :: NODE, relType :: STRING, props :: MAP, to :: NODE) :: (rel :: RELATIONSHIP)', + returnDescription: [ { - label: 'nodes', - documentation: 'nodes :: LIST', + isDeprecated: false, + description: 'rel :: RELATIONSHIP', + name: 'rel', + type: 'RELATIONSHIP', }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.create.removeLabels': { + name: 'apoc.create.removeLabels', + description: 'Removes the given labels from the given `NODE` values.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ { - label: 'rels', - documentation: 'rels :: LIST', + isDeprecated: false, + description: 'nodes :: ANY', + name: 'nodes', + type: 'ANY', }, { - label: 'file', - documentation: 'file :: STRING', + isDeprecated: false, + description: 'labels :: LIST', + name: 'labels', + type: 'LIST', }, + ], + signature: + 'apoc.create.removeLabels(nodes :: ANY, labels :: LIST) :: (node :: NODE)', + returnDescription: [ { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.export.json.graph': { - label: 'apoc.export.json.graph', - documentation: 'Exports the given graph to the provided JSON file.', - parameters: [ + 'apoc.create.removeProperties': { + name: 'apoc.create.removeProperties', + description: 'Removes the given properties from the given `NODE` values.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ { - label: 'graph', - documentation: 'graph :: MAP', + isDeprecated: false, + description: 'nodes :: ANY', + name: 'nodes', + type: 'ANY', }, { - label: 'file', - documentation: 'file :: STRING', + isDeprecated: false, + description: 'keys :: LIST', + name: 'keys', + type: 'LIST', }, + ], + signature: + 'apoc.create.removeProperties(nodes :: ANY, keys :: LIST) :: (node :: NODE)', + returnDescription: [ { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.export.json.query': { - label: 'apoc.export.json.query', - documentation: - 'Exports the results from the Cypher statement to the provided JSON file.', - parameters: [ + 'apoc.create.removeRelProperties': { + name: 'apoc.create.removeRelProperties', + description: + 'Removes the given properties from the given `RELATIONSHIP` values.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ { - label: 'statement', - documentation: 'statement :: STRING', + isDeprecated: false, + description: 'rels :: ANY', + name: 'rels', + type: 'ANY', }, { - label: 'file', - documentation: 'file :: STRING', + isDeprecated: false, + description: 'keys :: LIST', + name: 'keys', + type: 'LIST', }, + ], + signature: + 'apoc.create.removeRelProperties(rels :: ANY, keys :: LIST) :: (rel :: RELATIONSHIP)', + returnDescription: [ { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'rel :: RELATIONSHIP', + name: 'rel', + type: 'RELATIONSHIP', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.graph.from': { - label: 'apoc.graph.from', - documentation: - 'Generates a virtual sub-graph by extracting all of the `NODE` and `RELATIONSHIP` values from the given data.', - parameters: [ + 'apoc.create.setLabels': { + name: 'apoc.create.setLabels', + description: + 'Sets the given labels to the given `NODE` values. Non-matching labels are removed from the nodes.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ { - label: 'data', - documentation: 'data :: ANY', + isDeprecated: false, + description: 'nodes :: ANY', + name: 'nodes', + type: 'ANY', }, { - label: 'name', - documentation: 'name :: STRING', + isDeprecated: false, + description: 'labels :: LIST', + name: 'labels', + type: 'LIST', }, + ], + signature: + 'apoc.create.setLabels(nodes :: ANY, labels :: LIST) :: (node :: NODE)', + returnDescription: [ { - label: 'props', - documentation: 'props :: MAP', + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.graph.fromCypher': { - label: 'apoc.graph.fromCypher', - documentation: - 'Generates a virtual sub-graph by extracting all of the `NODE` and `RELATIONSHIP` values from the data returned by the given Cypher statement.', - parameters: [ + 'apoc.create.setProperties': { + name: 'apoc.create.setProperties', + description: 'Sets the given properties to the given `NODE` values.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ { - label: 'statement', - documentation: 'statement :: STRING', + isDeprecated: false, + description: 'nodes :: ANY', + name: 'nodes', + type: 'ANY', }, { - label: 'params', - documentation: 'params :: MAP', + isDeprecated: false, + description: 'keys :: LIST', + name: 'keys', + type: 'LIST', }, { - label: 'name', - documentation: 'name :: STRING', + isDeprecated: false, + description: 'values :: LIST', + name: 'values', + type: 'LIST', }, + ], + signature: + 'apoc.create.setProperties(nodes :: ANY, keys :: LIST, values :: LIST) :: (node :: NODE)', + returnDescription: [ { - label: 'props', - documentation: 'props :: MAP', + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.graph.fromDB': { - label: 'apoc.graph.fromDB', - documentation: - 'Generates a virtual sub-graph by extracting all of the `NODE` and `RELATIONSHIP` values from the data returned by the given database.', - parameters: [ + 'apoc.create.setProperty': { + name: 'apoc.create.setProperty', + description: 'Sets the given property to the given `NODE` values.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'nodes :: ANY', + name: 'nodes', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'key :: STRING', + name: 'key', + type: 'STRING', + }, { - label: 'name', - documentation: 'name :: STRING', + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', }, + ], + signature: + 'apoc.create.setProperty(nodes :: ANY, key :: STRING, value :: ANY) :: (node :: NODE)', + returnDescription: [ { - label: 'props', - documentation: 'props :: MAP', + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.graph.fromData': { - label: 'apoc.graph.fromData', - documentation: - 'Generates a virtual sub-graph by extracting all of the `NODE` and `RELATIONSHIP` values from the given data.', - parameters: [ + 'apoc.create.setRelProperties': { + name: 'apoc.create.setRelProperties', + description: 'Sets the given properties on the `RELATIONSHIP` values.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ { - label: 'nodes', - documentation: 'nodes :: LIST', + isDeprecated: false, + description: 'rels :: ANY', + name: 'rels', + type: 'ANY', }, { - label: 'rels', - documentation: 'rels :: LIST', + isDeprecated: false, + description: 'keys :: LIST', + name: 'keys', + type: 'LIST', }, { - label: 'name', - documentation: 'name :: STRING', + isDeprecated: false, + description: 'values :: LIST', + name: 'values', + type: 'LIST', }, + ], + signature: + 'apoc.create.setRelProperties(rels :: ANY, keys :: LIST, values :: LIST) :: (rel :: RELATIONSHIP)', + returnDescription: [ { - label: 'props', - documentation: 'props :: MAP', + isDeprecated: false, + description: 'rel :: RELATIONSHIP', + name: 'rel', + type: 'RELATIONSHIP', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.graph.fromDocument': { - label: 'apoc.graph.fromDocument', - documentation: - 'Generates a virtual sub-graph by extracting all of the `NODE` and `RELATIONSHIP` values from the data returned by the given JSON file.', - parameters: [ + 'apoc.create.setRelProperty': { + name: 'apoc.create.setRelProperty', + description: 'Sets the given property on the `RELATIONSHIP` values.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ { - label: 'json', - documentation: 'json :: ANY', + isDeprecated: false, + description: 'rels :: ANY', + name: 'rels', + type: 'ANY', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'key :: STRING', + name: 'key', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', + }, + ], + signature: + 'apoc.create.setRelProperty(rels :: ANY, key :: STRING, value :: ANY) :: (rel :: RELATIONSHIP)', + returnDescription: [ + { + isDeprecated: false, + description: 'rel :: RELATIONSHIP', + name: 'rel', + type: 'RELATIONSHIP', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.graph.fromPath': { - label: 'apoc.graph.fromPath', - documentation: - 'Generates a virtual sub-graph by extracting all of the `NODE` and `RELATIONSHIP` values from the data returned by the given `PATH`.', - parameters: [ + 'apoc.create.uuids': { + name: 'apoc.create.uuids', + description: 'Returns a stream of UUIDs.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ { - label: 'path', - documentation: 'path :: PATH', + isDeprecated: false, + description: 'count :: INTEGER', + name: 'count', + type: 'INTEGER', }, + ], + signature: + 'apoc.create.uuids(count :: INTEGER) :: (row :: INTEGER, uuid :: STRING)', + returnDescription: [ { - label: 'name', - documentation: 'name :: STRING', + isDeprecated: false, + description: 'row :: INTEGER', + name: 'row', + type: 'INTEGER', }, { - label: 'props', - documentation: 'props :: MAP', + isDeprecated: false, + description: 'uuid :: STRING', + name: 'uuid', + type: 'STRING', }, ], + admin: false, + option: { + deprecated: true, + }, }, - 'apoc.graph.fromPaths': { - label: 'apoc.graph.fromPaths', - documentation: - 'Generates a virtual sub-graph by extracting all of the `NODE` and `RELATIONSHIP` values from the data returned by the given `PATH` values.', - parameters: [ + 'apoc.create.vNode': { + name: 'apoc.create.vNode', + description: 'Returns a virtual `NODE`.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ { - label: 'paths', - documentation: 'paths :: LIST', + isDeprecated: false, + description: 'labels :: LIST', + name: 'labels', + type: 'LIST', }, { - label: 'name', - documentation: 'name :: STRING', + isDeprecated: false, + description: 'props :: MAP', + name: 'props', + type: 'MAP', }, + ], + signature: + 'apoc.create.vNode(labels :: LIST, props :: MAP) :: (node :: NODE)', + returnDescription: [ { - label: 'props', - documentation: 'props :: MAP', + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.graph.validateDocument': { - label: 'apoc.graph.validateDocument', - documentation: - 'Validates the JSON file and returns the result of the validation.', - parameters: [ + 'apoc.create.vNodes': { + name: 'apoc.create.vNodes', + description: 'Returns virtual `NODE` values.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ { - label: 'json', - documentation: 'json :: ANY', + isDeprecated: false, + description: 'labels :: LIST', + name: 'labels', + type: 'LIST', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'props :: LIST', + name: 'props', + type: 'LIST', }, ], - }, - 'apoc.help': { - label: 'apoc.help', - documentation: - 'Returns descriptions of the available APOC procedures and functions. If a keyword is provided, it will return only those procedures and functions that have the keyword in their name.', - parameters: [ + signature: + 'apoc.create.vNodes(labels :: LIST, props :: LIST) :: (node :: NODE)', + returnDescription: [ { - label: 'proc', - documentation: 'proc :: STRING', + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.import.csv': { - label: 'apoc.import.csv', - documentation: - 'Imports `NODE` and `RELATIONSHIP` values with the given labels and types from the provided CSV file.', - parameters: [ + 'apoc.create.vRelationship': { + name: 'apoc.create.vRelationship', + description: 'Returns a virtual `RELATIONSHIP`.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ { - label: 'nodes', - documentation: 'nodes :: LIST', + isDeprecated: false, + description: 'from :: NODE', + name: 'from', + type: 'NODE', }, { - label: 'rels', - documentation: 'rels :: LIST', + isDeprecated: false, + description: 'relType :: STRING', + name: 'relType', + type: 'STRING', }, { - label: 'config', - documentation: 'config :: MAP', + isDeprecated: false, + description: 'props :: MAP', + name: 'props', + type: 'MAP', }, - ], - }, - 'apoc.import.graphml': { - label: 'apoc.import.graphml', - documentation: 'Imports a graph from the provided GraphML file.', - parameters: [ { - label: 'urlOrBinaryFile', - documentation: 'urlOrBinaryFile :: ANY', + isDeprecated: false, + description: 'to :: NODE', + name: 'to', + type: 'NODE', }, + ], + signature: + 'apoc.create.vRelationship(from :: NODE, relType :: STRING, props :: MAP, to :: NODE) :: (rel :: RELATIONSHIP)', + returnDescription: [ { - label: 'config', - documentation: 'config :: MAP', + isDeprecated: false, + description: 'rel :: RELATIONSHIP', + name: 'rel', + type: 'RELATIONSHIP', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.import.json': { - label: 'apoc.import.json', - documentation: 'Imports a graph from the provided JSON file.', - parameters: [ + 'apoc.create.virtualPath': { + name: 'apoc.create.virtualPath', + description: 'Returns a virtual `PATH`.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ { - label: 'urlOrBinaryFile', - documentation: 'urlOrBinaryFile :: ANY', + isDeprecated: false, + description: 'labelsN :: LIST', + name: 'labelsN', + type: 'LIST', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'n :: MAP', + name: 'n', + type: 'MAP', }, - ], - }, - 'apoc.import.xml': { - label: 'apoc.import.xml', - documentation: 'Imports a graph from the provided XML file.', - parameters: [ { - label: 'urlOrBinary', - documentation: 'urlOrBinary :: ANY', + isDeprecated: false, + description: 'relType :: STRING', + name: 'relType', + type: 'STRING', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'props :: MAP', + name: 'props', + type: 'MAP', }, - ], - }, - 'apoc.load.arrow': { - label: 'apoc.load.arrow', - documentation: - 'Imports `NODE` and `RELATIONSHIP` values from the provided arrow file.', - parameters: [ { - label: 'file', - documentation: 'file :: STRING', + isDeprecated: false, + description: 'labelsM :: LIST', + name: 'labelsM', + type: 'LIST', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'm :: MAP', + name: 'm', + type: 'MAP', }, ], - }, - 'apoc.load.arrow.stream': { - label: 'apoc.load.arrow.stream', - documentation: - 'Imports `NODE` and `RELATIONSHIP` values from the provided arrow byte array.', - parameters: [ + signature: + 'apoc.create.virtualPath(labelsN :: LIST, n :: MAP, relType :: STRING, props :: MAP, labelsM :: LIST, m :: MAP) :: (from :: NODE, rel :: RELATIONSHIP, to :: NODE)', + returnDescription: [ + { + isDeprecated: false, + description: 'from :: NODE', + name: 'from', + type: 'NODE', + }, { - label: 'source', - documentation: 'source :: BYTEARRAY', + isDeprecated: false, + description: 'rel :: RELATIONSHIP', + name: 'rel', + type: 'RELATIONSHIP', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'to :: NODE', + name: 'to', + type: 'NODE', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.load.json': { - label: 'apoc.load.json', - documentation: - 'Imports JSON file as a stream of values if the given JSON file is a `LIST`.\nIf the given JSON file is a `MAP`, this procedure imports a single value instead.', - parameters: [ + 'apoc.cypher.doIt': { + name: 'apoc.cypher.doIt', + description: + 'Runs a dynamically constructed statement with the given parameters. This procedure allows for both read and write statements.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ { - label: 'urlOrKeyOrBinary', - documentation: 'urlOrKeyOrBinary :: ANY', + isDeprecated: false, + description: 'statement :: STRING', + name: 'statement', + type: 'STRING', }, { - label: 'path', - documentation: 'path = :: STRING', + isDeprecated: false, + description: 'params :: MAP', + name: 'params', + type: 'MAP', }, + ], + signature: + 'apoc.cypher.doIt(statement :: STRING, params :: MAP) :: (value :: MAP)', + returnDescription: [ { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'value :: MAP', + name: 'value', + type: 'MAP', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.load.jsonArray': { - label: 'apoc.load.jsonArray', - documentation: - 'Loads array from a JSON URL (e.g. web-API) to then import the given JSON file as a stream of values.', - parameters: [ + 'apoc.cypher.run': { + name: 'apoc.cypher.run', + description: + 'Runs a dynamically constructed read-only statement with the given parameters.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ { - label: 'url', - documentation: 'url :: STRING', + isDeprecated: false, + description: 'statement :: STRING', + name: 'statement', + type: 'STRING', }, { - label: 'path', - documentation: 'path = :: STRING', + isDeprecated: false, + description: 'params :: MAP', + name: 'params', + type: 'MAP', }, + ], + signature: + 'apoc.cypher.run(statement :: STRING, params :: MAP) :: (value :: MAP)', + returnDescription: [ { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'value :: MAP', + name: 'value', + type: 'MAP', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.load.jsonParams': { - label: 'apoc.load.jsonParams', - documentation: - 'Loads parameters from a JSON URL (e.g. web-API) as a stream of values if the given JSON file is a `LIST`.\nIf the given JSON file is a `MAP`, this procedure imports a single value instead.', - parameters: [ + 'apoc.cypher.runMany': { + name: 'apoc.cypher.runMany', + description: + 'Runs each semicolon separated statement and returns a summary of the statement outcomes.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ { - label: 'urlOrKeyOrBinary', - documentation: 'urlOrKeyOrBinary :: ANY', + isDeprecated: false, + description: 'statement :: STRING', + name: 'statement', + type: 'STRING', }, { - label: 'headers', - documentation: 'headers :: MAP', + isDeprecated: false, + description: 'params :: MAP', + name: 'params', + type: 'MAP', }, { - label: 'payload', - documentation: 'payload :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', }, + ], + signature: + 'apoc.cypher.runMany(statement :: STRING, params :: MAP, config = {} :: MAP) :: (row :: INTEGER, result :: MAP)', + returnDescription: [ { - label: 'path', - documentation: 'path = :: STRING', + isDeprecated: false, + description: 'row :: INTEGER', + name: 'row', + type: 'INTEGER', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'result :: MAP', + name: 'result', + type: 'MAP', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.load.xml': { - label: 'apoc.load.xml', - documentation: - 'Loads a single nested `MAP` from an XML URL (e.g. web-API).', - parameters: [ - { - label: 'urlOrBinary', - documentation: 'urlOrBinary :: ANY', - }, + 'apoc.cypher.runManyReadOnly': { + name: 'apoc.cypher.runManyReadOnly', + description: + 'Runs each semicolon separated read-only statement and returns a summary of the statement outcomes.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ { - label: 'path', - documentation: 'path = / :: STRING', + isDeprecated: false, + description: 'statement :: STRING', + name: 'statement', + type: 'STRING', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'params :: MAP', + name: 'params', + type: 'MAP', }, { - label: 'simple', - documentation: 'simple = false :: BOOLEAN', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', }, ], - }, - 'apoc.lock.all': { - label: 'apoc.lock.all', - documentation: - 'Acquires a write lock on the given `NODE` and `RELATIONSHIP` values.', - parameters: [ + signature: + 'apoc.cypher.runManyReadOnly(statement :: STRING, params :: MAP, config = {} :: MAP) :: (row :: INTEGER, result :: MAP)', + returnDescription: [ { - label: 'nodes', - documentation: 'nodes :: LIST', + isDeprecated: false, + description: 'row :: INTEGER', + name: 'row', + type: 'INTEGER', }, { - label: 'rels', - documentation: 'rels :: LIST', + isDeprecated: false, + description: 'result :: MAP', + name: 'result', + type: 'MAP', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.lock.nodes': { - label: 'apoc.lock.nodes', - documentation: 'Acquires a write lock on the given `NODE` values.', - parameters: [ + 'apoc.cypher.runSchema': { + name: 'apoc.cypher.runSchema', + description: + 'Runs the given query schema statement with the given parameters.', + mode: 'SCHEMA', + worksOnSystem: false, + argumentDescription: [ { - label: 'nodes', - documentation: 'nodes :: LIST', + isDeprecated: false, + description: 'statement :: STRING', + name: 'statement', + type: 'STRING', }, - ], - }, - 'apoc.lock.read.nodes': { - label: 'apoc.lock.read.nodes', - documentation: 'Acquires a read lock on the given `NODE` values.', - parameters: [ { - label: 'nodes', - documentation: 'nodes :: LIST', + isDeprecated: false, + description: 'params :: MAP', + name: 'params', + type: 'MAP', }, ], - }, - 'apoc.lock.read.rels': { - label: 'apoc.lock.read.rels', - documentation: 'Acquires a read lock on the given `RELATIONSHIP` values.', - parameters: [ + signature: + 'apoc.cypher.runSchema(statement :: STRING, params :: MAP) :: (value :: MAP)', + returnDescription: [ { - label: 'rels', - documentation: 'rels :: LIST', + isDeprecated: false, + description: 'value :: MAP', + name: 'value', + type: 'MAP', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.lock.rels': { - label: 'apoc.lock.rels', - documentation: - 'Acquires a write lock on the given `RELATIONSHIP` values.', - parameters: [ + 'apoc.cypher.runTimeboxed': { + name: 'apoc.cypher.runTimeboxed', + description: + 'Terminates a Cypher statement if it has not finished before the set timeout (ms).', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ { - label: 'rels', - documentation: 'rels :: LIST', + isDeprecated: false, + description: 'statement :: STRING', + name: 'statement', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'params :: MAP', + name: 'params', + type: 'MAP', }, - ], - }, - 'apoc.log.stream': { - label: 'apoc.log.stream', - documentation: - 'Returns the file contents from the given log, optionally returning only the last n lines.\nThis procedure requires users to have an admin role.', - parameters: [ { - label: 'path', - documentation: 'path :: STRING', + isDeprecated: false, + description: 'timeout :: INTEGER', + name: 'timeout', + type: 'INTEGER', }, + ], + signature: + 'apoc.cypher.runTimeboxed(statement :: STRING, params :: MAP, timeout :: INTEGER) :: (value :: MAP)', + returnDescription: [ { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'value :: MAP', + name: 'value', + type: 'MAP', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.math.regr': { - label: 'apoc.math.regr', - documentation: - 'Returns the coefficient of determination (R-squared) for the values of propertyY and propertyX in the given label.', - parameters: [ + 'apoc.cypher.runWrite': { + name: 'apoc.cypher.runWrite', + description: 'Alias for `apoc.cypher.doIt`.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ { - label: 'label', - documentation: 'label :: STRING', + isDeprecated: false, + description: 'statement :: STRING', + name: 'statement', + type: 'STRING', }, { - label: 'propertyY', - documentation: 'propertyY :: STRING', + isDeprecated: false, + description: 'params :: MAP', + name: 'params', + type: 'MAP', }, + ], + signature: + 'apoc.cypher.runWrite(statement :: STRING, params :: MAP) :: (value :: MAP)', + returnDescription: [ { - label: 'propertyX', - documentation: 'propertyX :: STRING', + isDeprecated: false, + description: 'value :: MAP', + name: 'value', + type: 'MAP', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.merge.node': { - label: 'apoc.merge.node', - documentation: - 'Merges the given `NODE` values with the given dynamic labels.', - parameters: [ + 'apoc.do.case': { + name: 'apoc.do.case', + description: + 'For each pair of conditional queries in the given `LIST`, this procedure will run the first query for which the conditional is evaluated to true.\nIf none of the conditionals are true, the `ELSE` query will run instead.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ { - label: 'labels', - documentation: 'labels :: LIST', + isDeprecated: false, + description: 'conditionals :: LIST', + name: 'conditionals', + type: 'LIST', }, { - label: 'identProps', - documentation: 'identProps :: MAP', + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'elseQuery = :: STRING', + name: 'elseQuery', + type: 'STRING', }, { - label: 'onCreateProps', - documentation: 'onCreateProps = {} :: MAP', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'params = {} :: MAP', + name: 'params', + type: 'MAP', }, + ], + signature: + 'apoc.do.case(conditionals :: LIST, elseQuery = :: STRING, params = {} :: MAP) :: (value :: MAP)', + returnDescription: [ { - label: 'onMatchProps', - documentation: 'onMatchProps = {} :: MAP', + isDeprecated: false, + description: 'value :: MAP', + name: 'value', + type: 'MAP', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.merge.node.eager': { - label: 'apoc.merge.node.eager', - documentation: - 'Merges the given `NODE` values with the given dynamic labels eagerly.', - parameters: [ + 'apoc.do.when': { + name: 'apoc.do.when', + description: + 'Runs the given read/write `ifQuery` if the conditional has evaluated to true, otherwise the `elseQuery` will run.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'condition :: BOOLEAN', + name: 'condition', + type: 'BOOLEAN', + }, { - label: 'labels', - documentation: 'labels :: LIST', + isDeprecated: false, + description: 'ifQuery :: STRING', + name: 'ifQuery', + type: 'STRING', }, { - label: 'identProps', - documentation: 'identProps :: MAP', + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'elseQuery = :: STRING', + name: 'elseQuery', + type: 'STRING', }, { - label: 'onCreateProps', - documentation: 'onCreateProps = {} :: MAP', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'params = {} :: MAP', + name: 'params', + type: 'MAP', }, + ], + signature: + 'apoc.do.when(condition :: BOOLEAN, ifQuery :: STRING, elseQuery = :: STRING, params = {} :: MAP) :: (value :: MAP)', + returnDescription: [ { - label: 'onMatchProps', - documentation: 'onMatchProps = {} :: MAP', + isDeprecated: false, + description: 'value :: MAP', + name: 'value', + type: 'MAP', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.merge.nodeWithStats': { - label: 'apoc.merge.nodeWithStats', - documentation: - 'Merges the given `NODE` values with the given dynamic labels. Provides queryStatistics in the result.', - parameters: [ + 'apoc.example.movies': { + name: 'apoc.example.movies', + description: 'Seeds the database with the Neo4j movie dataset.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [], + signature: + 'apoc.example.movies() :: (file :: STRING, source :: STRING, format :: STRING, nodes :: INTEGER, relationships :: INTEGER, properties :: INTEGER, time :: INTEGER, rows :: INTEGER, batchSize :: INTEGER, batches :: INTEGER, done :: BOOLEAN, data :: ANY)', + returnDescription: [ { - label: 'labels', - documentation: 'labels :: LIST', + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', }, { - label: 'identProps', - documentation: 'identProps :: MAP', + isDeprecated: false, + description: 'source :: STRING', + name: 'source', + type: 'STRING', }, { - label: 'onCreateProps', - documentation: 'onCreateProps = {} :: MAP', + isDeprecated: false, + description: 'format :: STRING', + name: 'format', + type: 'STRING', }, { - label: 'onMatchProps', - documentation: 'onMatchProps = {} :: MAP', + isDeprecated: false, + description: 'nodes :: INTEGER', + name: 'nodes', + type: 'INTEGER', }, - ], - }, - 'apoc.merge.nodeWithStats.eager': { - label: 'apoc.merge.nodeWithStats.eager', - documentation: - 'Merges the given `NODE` values with the given dynamic labels eagerly. Provides queryStatistics in the result.', - parameters: [ { - label: 'labels', - documentation: 'labels :: LIST', + isDeprecated: false, + description: 'relationships :: INTEGER', + name: 'relationships', + type: 'INTEGER', }, { - label: 'identProps', - documentation: 'identProps :: MAP', + isDeprecated: false, + description: 'properties :: INTEGER', + name: 'properties', + type: 'INTEGER', }, { - label: 'onCreateProps', - documentation: 'onCreateProps = {} :: MAP', + isDeprecated: false, + description: 'time :: INTEGER', + name: 'time', + type: 'INTEGER', }, { - label: 'onMatchProps', - documentation: 'onMatchProps = {} :: MAP', + isDeprecated: false, + description: 'rows :: INTEGER', + name: 'rows', + type: 'INTEGER', }, - ], - }, - 'apoc.merge.relationship': { - label: 'apoc.merge.relationship', - documentation: - 'Merges the given `RELATIONSHIP` values with the given dynamic types/properties.', - parameters: [ { - label: 'startNode', - documentation: 'startNode :: NODE', + isDeprecated: false, + description: 'batchSize :: INTEGER', + name: 'batchSize', + type: 'INTEGER', }, { - label: 'relType', - documentation: 'relType :: STRING', + isDeprecated: false, + description: 'batches :: INTEGER', + name: 'batches', + type: 'INTEGER', }, { - label: 'identProps', - documentation: 'identProps :: MAP', + isDeprecated: false, + description: 'done :: BOOLEAN', + name: 'done', + type: 'BOOLEAN', }, { - label: 'onCreateProps', - documentation: 'onCreateProps :: MAP', + isDeprecated: false, + description: 'data :: ANY', + name: 'data', + type: 'ANY', }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.export.arrow.all': { + name: 'apoc.export.arrow.all', + description: 'Exports the full database as an arrow file.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ { - label: 'endNode', - documentation: 'endNode :: NODE', + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', }, { - label: 'onMatchProps', - documentation: 'onMatchProps = {} :: MAP', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', }, ], - }, - 'apoc.merge.relationship.eager': { - label: 'apoc.merge.relationship.eager', - documentation: - 'Merges the given `RELATIONSHIP` values with the given dynamic types/properties eagerly.', - parameters: [ + signature: + 'apoc.export.arrow.all(file :: STRING, config = {} :: MAP) :: (file :: STRING, source :: STRING, format :: STRING, nodes :: INTEGER, relationships :: INTEGER, properties :: INTEGER, time :: INTEGER, rows :: INTEGER, batchSize :: INTEGER, batches :: INTEGER, done :: BOOLEAN, data :: ANY)', + returnDescription: [ { - label: 'startNode', - documentation: 'startNode :: NODE', + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', }, { - label: 'relType', - documentation: 'relType :: STRING', + isDeprecated: false, + description: 'source :: STRING', + name: 'source', + type: 'STRING', }, { - label: 'identProps', - documentation: 'identProps :: MAP', + isDeprecated: false, + description: 'format :: STRING', + name: 'format', + type: 'STRING', }, { - label: 'onCreateProps', - documentation: 'onCreateProps :: MAP', + isDeprecated: false, + description: 'nodes :: INTEGER', + name: 'nodes', + type: 'INTEGER', }, { - label: 'endNode', - documentation: 'endNode :: NODE', + isDeprecated: false, + description: 'relationships :: INTEGER', + name: 'relationships', + type: 'INTEGER', }, { - label: 'onMatchProps', - documentation: 'onMatchProps = {} :: MAP', + isDeprecated: false, + description: 'properties :: INTEGER', + name: 'properties', + type: 'INTEGER', }, - ], - }, - 'apoc.merge.relationshipWithStats': { - label: 'apoc.merge.relationshipWithStats', - documentation: - 'Merges the given `RELATIONSHIP` values with the given dynamic types/properties. Provides queryStatistics in the result.', - parameters: [ { - label: 'startNode', - documentation: 'startNode :: NODE', + isDeprecated: false, + description: 'time :: INTEGER', + name: 'time', + type: 'INTEGER', }, { - label: 'relType', - documentation: 'relType :: STRING', + isDeprecated: false, + description: 'rows :: INTEGER', + name: 'rows', + type: 'INTEGER', }, { - label: 'identProps', - documentation: 'identProps :: MAP', + isDeprecated: false, + description: 'batchSize :: INTEGER', + name: 'batchSize', + type: 'INTEGER', }, { - label: 'onCreateProps', - documentation: 'onCreateProps :: MAP', + isDeprecated: false, + description: 'batches :: INTEGER', + name: 'batches', + type: 'INTEGER', }, { - label: 'endNode', - documentation: 'endNode :: NODE', + isDeprecated: false, + description: 'done :: BOOLEAN', + name: 'done', + type: 'BOOLEAN', }, { - label: 'onMatchProps', - documentation: 'onMatchProps = {} :: MAP', + isDeprecated: false, + description: 'data :: ANY', + name: 'data', + type: 'ANY', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.merge.relationshipWithStats.eager': { - label: 'apoc.merge.relationshipWithStats.eager', - documentation: + 'apoc.export.arrow.graph': { + name: 'apoc.export.arrow.graph', + description: 'Exports the given graph as an arrow file.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'graph :: ANY', + name: 'graph', + type: 'ANY', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.export.arrow.graph(file :: STRING, graph :: ANY, config = {} :: MAP) :: (file :: STRING, source :: STRING, format :: STRING, nodes :: INTEGER, relationships :: INTEGER, properties :: INTEGER, time :: INTEGER, rows :: INTEGER, batchSize :: INTEGER, batches :: INTEGER, done :: BOOLEAN, data :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'source :: STRING', + name: 'source', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'format :: STRING', + name: 'format', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodes :: INTEGER', + name: 'nodes', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationships :: INTEGER', + name: 'relationships', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'properties :: INTEGER', + name: 'properties', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'time :: INTEGER', + name: 'time', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'rows :: INTEGER', + name: 'rows', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batchSize :: INTEGER', + name: 'batchSize', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batches :: INTEGER', + name: 'batches', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'done :: BOOLEAN', + name: 'done', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'data :: ANY', + name: 'data', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.export.arrow.query': { + name: 'apoc.export.arrow.query', + description: + 'Exports the results from the given Cypher query as an arrow file.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'query :: STRING', + name: 'query', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.export.arrow.query(file :: STRING, query :: STRING, config = {} :: MAP) :: (file :: STRING, source :: STRING, format :: STRING, nodes :: INTEGER, relationships :: INTEGER, properties :: INTEGER, time :: INTEGER, rows :: INTEGER, batchSize :: INTEGER, batches :: INTEGER, done :: BOOLEAN, data :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'source :: STRING', + name: 'source', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'format :: STRING', + name: 'format', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodes :: INTEGER', + name: 'nodes', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationships :: INTEGER', + name: 'relationships', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'properties :: INTEGER', + name: 'properties', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'time :: INTEGER', + name: 'time', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'rows :: INTEGER', + name: 'rows', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batchSize :: INTEGER', + name: 'batchSize', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batches :: INTEGER', + name: 'batches', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'done :: BOOLEAN', + name: 'done', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'data :: ANY', + name: 'data', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.export.arrow.stream.all': { + name: 'apoc.export.arrow.stream.all', + description: 'Exports the full database as an arrow byte array.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.export.arrow.stream.all(config = {} :: MAP) :: (value :: BYTEARRAY)', + returnDescription: [ + { + isDeprecated: false, + description: 'value :: BYTEARRAY', + name: 'value', + type: 'BYTEARRAY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.export.arrow.stream.graph': { + name: 'apoc.export.arrow.stream.graph', + description: 'Exports the given graph as an arrow byte array.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graph :: ANY', + name: 'graph', + type: 'ANY', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.export.arrow.stream.graph(graph :: ANY, config = {} :: MAP) :: (value :: BYTEARRAY)', + returnDescription: [ + { + isDeprecated: false, + description: 'value :: BYTEARRAY', + name: 'value', + type: 'BYTEARRAY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.export.arrow.stream.query': { + name: 'apoc.export.arrow.stream.query', + description: 'Exports the given Cypher query as an arrow byte array.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'query :: STRING', + name: 'query', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.export.arrow.stream.query(query :: STRING, config = {} :: MAP) :: (value :: BYTEARRAY)', + returnDescription: [ + { + isDeprecated: false, + description: 'value :: BYTEARRAY', + name: 'value', + type: 'BYTEARRAY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.export.csv.all': { + name: 'apoc.export.csv.all', + description: 'Exports the full database to the provided CSV file.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'config :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.export.csv.all(file :: STRING, config :: MAP) :: (file :: STRING, source :: STRING, format :: STRING, nodes :: INTEGER, relationships :: INTEGER, properties :: INTEGER, time :: INTEGER, rows :: INTEGER, batchSize :: INTEGER, batches :: INTEGER, done :: BOOLEAN, data :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'source :: STRING', + name: 'source', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'format :: STRING', + name: 'format', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodes :: INTEGER', + name: 'nodes', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationships :: INTEGER', + name: 'relationships', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'properties :: INTEGER', + name: 'properties', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'time :: INTEGER', + name: 'time', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'rows :: INTEGER', + name: 'rows', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batchSize :: INTEGER', + name: 'batchSize', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batches :: INTEGER', + name: 'batches', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'done :: BOOLEAN', + name: 'done', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'data :: ANY', + name: 'data', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.export.csv.data': { + name: 'apoc.export.csv.data', + description: + 'Exports the given `NODE` and `RELATIONSHIP` values to the provided CSV file.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'nodes :: LIST', + name: 'nodes', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'rels :: LIST', + name: 'rels', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'config :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.export.csv.data(nodes :: LIST, rels :: LIST, file :: STRING, config :: MAP) :: (file :: STRING, source :: STRING, format :: STRING, nodes :: INTEGER, relationships :: INTEGER, properties :: INTEGER, time :: INTEGER, rows :: INTEGER, batchSize :: INTEGER, batches :: INTEGER, done :: BOOLEAN, data :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'source :: STRING', + name: 'source', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'format :: STRING', + name: 'format', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodes :: INTEGER', + name: 'nodes', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationships :: INTEGER', + name: 'relationships', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'properties :: INTEGER', + name: 'properties', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'time :: INTEGER', + name: 'time', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'rows :: INTEGER', + name: 'rows', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batchSize :: INTEGER', + name: 'batchSize', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batches :: INTEGER', + name: 'batches', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'done :: BOOLEAN', + name: 'done', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'data :: ANY', + name: 'data', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.export.csv.graph': { + name: 'apoc.export.csv.graph', + description: 'Exports the given graph to the provided CSV file.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graph :: MAP', + name: 'graph', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'config :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.export.csv.graph(graph :: MAP, file :: STRING, config :: MAP) :: (file :: STRING, source :: STRING, format :: STRING, nodes :: INTEGER, relationships :: INTEGER, properties :: INTEGER, time :: INTEGER, rows :: INTEGER, batchSize :: INTEGER, batches :: INTEGER, done :: BOOLEAN, data :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'source :: STRING', + name: 'source', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'format :: STRING', + name: 'format', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodes :: INTEGER', + name: 'nodes', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationships :: INTEGER', + name: 'relationships', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'properties :: INTEGER', + name: 'properties', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'time :: INTEGER', + name: 'time', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'rows :: INTEGER', + name: 'rows', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batchSize :: INTEGER', + name: 'batchSize', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batches :: INTEGER', + name: 'batches', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'done :: BOOLEAN', + name: 'done', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'data :: ANY', + name: 'data', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.export.csv.query': { + name: 'apoc.export.csv.query', + description: + 'Exports the results from running the given Cypher query to the provided CSV file.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'query :: STRING', + name: 'query', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'config :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.export.csv.query(query :: STRING, file :: STRING, config :: MAP) :: (file :: STRING, source :: STRING, format :: STRING, nodes :: INTEGER, relationships :: INTEGER, properties :: INTEGER, time :: INTEGER, rows :: INTEGER, batchSize :: INTEGER, batches :: INTEGER, done :: BOOLEAN, data :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'source :: STRING', + name: 'source', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'format :: STRING', + name: 'format', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodes :: INTEGER', + name: 'nodes', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationships :: INTEGER', + name: 'relationships', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'properties :: INTEGER', + name: 'properties', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'time :: INTEGER', + name: 'time', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'rows :: INTEGER', + name: 'rows', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batchSize :: INTEGER', + name: 'batchSize', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batches :: INTEGER', + name: 'batches', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'done :: BOOLEAN', + name: 'done', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'data :: ANY', + name: 'data', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.export.cypher.all': { + name: 'apoc.export.cypher.all', + description: + 'Exports the full database (incl. indexes) as Cypher statements to the provided file (default: Cypher Shell).', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'file = :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.export.cypher.all(file = :: STRING, config = {} :: MAP) :: (file :: STRING, batches :: INTEGER, source :: STRING, format :: STRING, nodes :: INTEGER, relationships :: INTEGER, properties :: INTEGER, time :: INTEGER, rows :: INTEGER, batchSize :: INTEGER, cypherStatements :: ANY, nodeStatements :: ANY, relationshipStatements :: ANY, schemaStatements :: ANY, cleanupStatements :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'batches :: INTEGER', + name: 'batches', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'source :: STRING', + name: 'source', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'format :: STRING', + name: 'format', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodes :: INTEGER', + name: 'nodes', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationships :: INTEGER', + name: 'relationships', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'properties :: INTEGER', + name: 'properties', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'time :: INTEGER', + name: 'time', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'rows :: INTEGER', + name: 'rows', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batchSize :: INTEGER', + name: 'batchSize', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'cypherStatements :: ANY', + name: 'cypherStatements', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'nodeStatements :: ANY', + name: 'nodeStatements', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'relationshipStatements :: ANY', + name: 'relationshipStatements', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'schemaStatements :: ANY', + name: 'schemaStatements', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'cleanupStatements :: ANY', + name: 'cleanupStatements', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.export.cypher.data': { + name: 'apoc.export.cypher.data', + description: + 'Exports the given `NODE` and `RELATIONSHIP` values (incl. indexes) as Cypher statements to the provided file (default: Cypher Shell).', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'nodes :: LIST', + name: 'nodes', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'rels :: LIST', + name: 'rels', + type: 'LIST', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'file = :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.export.cypher.data(nodes :: LIST, rels :: LIST, file = :: STRING, config = {} :: MAP) :: (file :: STRING, batches :: INTEGER, source :: STRING, format :: STRING, nodes :: INTEGER, relationships :: INTEGER, properties :: INTEGER, time :: INTEGER, rows :: INTEGER, batchSize :: INTEGER, cypherStatements :: ANY, nodeStatements :: ANY, relationshipStatements :: ANY, schemaStatements :: ANY, cleanupStatements :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'batches :: INTEGER', + name: 'batches', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'source :: STRING', + name: 'source', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'format :: STRING', + name: 'format', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodes :: INTEGER', + name: 'nodes', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationships :: INTEGER', + name: 'relationships', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'properties :: INTEGER', + name: 'properties', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'time :: INTEGER', + name: 'time', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'rows :: INTEGER', + name: 'rows', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batchSize :: INTEGER', + name: 'batchSize', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'cypherStatements :: ANY', + name: 'cypherStatements', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'nodeStatements :: ANY', + name: 'nodeStatements', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'relationshipStatements :: ANY', + name: 'relationshipStatements', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'schemaStatements :: ANY', + name: 'schemaStatements', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'cleanupStatements :: ANY', + name: 'cleanupStatements', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.export.cypher.graph': { + name: 'apoc.export.cypher.graph', + description: + 'Exports the given graph (incl. indexes) as Cypher statements to the provided file (default: Cypher Shell).', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graph :: MAP', + name: 'graph', + type: 'MAP', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'file = :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.export.cypher.graph(graph :: MAP, file = :: STRING, config = {} :: MAP) :: (file :: STRING, batches :: INTEGER, source :: STRING, format :: STRING, nodes :: INTEGER, relationships :: INTEGER, properties :: INTEGER, time :: INTEGER, rows :: INTEGER, batchSize :: INTEGER, cypherStatements :: ANY, nodeStatements :: ANY, relationshipStatements :: ANY, schemaStatements :: ANY, cleanupStatements :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'batches :: INTEGER', + name: 'batches', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'source :: STRING', + name: 'source', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'format :: STRING', + name: 'format', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodes :: INTEGER', + name: 'nodes', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationships :: INTEGER', + name: 'relationships', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'properties :: INTEGER', + name: 'properties', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'time :: INTEGER', + name: 'time', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'rows :: INTEGER', + name: 'rows', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batchSize :: INTEGER', + name: 'batchSize', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'cypherStatements :: ANY', + name: 'cypherStatements', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'nodeStatements :: ANY', + name: 'nodeStatements', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'relationshipStatements :: ANY', + name: 'relationshipStatements', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'schemaStatements :: ANY', + name: 'schemaStatements', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'cleanupStatements :: ANY', + name: 'cleanupStatements', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.export.cypher.query': { + name: 'apoc.export.cypher.query', + description: + 'Exports the `NODE` and `RELATIONSHIP` values from the given Cypher query (incl. indexes) as Cypher statements to the provided file (default: Cypher Shell).', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'statement :: STRING', + name: 'statement', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'file = :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.export.cypher.query(statement :: STRING, file = :: STRING, config = {} :: MAP) :: (file :: STRING, batches :: INTEGER, source :: STRING, format :: STRING, nodes :: INTEGER, relationships :: INTEGER, properties :: INTEGER, time :: INTEGER, rows :: INTEGER, batchSize :: INTEGER, cypherStatements :: ANY, nodeStatements :: ANY, relationshipStatements :: ANY, schemaStatements :: ANY, cleanupStatements :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'batches :: INTEGER', + name: 'batches', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'source :: STRING', + name: 'source', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'format :: STRING', + name: 'format', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodes :: INTEGER', + name: 'nodes', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationships :: INTEGER', + name: 'relationships', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'properties :: INTEGER', + name: 'properties', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'time :: INTEGER', + name: 'time', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'rows :: INTEGER', + name: 'rows', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batchSize :: INTEGER', + name: 'batchSize', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'cypherStatements :: ANY', + name: 'cypherStatements', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'nodeStatements :: ANY', + name: 'nodeStatements', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'relationshipStatements :: ANY', + name: 'relationshipStatements', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'schemaStatements :: ANY', + name: 'schemaStatements', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'cleanupStatements :: ANY', + name: 'cleanupStatements', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.export.cypher.schema': { + name: 'apoc.export.cypher.schema', + description: + 'Exports all schema indexes and constraints to Cypher statements.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'file = :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.export.cypher.schema(file = :: STRING, config = {} :: MAP) :: (file :: STRING, batches :: INTEGER, source :: STRING, format :: STRING, nodes :: INTEGER, relationships :: INTEGER, properties :: INTEGER, time :: INTEGER, rows :: INTEGER, batchSize :: INTEGER, cypherStatements :: ANY, nodeStatements :: ANY, relationshipStatements :: ANY, schemaStatements :: ANY, cleanupStatements :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'batches :: INTEGER', + name: 'batches', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'source :: STRING', + name: 'source', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'format :: STRING', + name: 'format', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodes :: INTEGER', + name: 'nodes', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationships :: INTEGER', + name: 'relationships', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'properties :: INTEGER', + name: 'properties', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'time :: INTEGER', + name: 'time', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'rows :: INTEGER', + name: 'rows', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batchSize :: INTEGER', + name: 'batchSize', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'cypherStatements :: ANY', + name: 'cypherStatements', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'nodeStatements :: ANY', + name: 'nodeStatements', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'relationshipStatements :: ANY', + name: 'relationshipStatements', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'schemaStatements :: ANY', + name: 'schemaStatements', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'cleanupStatements :: ANY', + name: 'cleanupStatements', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.export.graphml.all': { + name: 'apoc.export.graphml.all', + description: 'Exports the full database to the provided GraphML file.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'config :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.export.graphml.all(file :: STRING, config :: MAP) :: (file :: STRING, source :: STRING, format :: STRING, nodes :: INTEGER, relationships :: INTEGER, properties :: INTEGER, time :: INTEGER, rows :: INTEGER, batchSize :: INTEGER, batches :: INTEGER, done :: BOOLEAN, data :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'source :: STRING', + name: 'source', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'format :: STRING', + name: 'format', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodes :: INTEGER', + name: 'nodes', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationships :: INTEGER', + name: 'relationships', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'properties :: INTEGER', + name: 'properties', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'time :: INTEGER', + name: 'time', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'rows :: INTEGER', + name: 'rows', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batchSize :: INTEGER', + name: 'batchSize', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batches :: INTEGER', + name: 'batches', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'done :: BOOLEAN', + name: 'done', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'data :: ANY', + name: 'data', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.export.graphml.data': { + name: 'apoc.export.graphml.data', + description: + 'Exports the given `NODE` and `RELATIONSHIP` values to the provided GraphML file.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'nodes :: LIST', + name: 'nodes', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'rels :: LIST', + name: 'rels', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'config :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.export.graphml.data(nodes :: LIST, rels :: LIST, file :: STRING, config :: MAP) :: (file :: STRING, source :: STRING, format :: STRING, nodes :: INTEGER, relationships :: INTEGER, properties :: INTEGER, time :: INTEGER, rows :: INTEGER, batchSize :: INTEGER, batches :: INTEGER, done :: BOOLEAN, data :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'source :: STRING', + name: 'source', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'format :: STRING', + name: 'format', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodes :: INTEGER', + name: 'nodes', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationships :: INTEGER', + name: 'relationships', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'properties :: INTEGER', + name: 'properties', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'time :: INTEGER', + name: 'time', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'rows :: INTEGER', + name: 'rows', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batchSize :: INTEGER', + name: 'batchSize', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batches :: INTEGER', + name: 'batches', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'done :: BOOLEAN', + name: 'done', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'data :: ANY', + name: 'data', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.export.graphml.graph': { + name: 'apoc.export.graphml.graph', + description: 'Exports the given graph to the provided GraphML file.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graph :: MAP', + name: 'graph', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'config :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.export.graphml.graph(graph :: MAP, file :: STRING, config :: MAP) :: (file :: STRING, source :: STRING, format :: STRING, nodes :: INTEGER, relationships :: INTEGER, properties :: INTEGER, time :: INTEGER, rows :: INTEGER, batchSize :: INTEGER, batches :: INTEGER, done :: BOOLEAN, data :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'source :: STRING', + name: 'source', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'format :: STRING', + name: 'format', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodes :: INTEGER', + name: 'nodes', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationships :: INTEGER', + name: 'relationships', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'properties :: INTEGER', + name: 'properties', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'time :: INTEGER', + name: 'time', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'rows :: INTEGER', + name: 'rows', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batchSize :: INTEGER', + name: 'batchSize', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batches :: INTEGER', + name: 'batches', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'done :: BOOLEAN', + name: 'done', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'data :: ANY', + name: 'data', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.export.graphml.query': { + name: 'apoc.export.graphml.query', + description: + 'Exports the given `NODE` and `RELATIONSHIP` values from the Cypher statement to the provided GraphML file.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'statement :: STRING', + name: 'statement', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'config :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.export.graphml.query(statement :: STRING, file :: STRING, config :: MAP) :: (file :: STRING, source :: STRING, format :: STRING, nodes :: INTEGER, relationships :: INTEGER, properties :: INTEGER, time :: INTEGER, rows :: INTEGER, batchSize :: INTEGER, batches :: INTEGER, done :: BOOLEAN, data :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'source :: STRING', + name: 'source', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'format :: STRING', + name: 'format', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodes :: INTEGER', + name: 'nodes', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationships :: INTEGER', + name: 'relationships', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'properties :: INTEGER', + name: 'properties', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'time :: INTEGER', + name: 'time', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'rows :: INTEGER', + name: 'rows', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batchSize :: INTEGER', + name: 'batchSize', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batches :: INTEGER', + name: 'batches', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'done :: BOOLEAN', + name: 'done', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'data :: ANY', + name: 'data', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.export.json.all': { + name: 'apoc.export.json.all', + description: 'Exports the full database to the provided JSON file.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.export.json.all(file :: STRING, config = {} :: MAP) :: (file :: STRING, source :: STRING, format :: STRING, nodes :: INTEGER, relationships :: INTEGER, properties :: INTEGER, time :: INTEGER, rows :: INTEGER, batchSize :: INTEGER, batches :: INTEGER, done :: BOOLEAN, data :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'source :: STRING', + name: 'source', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'format :: STRING', + name: 'format', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodes :: INTEGER', + name: 'nodes', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationships :: INTEGER', + name: 'relationships', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'properties :: INTEGER', + name: 'properties', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'time :: INTEGER', + name: 'time', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'rows :: INTEGER', + name: 'rows', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batchSize :: INTEGER', + name: 'batchSize', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batches :: INTEGER', + name: 'batches', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'done :: BOOLEAN', + name: 'done', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'data :: ANY', + name: 'data', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.export.json.data': { + name: 'apoc.export.json.data', + description: + 'Exports the given `NODE` and `RELATIONSHIP` values to the provided JSON file.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'nodes :: LIST', + name: 'nodes', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'rels :: LIST', + name: 'rels', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.export.json.data(nodes :: LIST, rels :: LIST, file :: STRING, config = {} :: MAP) :: (file :: STRING, source :: STRING, format :: STRING, nodes :: INTEGER, relationships :: INTEGER, properties :: INTEGER, time :: INTEGER, rows :: INTEGER, batchSize :: INTEGER, batches :: INTEGER, done :: BOOLEAN, data :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'source :: STRING', + name: 'source', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'format :: STRING', + name: 'format', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodes :: INTEGER', + name: 'nodes', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationships :: INTEGER', + name: 'relationships', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'properties :: INTEGER', + name: 'properties', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'time :: INTEGER', + name: 'time', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'rows :: INTEGER', + name: 'rows', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batchSize :: INTEGER', + name: 'batchSize', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batches :: INTEGER', + name: 'batches', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'done :: BOOLEAN', + name: 'done', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'data :: ANY', + name: 'data', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.export.json.graph': { + name: 'apoc.export.json.graph', + description: 'Exports the given graph to the provided JSON file.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graph :: MAP', + name: 'graph', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.export.json.graph(graph :: MAP, file :: STRING, config = {} :: MAP) :: (file :: STRING, source :: STRING, format :: STRING, nodes :: INTEGER, relationships :: INTEGER, properties :: INTEGER, time :: INTEGER, rows :: INTEGER, batchSize :: INTEGER, batches :: INTEGER, done :: BOOLEAN, data :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'source :: STRING', + name: 'source', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'format :: STRING', + name: 'format', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodes :: INTEGER', + name: 'nodes', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationships :: INTEGER', + name: 'relationships', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'properties :: INTEGER', + name: 'properties', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'time :: INTEGER', + name: 'time', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'rows :: INTEGER', + name: 'rows', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batchSize :: INTEGER', + name: 'batchSize', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batches :: INTEGER', + name: 'batches', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'done :: BOOLEAN', + name: 'done', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'data :: ANY', + name: 'data', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.export.json.query': { + name: 'apoc.export.json.query', + description: + 'Exports the results from the Cypher statement to the provided JSON file.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'statement :: STRING', + name: 'statement', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.export.json.query(statement :: STRING, file :: STRING, config = {} :: MAP) :: (file :: STRING, source :: STRING, format :: STRING, nodes :: INTEGER, relationships :: INTEGER, properties :: INTEGER, time :: INTEGER, rows :: INTEGER, batchSize :: INTEGER, batches :: INTEGER, done :: BOOLEAN, data :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'source :: STRING', + name: 'source', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'format :: STRING', + name: 'format', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodes :: INTEGER', + name: 'nodes', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationships :: INTEGER', + name: 'relationships', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'properties :: INTEGER', + name: 'properties', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'time :: INTEGER', + name: 'time', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'rows :: INTEGER', + name: 'rows', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batchSize :: INTEGER', + name: 'batchSize', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batches :: INTEGER', + name: 'batches', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'done :: BOOLEAN', + name: 'done', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'data :: ANY', + name: 'data', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.graph.from': { + name: 'apoc.graph.from', + description: + 'Generates a virtual sub-graph by extracting all of the `NODE` and `RELATIONSHIP` values from the given data.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'data :: ANY', + name: 'data', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'props :: MAP', + name: 'props', + type: 'MAP', + }, + ], + signature: + 'apoc.graph.from(data :: ANY, name :: STRING, props :: MAP) :: (graph :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'graph :: MAP', + name: 'graph', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.graph.fromCypher': { + name: 'apoc.graph.fromCypher', + description: + 'Generates a virtual sub-graph by extracting all of the `NODE` and `RELATIONSHIP` values from the data returned by the given Cypher statement.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'statement :: STRING', + name: 'statement', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'params :: MAP', + name: 'params', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'props :: MAP', + name: 'props', + type: 'MAP', + }, + ], + signature: + 'apoc.graph.fromCypher(statement :: STRING, params :: MAP, name :: STRING, props :: MAP) :: (graph :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'graph :: MAP', + name: 'graph', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.graph.fromDB': { + name: 'apoc.graph.fromDB', + description: + 'Generates a virtual sub-graph by extracting all of the `NODE` and `RELATIONSHIP` values from the data returned by the given database.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'props :: MAP', + name: 'props', + type: 'MAP', + }, + ], + signature: + 'apoc.graph.fromDB(name :: STRING, props :: MAP) :: (graph :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'graph :: MAP', + name: 'graph', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.graph.fromData': { + name: 'apoc.graph.fromData', + description: + 'Generates a virtual sub-graph by extracting all of the `NODE` and `RELATIONSHIP` values from the given data.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'nodes :: LIST', + name: 'nodes', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'rels :: LIST', + name: 'rels', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'props :: MAP', + name: 'props', + type: 'MAP', + }, + ], + signature: + 'apoc.graph.fromData(nodes :: LIST, rels :: LIST, name :: STRING, props :: MAP) :: (graph :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'graph :: MAP', + name: 'graph', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.graph.fromDocument': { + name: 'apoc.graph.fromDocument', + description: + 'Generates a virtual sub-graph by extracting all of the `NODE` and `RELATIONSHIP` values from the data returned by the given JSON file.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'json :: ANY', + name: 'json', + type: 'ANY', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.graph.fromDocument(json :: ANY, config = {} :: MAP) :: (graph :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'graph :: MAP', + name: 'graph', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.graph.fromPath': { + name: 'apoc.graph.fromPath', + description: + 'Generates a virtual sub-graph by extracting all of the `NODE` and `RELATIONSHIP` values from the data returned by the given `PATH`.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'path :: PATH', + name: 'path', + type: 'PATH', + }, + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'props :: MAP', + name: 'props', + type: 'MAP', + }, + ], + signature: + 'apoc.graph.fromPath(path :: PATH, name :: STRING, props :: MAP) :: (graph :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'graph :: MAP', + name: 'graph', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.graph.fromPaths': { + name: 'apoc.graph.fromPaths', + description: + 'Generates a virtual sub-graph by extracting all of the `NODE` and `RELATIONSHIP` values from the data returned by the given `PATH` values.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'paths :: LIST', + name: 'paths', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'props :: MAP', + name: 'props', + type: 'MAP', + }, + ], + signature: + 'apoc.graph.fromPaths(paths :: LIST, name :: STRING, props :: MAP) :: (graph :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'graph :: MAP', + name: 'graph', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.graph.validateDocument': { + name: 'apoc.graph.validateDocument', + description: + 'Validates the JSON file and returns the result of the validation.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'json :: ANY', + name: 'json', + type: 'ANY', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.graph.validateDocument(json :: ANY, config = {} :: MAP) :: (row :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'row :: MAP', + name: 'row', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.help': { + name: 'apoc.help', + description: + 'Returns descriptions of the available APOC procedures and functions. If a keyword is provided, it will return only those procedures and functions that have the keyword in their name.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'proc :: STRING', + name: 'proc', + type: 'STRING', + }, + ], + signature: + 'apoc.help(proc :: STRING) :: (type :: STRING, name :: STRING, text :: STRING, signature :: STRING, roles :: LIST, writes :: BOOLEAN, core :: BOOLEAN, isDeprecated :: BOOLEAN)', + returnDescription: [ + { + isDeprecated: false, + description: 'type :: STRING', + name: 'type', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'text :: STRING', + name: 'text', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'signature :: STRING', + name: 'signature', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'roles :: LIST', + name: 'roles', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'writes :: BOOLEAN', + name: 'writes', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'core :: BOOLEAN', + name: 'core', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'isDeprecated :: BOOLEAN', + name: 'isDeprecated', + type: 'BOOLEAN', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.import.csv': { + name: 'apoc.import.csv', + description: + 'Imports `NODE` and `RELATIONSHIP` values with the given labels and types from the provided CSV file.', + mode: 'SCHEMA', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'nodes :: LIST', + name: 'nodes', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'rels :: LIST', + name: 'rels', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'config :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.import.csv(nodes :: LIST, rels :: LIST, config :: MAP) :: (file :: STRING, source :: STRING, format :: STRING, nodes :: INTEGER, relationships :: INTEGER, properties :: INTEGER, time :: INTEGER, rows :: INTEGER, batchSize :: INTEGER, batches :: INTEGER, done :: BOOLEAN, data :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'source :: STRING', + name: 'source', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'format :: STRING', + name: 'format', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodes :: INTEGER', + name: 'nodes', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationships :: INTEGER', + name: 'relationships', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'properties :: INTEGER', + name: 'properties', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'time :: INTEGER', + name: 'time', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'rows :: INTEGER', + name: 'rows', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batchSize :: INTEGER', + name: 'batchSize', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batches :: INTEGER', + name: 'batches', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'done :: BOOLEAN', + name: 'done', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'data :: ANY', + name: 'data', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.import.graphml': { + name: 'apoc.import.graphml', + description: 'Imports a graph from the provided GraphML file.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'urlOrBinaryFile :: ANY', + name: 'urlOrBinaryFile', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'config :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.import.graphml(urlOrBinaryFile :: ANY, config :: MAP) :: (file :: STRING, source :: STRING, format :: STRING, nodes :: INTEGER, relationships :: INTEGER, properties :: INTEGER, time :: INTEGER, rows :: INTEGER, batchSize :: INTEGER, batches :: INTEGER, done :: BOOLEAN, data :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'source :: STRING', + name: 'source', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'format :: STRING', + name: 'format', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodes :: INTEGER', + name: 'nodes', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationships :: INTEGER', + name: 'relationships', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'properties :: INTEGER', + name: 'properties', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'time :: INTEGER', + name: 'time', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'rows :: INTEGER', + name: 'rows', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batchSize :: INTEGER', + name: 'batchSize', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batches :: INTEGER', + name: 'batches', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'done :: BOOLEAN', + name: 'done', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'data :: ANY', + name: 'data', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.import.json': { + name: 'apoc.import.json', + description: 'Imports a graph from the provided JSON file.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'urlOrBinaryFile :: ANY', + name: 'urlOrBinaryFile', + type: 'ANY', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.import.json(urlOrBinaryFile :: ANY, config = {} :: MAP) :: (file :: STRING, source :: STRING, format :: STRING, nodes :: INTEGER, relationships :: INTEGER, properties :: INTEGER, time :: INTEGER, rows :: INTEGER, batchSize :: INTEGER, batches :: INTEGER, done :: BOOLEAN, data :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'source :: STRING', + name: 'source', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'format :: STRING', + name: 'format', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodes :: INTEGER', + name: 'nodes', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationships :: INTEGER', + name: 'relationships', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'properties :: INTEGER', + name: 'properties', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'time :: INTEGER', + name: 'time', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'rows :: INTEGER', + name: 'rows', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batchSize :: INTEGER', + name: 'batchSize', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batches :: INTEGER', + name: 'batches', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'done :: BOOLEAN', + name: 'done', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'data :: ANY', + name: 'data', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.import.xml': { + name: 'apoc.import.xml', + description: 'Imports a graph from the provided XML file.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'urlOrBinary :: ANY', + name: 'urlOrBinary', + type: 'ANY', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.import.xml(urlOrBinary :: ANY, config = {} :: MAP) :: (node :: NODE)', + returnDescription: [ + { + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.load.arrow': { + name: 'apoc.load.arrow', + description: + 'Imports `NODE` and `RELATIONSHIP` values from the provided arrow file.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'file :: STRING', + name: 'file', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.load.arrow(file :: STRING, config = {} :: MAP) :: (value :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'value :: MAP', + name: 'value', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.load.arrow.stream': { + name: 'apoc.load.arrow.stream', + description: + 'Imports `NODE` and `RELATIONSHIP` values from the provided arrow byte array.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'source :: BYTEARRAY', + name: 'source', + type: 'BYTEARRAY', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.load.arrow.stream(source :: BYTEARRAY, config = {} :: MAP) :: (value :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'value :: MAP', + name: 'value', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.load.json': { + name: 'apoc.load.json', + description: + 'Imports JSON file as a stream of values if the given JSON file is a `LIST`.\nIf the given JSON file is a `MAP`, this procedure imports a single value instead.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'urlOrKeyOrBinary :: ANY', + name: 'urlOrKeyOrBinary', + type: 'ANY', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'path = :: STRING', + name: 'path', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.load.json(urlOrKeyOrBinary :: ANY, path = :: STRING, config = {} :: MAP) :: (value :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'value :: MAP', + name: 'value', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.load.jsonArray': { + name: 'apoc.load.jsonArray', + description: + 'Loads array from a JSON URL (e.g. web-API) to then import the given JSON file as a stream of values.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'url :: STRING', + name: 'url', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'path = :: STRING', + name: 'path', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.load.jsonArray(url :: STRING, path = :: STRING, config = {} :: MAP) :: (value :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.load.jsonParams': { + name: 'apoc.load.jsonParams', + description: + 'Loads parameters from a JSON URL (e.g. web-API) as a stream of values if the given JSON file is a `LIST`.\nIf the given JSON file is a `MAP`, this procedure imports a single value instead.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'urlOrKeyOrBinary :: ANY', + name: 'urlOrKeyOrBinary', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'headers :: MAP', + name: 'headers', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'payload :: STRING', + name: 'payload', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'path = :: STRING', + name: 'path', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.load.jsonParams(urlOrKeyOrBinary :: ANY, headers :: MAP, payload :: STRING, path = :: STRING, config = {} :: MAP) :: (value :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'value :: MAP', + name: 'value', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.load.xml': { + name: 'apoc.load.xml', + description: + 'Loads a single nested `MAP` from an XML URL (e.g. web-API).', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'urlOrBinary :: ANY', + name: 'urlOrBinary', + type: 'ANY', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=/, type=STRING}', + description: 'path = / :: STRING', + name: 'path', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=false, type=BOOLEAN}', + description: 'simple = false :: BOOLEAN', + name: 'simple', + type: 'BOOLEAN', + }, + ], + signature: + 'apoc.load.xml(urlOrBinary :: ANY, path = / :: STRING, config = {} :: MAP, simple = false :: BOOLEAN) :: (value :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'value :: MAP', + name: 'value', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.lock.all': { + name: 'apoc.lock.all', + description: + 'Acquires a write lock on the given `NODE` and `RELATIONSHIP` values.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'nodes :: LIST', + name: 'nodes', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'rels :: LIST', + name: 'rels', + type: 'LIST', + }, + ], + signature: + 'apoc.lock.all(nodes :: LIST, rels :: LIST)', + returnDescription: [], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.lock.nodes': { + name: 'apoc.lock.nodes', + description: 'Acquires a write lock on the given `NODE` values.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'nodes :: LIST', + name: 'nodes', + type: 'LIST', + }, + ], + signature: 'apoc.lock.nodes(nodes :: LIST)', + returnDescription: [], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.lock.read.nodes': { + name: 'apoc.lock.read.nodes', + description: 'Acquires a read lock on the given `NODE` values.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'nodes :: LIST', + name: 'nodes', + type: 'LIST', + }, + ], + signature: 'apoc.lock.read.nodes(nodes :: LIST)', + returnDescription: [], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.lock.read.rels': { + name: 'apoc.lock.read.rels', + description: 'Acquires a read lock on the given `RELATIONSHIP` values.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'rels :: LIST', + name: 'rels', + type: 'LIST', + }, + ], + signature: 'apoc.lock.read.rels(rels :: LIST)', + returnDescription: [], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.lock.rels': { + name: 'apoc.lock.rels', + description: 'Acquires a write lock on the given `RELATIONSHIP` values.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'rels :: LIST', + name: 'rels', + type: 'LIST', + }, + ], + signature: 'apoc.lock.rels(rels :: LIST)', + returnDescription: [], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.log.stream': { + name: 'apoc.log.stream', + description: + 'Returns the file contents from the given log, optionally returning only the last n lines.\nThis procedure requires users to have an admin role.', + mode: 'DBMS', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'path :: STRING', + name: 'path', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.log.stream(path :: STRING, config = {} :: MAP) :: (lineNo :: INTEGER, line :: STRING, path :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'lineNo :: INTEGER', + name: 'lineNo', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'line :: STRING', + name: 'line', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'path :: STRING', + name: 'path', + type: 'STRING', + }, + ], + admin: true, + option: { + deprecated: false, + }, + }, + 'apoc.math.regr': { + name: 'apoc.math.regr', + description: + 'Returns the coefficient of determination (R-squared) for the values of propertyY and propertyX in the given label.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'label :: STRING', + name: 'label', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'propertyY :: STRING', + name: 'propertyY', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'propertyX :: STRING', + name: 'propertyX', + type: 'STRING', + }, + ], + signature: + 'apoc.math.regr(label :: STRING, propertyY :: STRING, propertyX :: STRING) :: (r2 :: FLOAT, avgX :: FLOAT, avgY :: FLOAT, slope :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'r2 :: FLOAT', + name: 'r2', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'avgX :: FLOAT', + name: 'avgX', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'avgY :: FLOAT', + name: 'avgY', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'slope :: FLOAT', + name: 'slope', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.merge.node': { + name: 'apoc.merge.node', + description: + 'Merges the given `NODE` values with the given dynamic labels.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'labels :: LIST', + name: 'labels', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'identProps :: MAP', + name: 'identProps', + type: 'MAP', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'onCreateProps = {} :: MAP', + name: 'onCreateProps', + type: 'MAP', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'onMatchProps = {} :: MAP', + name: 'onMatchProps', + type: 'MAP', + }, + ], + signature: + 'apoc.merge.node(labels :: LIST, identProps :: MAP, onCreateProps = {} :: MAP, onMatchProps = {} :: MAP) :: (node :: NODE)', + returnDescription: [ + { + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.merge.node.eager': { + name: 'apoc.merge.node.eager', + description: + 'Merges the given `NODE` values with the given dynamic labels eagerly.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'labels :: LIST', + name: 'labels', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'identProps :: MAP', + name: 'identProps', + type: 'MAP', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'onCreateProps = {} :: MAP', + name: 'onCreateProps', + type: 'MAP', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'onMatchProps = {} :: MAP', + name: 'onMatchProps', + type: 'MAP', + }, + ], + signature: + 'apoc.merge.node.eager(labels :: LIST, identProps :: MAP, onCreateProps = {} :: MAP, onMatchProps = {} :: MAP) :: (node :: NODE)', + returnDescription: [ + { + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.merge.nodeWithStats': { + name: 'apoc.merge.nodeWithStats', + description: + 'Merges the given `NODE` values with the given dynamic labels. Provides queryStatistics in the result.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'labels :: LIST', + name: 'labels', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'identProps :: MAP', + name: 'identProps', + type: 'MAP', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'onCreateProps = {} :: MAP', + name: 'onCreateProps', + type: 'MAP', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'onMatchProps = {} :: MAP', + name: 'onMatchProps', + type: 'MAP', + }, + ], + signature: + 'apoc.merge.nodeWithStats(labels :: LIST, identProps :: MAP, onCreateProps = {} :: MAP, onMatchProps = {} :: MAP) :: (stats :: MAP, node :: NODE)', + returnDescription: [ + { + isDeprecated: false, + description: 'stats :: MAP', + name: 'stats', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.merge.nodeWithStats.eager': { + name: 'apoc.merge.nodeWithStats.eager', + description: + 'Merges the given `NODE` values with the given dynamic labels eagerly. Provides queryStatistics in the result.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'labels :: LIST', + name: 'labels', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'identProps :: MAP', + name: 'identProps', + type: 'MAP', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'onCreateProps = {} :: MAP', + name: 'onCreateProps', + type: 'MAP', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'onMatchProps = {} :: MAP', + name: 'onMatchProps', + type: 'MAP', + }, + ], + signature: + 'apoc.merge.nodeWithStats.eager(labels :: LIST, identProps :: MAP, onCreateProps = {} :: MAP, onMatchProps = {} :: MAP) :: (stats :: MAP, node :: NODE)', + returnDescription: [ + { + isDeprecated: false, + description: 'stats :: MAP', + name: 'stats', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.merge.relationship': { + name: 'apoc.merge.relationship', + description: + 'Merges the given `RELATIONSHIP` values with the given dynamic types/properties.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'startNode :: NODE', + name: 'startNode', + type: 'NODE', + }, + { + isDeprecated: false, + description: 'relType :: STRING', + name: 'relType', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'identProps :: MAP', + name: 'identProps', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'onCreateProps :: MAP', + name: 'onCreateProps', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'endNode :: NODE', + name: 'endNode', + type: 'NODE', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'onMatchProps = {} :: MAP', + name: 'onMatchProps', + type: 'MAP', + }, + ], + signature: + 'apoc.merge.relationship(startNode :: NODE, relType :: STRING, identProps :: MAP, onCreateProps :: MAP, endNode :: NODE, onMatchProps = {} :: MAP) :: (rel :: RELATIONSHIP)', + returnDescription: [ + { + isDeprecated: false, + description: 'rel :: RELATIONSHIP', + name: 'rel', + type: 'RELATIONSHIP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.merge.relationship.eager': { + name: 'apoc.merge.relationship.eager', + description: + 'Merges the given `RELATIONSHIP` values with the given dynamic types/properties eagerly.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'startNode :: NODE', + name: 'startNode', + type: 'NODE', + }, + { + isDeprecated: false, + description: 'relType :: STRING', + name: 'relType', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'identProps :: MAP', + name: 'identProps', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'onCreateProps :: MAP', + name: 'onCreateProps', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'endNode :: NODE', + name: 'endNode', + type: 'NODE', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'onMatchProps = {} :: MAP', + name: 'onMatchProps', + type: 'MAP', + }, + ], + signature: + 'apoc.merge.relationship.eager(startNode :: NODE, relType :: STRING, identProps :: MAP, onCreateProps :: MAP, endNode :: NODE, onMatchProps = {} :: MAP) :: (rel :: RELATIONSHIP)', + returnDescription: [ + { + isDeprecated: false, + description: 'rel :: RELATIONSHIP', + name: 'rel', + type: 'RELATIONSHIP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.merge.relationshipWithStats': { + name: 'apoc.merge.relationshipWithStats', + description: + 'Merges the given `RELATIONSHIP` values with the given dynamic types/properties. Provides queryStatistics in the result.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'startNode :: NODE', + name: 'startNode', + type: 'NODE', + }, + { + isDeprecated: false, + description: 'relType :: STRING', + name: 'relType', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'identProps :: MAP', + name: 'identProps', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'onCreateProps :: MAP', + name: 'onCreateProps', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'endNode :: NODE', + name: 'endNode', + type: 'NODE', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'onMatchProps = {} :: MAP', + name: 'onMatchProps', + type: 'MAP', + }, + ], + signature: + 'apoc.merge.relationshipWithStats(startNode :: NODE, relType :: STRING, identProps :: MAP, onCreateProps :: MAP, endNode :: NODE, onMatchProps = {} :: MAP) :: (stats :: MAP, rel :: RELATIONSHIP)', + returnDescription: [ + { + isDeprecated: false, + description: 'stats :: MAP', + name: 'stats', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'rel :: RELATIONSHIP', + name: 'rel', + type: 'RELATIONSHIP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.merge.relationshipWithStats.eager': { + name: 'apoc.merge.relationshipWithStats.eager', + description: 'Merges the given `RELATIONSHIP` values with the given dynamic types/properties eagerly. Provides queryStatistics in the result.', - parameters: [ + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'startNode :: NODE', + name: 'startNode', + type: 'NODE', + }, + { + isDeprecated: false, + description: 'relType :: STRING', + name: 'relType', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'identProps :: MAP', + name: 'identProps', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'onCreateProps :: MAP', + name: 'onCreateProps', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'endNode :: NODE', + name: 'endNode', + type: 'NODE', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'onMatchProps = {} :: MAP', + name: 'onMatchProps', + type: 'MAP', + }, + ], + signature: + 'apoc.merge.relationshipWithStats.eager(startNode :: NODE, relType :: STRING, identProps :: MAP, onCreateProps :: MAP, endNode :: NODE, onMatchProps = {} :: MAP) :: (stats :: MAP, rel :: RELATIONSHIP)', + returnDescription: [ + { + isDeprecated: false, + description: 'stats :: MAP', + name: 'stats', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'rel :: RELATIONSHIP', + name: 'rel', + type: 'RELATIONSHIP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.meta.data': { + name: 'apoc.meta.data', + description: 'Examines the full graph and returns a table of metadata.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.meta.data(config = {} :: MAP) :: (label :: STRING, property :: STRING, count :: INTEGER, unique :: BOOLEAN, index :: BOOLEAN, existence :: BOOLEAN, type :: STRING, array :: BOOLEAN, sample :: LIST, left :: INTEGER, right :: INTEGER, other :: LIST, otherLabels :: LIST, elementType :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'label :: STRING', + name: 'label', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'property :: STRING', + name: 'property', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'count :: INTEGER', + name: 'count', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'unique :: BOOLEAN', + name: 'unique', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'index :: BOOLEAN', + name: 'index', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'existence :: BOOLEAN', + name: 'existence', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'type :: STRING', + name: 'type', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'array :: BOOLEAN', + name: 'array', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'sample :: LIST', + name: 'sample', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'left :: INTEGER', + name: 'left', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'right :: INTEGER', + name: 'right', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'other :: LIST', + name: 'other', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'otherLabels :: LIST', + name: 'otherLabels', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'elementType :: STRING', + name: 'elementType', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.meta.data.of': { + name: 'apoc.meta.data.of', + description: + 'Examines the given sub-graph and returns a table of metadata.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graph :: ANY', + name: 'graph', + type: 'ANY', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.meta.data.of(graph :: ANY, config = {} :: MAP) :: (label :: STRING, property :: STRING, count :: INTEGER, unique :: BOOLEAN, index :: BOOLEAN, existence :: BOOLEAN, type :: STRING, array :: BOOLEAN, sample :: LIST, left :: INTEGER, right :: INTEGER, other :: LIST, otherLabels :: LIST, elementType :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'label :: STRING', + name: 'label', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'property :: STRING', + name: 'property', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'count :: INTEGER', + name: 'count', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'unique :: BOOLEAN', + name: 'unique', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'index :: BOOLEAN', + name: 'index', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'existence :: BOOLEAN', + name: 'existence', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'type :: STRING', + name: 'type', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'array :: BOOLEAN', + name: 'array', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'sample :: LIST', + name: 'sample', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'left :: INTEGER', + name: 'left', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'right :: INTEGER', + name: 'right', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'other :: LIST', + name: 'other', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'otherLabels :: LIST', + name: 'otherLabels', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'elementType :: STRING', + name: 'elementType', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.meta.graph': { + name: 'apoc.meta.graph', + description: 'Examines the full graph and returns a meta-graph.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.meta.graph(config = {} :: MAP) :: (nodes :: LIST, relationships :: LIST)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodes :: LIST', + name: 'nodes', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'relationships :: LIST', + name: 'relationships', + type: 'LIST', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.meta.graph.of': { + name: 'apoc.meta.graph.of', + description: 'Examines the given sub-graph and returns a meta-graph.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=ANY}', + description: 'graph = {} :: ANY', + name: 'graph', + type: 'ANY', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.meta.graph.of(graph = {} :: ANY, config = {} :: MAP) :: (nodes :: LIST, relationships :: LIST)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodes :: LIST', + name: 'nodes', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'relationships :: LIST', + name: 'relationships', + type: 'LIST', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.meta.graphSample': { + name: 'apoc.meta.graphSample', + description: + 'Examines the full graph and returns a meta-graph.\nUnlike `apoc.meta.graph`, this procedure does not filter away non-existing paths.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.meta.graphSample(config = {} :: MAP) :: (nodes :: LIST, relationships :: LIST)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodes :: LIST', + name: 'nodes', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'relationships :: LIST', + name: 'relationships', + type: 'LIST', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.meta.nodeTypeProperties': { + name: 'apoc.meta.nodeTypeProperties', + description: + 'Examines the full graph and returns a table of metadata with information about the `NODE` values therein.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.meta.nodeTypeProperties(config = {} :: MAP) :: (nodeType :: STRING, nodeLabels :: LIST, propertyName :: STRING, propertyTypes :: LIST, mandatory :: BOOLEAN, propertyObservations :: INTEGER, totalObservations :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeType :: STRING', + name: 'nodeType', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodeLabels :: LIST', + name: 'nodeLabels', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'propertyName :: STRING', + name: 'propertyName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'propertyTypes :: LIST', + name: 'propertyTypes', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'mandatory :: BOOLEAN', + name: 'mandatory', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'propertyObservations :: INTEGER', + name: 'propertyObservations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'totalObservations :: INTEGER', + name: 'totalObservations', + type: 'INTEGER', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.meta.relTypeProperties': { + name: 'apoc.meta.relTypeProperties', + description: + 'Examines the full graph and returns a table of metadata with information about the `RELATIONSHIP` values therein.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.meta.relTypeProperties(config = {} :: MAP) :: (relType :: STRING, sourceNodeLabels :: LIST, targetNodeLabels :: LIST, propertyName :: STRING, propertyTypes :: LIST, mandatory :: BOOLEAN, propertyObservations :: INTEGER, totalObservations :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'relType :: STRING', + name: 'relType', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'sourceNodeLabels :: LIST', + name: 'sourceNodeLabels', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'targetNodeLabels :: LIST', + name: 'targetNodeLabels', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'propertyName :: STRING', + name: 'propertyName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'propertyTypes :: LIST', + name: 'propertyTypes', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'mandatory :: BOOLEAN', + name: 'mandatory', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'propertyObservations :: INTEGER', + name: 'propertyObservations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'totalObservations :: INTEGER', + name: 'totalObservations', + type: 'INTEGER', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.meta.schema': { + name: 'apoc.meta.schema', + description: + 'Examines the given sub-graph and returns metadata as a `MAP`.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: 'apoc.meta.schema(config = {} :: MAP) :: (value :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'value :: MAP', + name: 'value', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.meta.stats': { + name: 'apoc.meta.stats', + description: + 'Returns the metadata stored in the transactional database statistics.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [], + signature: + 'apoc.meta.stats() :: (labelCount :: INTEGER, relTypeCount :: INTEGER, propertyKeyCount :: INTEGER, nodeCount :: INTEGER, relCount :: INTEGER, labels :: MAP, relTypes :: MAP, relTypesCount :: MAP, stats :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'labelCount :: INTEGER', + name: 'labelCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relTypeCount :: INTEGER', + name: 'relTypeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'propertyKeyCount :: INTEGER', + name: 'propertyKeyCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relCount :: INTEGER', + name: 'relCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'labels :: MAP', + name: 'labels', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'relTypes :: MAP', + name: 'relTypes', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'relTypesCount :: MAP', + name: 'relTypesCount', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'stats :: MAP', + name: 'stats', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.meta.subGraph': { + name: 'apoc.meta.subGraph', + description: 'Examines the given sub-graph and returns a meta-graph.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'config :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.meta.subGraph(config :: MAP) :: (nodes :: LIST, relationships :: LIST)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodes :: LIST', + name: 'nodes', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'relationships :: LIST', + name: 'relationships', + type: 'LIST', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.neighbors.athop': { + name: 'apoc.neighbors.athop', + description: + 'Returns all `NODE` values connected by the given `RELATIONSHIP` types at the specified distance.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'relTypes = :: STRING', + name: 'relTypes', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=1, type=INTEGER}', + description: 'distance = 1 :: INTEGER', + name: 'distance', + type: 'INTEGER', + }, + ], + signature: + 'apoc.neighbors.athop(node :: NODE, relTypes = :: STRING, distance = 1 :: INTEGER) :: (node :: NODE)', + returnDescription: [ + { + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.neighbors.athop.count': { + name: 'apoc.neighbors.athop.count', + description: + 'Returns the count of all `NODE` values connected by the given `RELATIONSHIP` types at the specified distance.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'relTypes = :: STRING', + name: 'relTypes', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=1, type=INTEGER}', + description: 'distance = 1 :: INTEGER', + name: 'distance', + type: 'INTEGER', + }, + ], + signature: + 'apoc.neighbors.athop.count(node :: NODE, relTypes = :: STRING, distance = 1 :: INTEGER) :: (value :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'value :: INTEGER', + name: 'value', + type: 'INTEGER', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.neighbors.byhop': { + name: 'apoc.neighbors.byhop', + description: + 'Returns all `NODE` values connected by the given `RELATIONSHIP` types within the specified distance. Returns `LIST` values, where each `PATH` of `NODE` values represents one row of the `LIST` values.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'relTypes = :: STRING', + name: 'relTypes', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=1, type=INTEGER}', + description: 'distance = 1 :: INTEGER', + name: 'distance', + type: 'INTEGER', + }, + ], + signature: + 'apoc.neighbors.byhop(node :: NODE, relTypes = :: STRING, distance = 1 :: INTEGER) :: (nodes :: LIST)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodes :: LIST', + name: 'nodes', + type: 'LIST', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.neighbors.byhop.count': { + name: 'apoc.neighbors.byhop.count', + description: + 'Returns the count of all `NODE` values connected by the given `RELATIONSHIP` types within the specified distance.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'relTypes = :: STRING', + name: 'relTypes', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=1, type=INTEGER}', + description: 'distance = 1 :: INTEGER', + name: 'distance', + type: 'INTEGER', + }, + ], + signature: + 'apoc.neighbors.byhop.count(node :: NODE, relTypes = :: STRING, distance = 1 :: INTEGER) :: (value :: LIST)', + returnDescription: [ + { + isDeprecated: false, + description: 'value :: LIST', + name: 'value', + type: 'LIST', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.neighbors.tohop': { + name: 'apoc.neighbors.tohop', + description: + 'Returns all `NODE` values connected by the given `RELATIONSHIP` types within the specified distance.\n`NODE` values are returned individually for each row.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'relTypes = :: STRING', + name: 'relTypes', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=1, type=INTEGER}', + description: 'distance = 1 :: INTEGER', + name: 'distance', + type: 'INTEGER', + }, + ], + signature: + 'apoc.neighbors.tohop(node :: NODE, relTypes = :: STRING, distance = 1 :: INTEGER) :: (node :: NODE)', + returnDescription: [ + { + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.neighbors.tohop.count': { + name: 'apoc.neighbors.tohop.count', + description: + 'Returns the count of all `NODE` values connected by the given `RELATIONSHIP` values in the pattern within the specified distance.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'relTypes = :: STRING', + name: 'relTypes', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=1, type=INTEGER}', + description: 'distance = 1 :: INTEGER', + name: 'distance', + type: 'INTEGER', + }, + ], + signature: + 'apoc.neighbors.tohop.count(node :: NODE, relTypes = :: STRING, distance = 1 :: INTEGER) :: (value :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'value :: INTEGER', + name: 'value', + type: 'INTEGER', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.nodes.collapse': { + name: 'apoc.nodes.collapse', + description: + 'Merges `NODE` values together in the given `LIST`.\nThe `NODE` values are then combined to become one `NODE`, with all labels of the previous `NODE` values attached to it, and all `RELATIONSHIP` values pointing to it.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'nodes :: LIST', + name: 'nodes', + type: 'LIST', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.nodes.collapse(nodes :: LIST, config = {} :: MAP) :: (from :: NODE, rel :: RELATIONSHIP, to :: NODE)', + returnDescription: [ + { + isDeprecated: false, + description: 'from :: NODE', + name: 'from', + type: 'NODE', + }, + { + isDeprecated: false, + description: 'rel :: RELATIONSHIP', + name: 'rel', + type: 'RELATIONSHIP', + }, + { + isDeprecated: false, + description: 'to :: NODE', + name: 'to', + type: 'NODE', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.nodes.cycles': { + name: 'apoc.nodes.cycles', + description: + 'Detects all `PATH` cycles in the given `LIST`.\nThis procedure can be limited on `RELATIONSHIP` values as well.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'nodes :: LIST', + name: 'nodes', + type: 'LIST', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.nodes.cycles(nodes :: LIST, config = {} :: MAP) :: (path :: PATH)', + returnDescription: [ + { + isDeprecated: false, + description: 'path :: PATH', + name: 'path', + type: 'PATH', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.nodes.delete': { + name: 'apoc.nodes.delete', + description: 'Deletes all `NODE` values with the given ids.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'nodes :: ANY', + name: 'nodes', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'batchSize :: INTEGER', + name: 'batchSize', + type: 'INTEGER', + }, + ], + signature: + 'apoc.nodes.delete(nodes :: ANY, batchSize :: INTEGER) :: (value :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'value :: INTEGER', + name: 'value', + type: 'INTEGER', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.nodes.get': { + name: 'apoc.nodes.get', + description: 'Returns all `NODE` values with the given ids.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'nodes :: ANY', + name: 'nodes', + type: 'ANY', + }, + ], + signature: 'apoc.nodes.get(nodes :: ANY) :: (node :: NODE)', + returnDescription: [ + { + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.nodes.group': { + name: 'apoc.nodes.group', + description: + 'Allows for the aggregation of `NODE` values based on the given properties.\nThis procedure returns virtual `NODE` values.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'labels :: LIST', + name: 'labels', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'groupByProperties :: LIST', + name: 'groupByProperties', + type: 'LIST', + }, + { + isDeprecated: false, + default: + 'DefaultParameterValue{value=[{*=count}, {*=count}], type=LIST}', + description: 'aggregations = [{*=count}, {*=count}] :: LIST', + name: 'aggregations', + type: 'LIST', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.nodes.group(labels :: LIST, groupByProperties :: LIST, aggregations = [{*=count}, {*=count}] :: LIST, config = {} :: MAP) :: (nodes :: LIST, relationships :: LIST, node :: NODE, relationship :: RELATIONSHIP)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodes :: LIST', + name: 'nodes', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'relationships :: LIST', + name: 'relationships', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', + }, + { + isDeprecated: false, + description: 'relationship :: RELATIONSHIP', + name: 'relationship', + type: 'RELATIONSHIP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.nodes.link': { + name: 'apoc.nodes.link', + description: + 'Creates a linked list of the given `NODE` values connected by the given `RELATIONSHIP` type.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'nodes :: LIST', + name: 'nodes', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'type :: STRING', + name: 'type', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.nodes.link(nodes :: LIST, type :: STRING, config = {} :: MAP)', + returnDescription: [], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.nodes.rels': { + name: 'apoc.nodes.rels', + description: 'Returns all `RELATIONSHIP` values with the given ids.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'rels :: ANY', + name: 'rels', + type: 'ANY', + }, + ], + signature: 'apoc.nodes.rels(rels :: ANY) :: (rel :: RELATIONSHIP)', + returnDescription: [ + { + isDeprecated: false, + description: 'rel :: RELATIONSHIP', + name: 'rel', + type: 'RELATIONSHIP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.path.expand': { + name: 'apoc.path.expand', + description: + 'Returns `PATH` values expanded from the start `NODE` following the given `RELATIONSHIP` types from min-depth to max-depth.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'startNode :: ANY', + name: 'startNode', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'relFilter :: STRING', + name: 'relFilter', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'labelFilter :: STRING', + name: 'labelFilter', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'minDepth :: INTEGER', + name: 'minDepth', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'maxDepth :: INTEGER', + name: 'maxDepth', + type: 'INTEGER', + }, + ], + signature: + 'apoc.path.expand(startNode :: ANY, relFilter :: STRING, labelFilter :: STRING, minDepth :: INTEGER, maxDepth :: INTEGER) :: (path :: PATH)', + returnDescription: [ + { + isDeprecated: false, + description: 'path :: PATH', + name: 'path', + type: 'PATH', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.path.expandConfig': { + name: 'apoc.path.expandConfig', + description: + 'Returns `PATH` values expanded from the start `NODE` with the given `RELATIONSHIP` types from min-depth to max-depth.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'startNode :: ANY', + name: 'startNode', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'config :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.path.expandConfig(startNode :: ANY, config :: MAP) :: (path :: PATH)', + returnDescription: [ + { + isDeprecated: false, + description: 'path :: PATH', + name: 'path', + type: 'PATH', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.path.spanningTree': { + name: 'apoc.path.spanningTree', + description: + 'Returns spanning tree `PATH` values expanded from the start `NODE` following the given `RELATIONSHIP` types to max-depth.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'startNode :: ANY', + name: 'startNode', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'config :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.path.spanningTree(startNode :: ANY, config :: MAP) :: (path :: PATH)', + returnDescription: [ + { + isDeprecated: false, + description: 'path :: PATH', + name: 'path', + type: 'PATH', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.path.subgraphAll': { + name: 'apoc.path.subgraphAll', + description: + 'Returns the sub-graph reachable from the start `NODE` following the given `RELATIONSHIP` types to max-depth.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'startNode :: ANY', + name: 'startNode', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'config :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.path.subgraphAll(startNode :: ANY, config :: MAP) :: (nodes :: LIST, relationships :: LIST)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodes :: LIST', + name: 'nodes', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'relationships :: LIST', + name: 'relationships', + type: 'LIST', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.path.subgraphNodes': { + name: 'apoc.path.subgraphNodes', + description: + 'Returns the `NODE` values in the sub-graph reachable from the start `NODE` following the given `RELATIONSHIP` types to max-depth.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'startNode :: ANY', + name: 'startNode', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'config :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.path.subgraphNodes(startNode :: ANY, config :: MAP) :: (node :: NODE)', + returnDescription: [ + { + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.periodic.cancel': { + name: 'apoc.periodic.cancel', + description: 'Cancels the given background job.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + ], + signature: + 'apoc.periodic.cancel(name :: STRING) :: (name :: STRING, delay :: INTEGER, rate :: INTEGER, done :: BOOLEAN, cancelled :: BOOLEAN)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'delay :: INTEGER', + name: 'delay', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'rate :: INTEGER', + name: 'rate', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'done :: BOOLEAN', + name: 'done', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'cancelled :: BOOLEAN', + name: 'cancelled', + type: 'BOOLEAN', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.periodic.commit': { + name: 'apoc.periodic.commit', + description: 'Runs the given statement in separate batched transactions.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'statement :: STRING', + name: 'statement', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'params = {} :: MAP', + name: 'params', + type: 'MAP', + }, + ], + signature: + 'apoc.periodic.commit(statement :: STRING, params = {} :: MAP) :: (updates :: INTEGER, executions :: INTEGER, runtime :: INTEGER, batches :: INTEGER, failedBatches :: INTEGER, batchErrors :: MAP, failedCommits :: INTEGER, commitErrors :: MAP, wasTerminated :: BOOLEAN)', + returnDescription: [ + { + isDeprecated: false, + description: 'updates :: INTEGER', + name: 'updates', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'executions :: INTEGER', + name: 'executions', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'runtime :: INTEGER', + name: 'runtime', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batches :: INTEGER', + name: 'batches', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'failedBatches :: INTEGER', + name: 'failedBatches', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'batchErrors :: MAP', + name: 'batchErrors', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'failedCommits :: INTEGER', + name: 'failedCommits', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'commitErrors :: MAP', + name: 'commitErrors', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'wasTerminated :: BOOLEAN', + name: 'wasTerminated', + type: 'BOOLEAN', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.periodic.countdown': { + name: 'apoc.periodic.countdown', + description: + 'Runs a repeatedly called background statement until it returns 0.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'statement :: STRING', + name: 'statement', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'delay :: INTEGER', + name: 'delay', + type: 'INTEGER', + }, + ], + signature: + 'apoc.periodic.countdown(name :: STRING, statement :: STRING, delay :: INTEGER) :: (name :: STRING, delay :: INTEGER, rate :: INTEGER, done :: BOOLEAN, cancelled :: BOOLEAN)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'delay :: INTEGER', + name: 'delay', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'rate :: INTEGER', + name: 'rate', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'done :: BOOLEAN', + name: 'done', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'cancelled :: BOOLEAN', + name: 'cancelled', + type: 'BOOLEAN', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.periodic.iterate': { + name: 'apoc.periodic.iterate', + description: + 'Runs the second statement for each item returned by the first statement.\nThis procedure returns the number of batches and the total number of processed rows.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'cypherIterate :: STRING', + name: 'cypherIterate', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'cypherAction :: STRING', + name: 'cypherAction', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'config :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.periodic.iterate(cypherIterate :: STRING, cypherAction :: STRING, config :: MAP) :: (batches :: INTEGER, total :: INTEGER, timeTaken :: INTEGER, committedOperations :: INTEGER, failedOperations :: INTEGER, failedBatches :: INTEGER, retries :: INTEGER, errorMessages :: MAP, batch :: MAP, operations :: MAP, wasTerminated :: BOOLEAN, failedParams :: MAP, updateStatistics :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'batches :: INTEGER', + name: 'batches', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'total :: INTEGER', + name: 'total', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'timeTaken :: INTEGER', + name: 'timeTaken', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'committedOperations :: INTEGER', + name: 'committedOperations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'failedOperations :: INTEGER', + name: 'failedOperations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'failedBatches :: INTEGER', + name: 'failedBatches', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'retries :: INTEGER', + name: 'retries', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'errorMessages :: MAP', + name: 'errorMessages', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'batch :: MAP', + name: 'batch', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'operations :: MAP', + name: 'operations', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'wasTerminated :: BOOLEAN', + name: 'wasTerminated', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'failedParams :: MAP', + name: 'failedParams', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'updateStatistics :: MAP', + name: 'updateStatistics', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.periodic.list': { + name: 'apoc.periodic.list', + description: 'Returns a `LIST` of all background jobs.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [], + signature: + 'apoc.periodic.list() :: (name :: STRING, delay :: INTEGER, rate :: INTEGER, done :: BOOLEAN, cancelled :: BOOLEAN)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'delay :: INTEGER', + name: 'delay', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'rate :: INTEGER', + name: 'rate', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'done :: BOOLEAN', + name: 'done', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'cancelled :: BOOLEAN', + name: 'cancelled', + type: 'BOOLEAN', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.periodic.repeat': { + name: 'apoc.periodic.repeat', + description: + 'Runs a repeatedly called background job.\nTo stop this procedure, use `apoc.periodic.cancel`.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'statement :: STRING', + name: 'statement', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'rate :: INTEGER', + name: 'rate', + type: 'INTEGER', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.periodic.repeat(name :: STRING, statement :: STRING, rate :: INTEGER, config = {} :: MAP) :: (name :: STRING, delay :: INTEGER, rate :: INTEGER, done :: BOOLEAN, cancelled :: BOOLEAN)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'delay :: INTEGER', + name: 'delay', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'rate :: INTEGER', + name: 'rate', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'done :: BOOLEAN', + name: 'done', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'cancelled :: BOOLEAN', + name: 'cancelled', + type: 'BOOLEAN', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.periodic.submit': { + name: 'apoc.periodic.submit', + description: + 'Creates a background job which runs the given Cypher statement once.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'statement :: STRING', + name: 'statement', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'params = {} :: MAP', + name: 'params', + type: 'MAP', + }, + ], + signature: + 'apoc.periodic.submit(name :: STRING, statement :: STRING, params = {} :: MAP) :: (name :: STRING, delay :: INTEGER, rate :: INTEGER, done :: BOOLEAN, cancelled :: BOOLEAN)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'delay :: INTEGER', + name: 'delay', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'rate :: INTEGER', + name: 'rate', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'done :: BOOLEAN', + name: 'done', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'cancelled :: BOOLEAN', + name: 'cancelled', + type: 'BOOLEAN', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.periodic.truncate': { + name: 'apoc.periodic.truncate', + description: + 'Removes all entities (and optionally indexes and constraints) from the database using the `apoc.periodic.iterate` procedure.', + mode: 'SCHEMA', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: 'apoc.periodic.truncate(config = {} :: MAP)', + returnDescription: [], + admin: true, + option: { + deprecated: false, + }, + }, + 'apoc.refactor.categorize': { + name: 'apoc.refactor.categorize', + description: + 'Creates new category `NODE` values from `NODE` values in the graph with the specified `sourceKey` as one of its property keys.\nThe new category `NODE` values are then connected to the original `NODE` values with a `RELATIONSHIP` of the given type.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'sourceKey :: STRING', + name: 'sourceKey', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'type :: STRING', + name: 'type', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'outgoing :: BOOLEAN', + name: 'outgoing', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'label :: STRING', + name: 'label', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'targetKey :: STRING', + name: 'targetKey', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'copiedKeys :: LIST', + name: 'copiedKeys', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'batchSize :: INTEGER', + name: 'batchSize', + type: 'INTEGER', + }, + ], + signature: + 'apoc.refactor.categorize(sourceKey :: STRING, type :: STRING, outgoing :: BOOLEAN, label :: STRING, targetKey :: STRING, copiedKeys :: LIST, batchSize :: INTEGER)', + returnDescription: [], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.refactor.cloneNodes': { + name: 'apoc.refactor.cloneNodes', + description: + 'Clones the given `NODE` values with their labels and properties.\nIt is possible to skip any `NODE` properties using skipProperties (note: this only skips properties on `NODE` values and not their `RELATIONSHIP` values).', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'nodes :: LIST', + name: 'nodes', + type: 'LIST', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=false, type=BOOLEAN}', + description: 'withRelationships = false :: BOOLEAN', + name: 'withRelationships', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=[], type=LIST}', + description: 'skipProperties = [] :: LIST', + name: 'skipProperties', + type: 'LIST', + }, + ], + signature: + 'apoc.refactor.cloneNodes(nodes :: LIST, withRelationships = false :: BOOLEAN, skipProperties = [] :: LIST) :: (input :: INTEGER, output :: NODE, error :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'input :: INTEGER', + name: 'input', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'output :: NODE', + name: 'output', + type: 'NODE', + }, + { + isDeprecated: false, + description: 'error :: STRING', + name: 'error', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.refactor.cloneSubgraph': { + name: 'apoc.refactor.cloneSubgraph', + description: + 'Clones the given `NODE` values with their labels and properties (optionally skipping any properties in the `skipProperties` `LIST` via the config `MAP`), and clones the given `RELATIONSHIP` values.\nIf no `RELATIONSHIP` values are provided, all existing `RELATIONSHIP` values between the given `NODE` values will be cloned.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'nodes :: LIST', + name: 'nodes', + type: 'LIST', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=[], type=LIST}', + description: 'rels = [] :: LIST', + name: 'rels', + type: 'LIST', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.refactor.cloneSubgraph(nodes :: LIST, rels = [] :: LIST, config = {} :: MAP) :: (input :: INTEGER, output :: NODE, error :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'input :: INTEGER', + name: 'input', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'output :: NODE', + name: 'output', + type: 'NODE', + }, + { + isDeprecated: false, + description: 'error :: STRING', + name: 'error', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.refactor.cloneSubgraphFromPaths': { + name: 'apoc.refactor.cloneSubgraphFromPaths', + description: + 'Clones a sub-graph defined by the given `LIST` values.\nIt is possible to skip any `NODE` properties using the `skipProperties` `LIST` via the config `MAP`.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'paths :: LIST', + name: 'paths', + type: 'LIST', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.refactor.cloneSubgraphFromPaths(paths :: LIST, config = {} :: MAP) :: (input :: INTEGER, output :: NODE, error :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'input :: INTEGER', + name: 'input', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'output :: NODE', + name: 'output', + type: 'NODE', + }, + { + isDeprecated: false, + description: 'error :: STRING', + name: 'error', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.refactor.collapseNode': { + name: 'apoc.refactor.collapseNode', + description: + 'Collapses the given `NODE` and replaces it with a `RELATIONSHIP` of the given type.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'nodes :: ANY', + name: 'nodes', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'relType :: STRING', + name: 'relType', + type: 'STRING', + }, + ], + signature: + 'apoc.refactor.collapseNode(nodes :: ANY, relType :: STRING) :: (input :: INTEGER, output :: RELATIONSHIP, error :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'input :: INTEGER', + name: 'input', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'output :: RELATIONSHIP', + name: 'output', + type: 'RELATIONSHIP', + }, + { + isDeprecated: false, + description: 'error :: STRING', + name: 'error', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.refactor.deleteAndReconnect': { + name: 'apoc.refactor.deleteAndReconnect', + description: + 'Removes the given `NODE` values from the `PATH` and reconnects the remaining `NODE` values.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'path :: PATH', + name: 'path', + type: 'PATH', + }, + { + isDeprecated: false, + description: 'nodes :: LIST', + name: 'nodes', + type: 'LIST', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.refactor.deleteAndReconnect(path :: PATH, nodes :: LIST, config = {} :: MAP) :: (nodes :: LIST, relationships :: LIST)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodes :: LIST', + name: 'nodes', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'relationships :: LIST', + name: 'relationships', + type: 'LIST', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.refactor.extractNode': { + name: 'apoc.refactor.extractNode', + description: + 'Expands the given `RELATIONSHIP` VALUES into intermediate `NODE` VALUES.\nThe intermediate `NODE` values are connected by the given `outType` and `inType`.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'rels :: ANY', + name: 'rels', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'labels :: LIST', + name: 'labels', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'outType :: STRING', + name: 'outType', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'inType :: STRING', + name: 'inType', + type: 'STRING', + }, + ], + signature: + 'apoc.refactor.extractNode(rels :: ANY, labels :: LIST, outType :: STRING, inType :: STRING) :: (input :: INTEGER, output :: NODE, error :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'input :: INTEGER', + name: 'input', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'output :: NODE', + name: 'output', + type: 'NODE', + }, + { + isDeprecated: false, + description: 'error :: STRING', + name: 'error', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.refactor.from': { + name: 'apoc.refactor.from', + description: + 'Redirects the given `RELATIONSHIP` to the given start `NODE`.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'rel :: RELATIONSHIP', + name: 'rel', + type: 'RELATIONSHIP', + }, + { + isDeprecated: false, + description: 'newNode :: NODE', + name: 'newNode', + type: 'NODE', + }, + ], + signature: + 'apoc.refactor.from(rel :: RELATIONSHIP, newNode :: NODE) :: (input :: INTEGER, output :: RELATIONSHIP, error :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'input :: INTEGER', + name: 'input', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'output :: RELATIONSHIP', + name: 'output', + type: 'RELATIONSHIP', + }, + { + isDeprecated: false, + description: 'error :: STRING', + name: 'error', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.refactor.invert': { + name: 'apoc.refactor.invert', + description: 'Inverts the direction of the given `RELATIONSHIP`.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'rel :: RELATIONSHIP', + name: 'rel', + type: 'RELATIONSHIP', + }, + ], + signature: + 'apoc.refactor.invert(rel :: RELATIONSHIP) :: (input :: INTEGER, output :: RELATIONSHIP, error :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'input :: INTEGER', + name: 'input', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'output :: RELATIONSHIP', + name: 'output', + type: 'RELATIONSHIP', + }, + { + isDeprecated: false, + description: 'error :: STRING', + name: 'error', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.refactor.mergeNodes': { + name: 'apoc.refactor.mergeNodes', + description: + 'Merges the given `LIST` onto the first `NODE` in the `LIST`.\nAll `RELATIONSHIP` values are merged onto that `NODE` as well.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'nodes :: LIST', + name: 'nodes', + type: 'LIST', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.refactor.mergeNodes(nodes :: LIST, config = {} :: MAP) :: (node :: NODE)', + returnDescription: [ + { + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.refactor.mergeRelationships': { + name: 'apoc.refactor.mergeRelationships', + description: + 'Merges the given `LIST` onto the first `RELATIONSHIP` in the `LIST`.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'rels :: LIST', + name: 'rels', + type: 'LIST', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.refactor.mergeRelationships(rels :: LIST, config = {} :: MAP) :: (rel :: RELATIONSHIP)', + returnDescription: [ + { + isDeprecated: false, + description: 'rel :: RELATIONSHIP', + name: 'rel', + type: 'RELATIONSHIP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.refactor.normalizeAsBoolean': { + name: 'apoc.refactor.normalizeAsBoolean', + description: 'Refactors the given property to a `BOOLEAN`.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'entity :: ANY', + name: 'entity', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'propertyKey :: STRING', + name: 'propertyKey', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'trueValues :: LIST', + name: 'trueValues', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'falseValues :: LIST', + name: 'falseValues', + type: 'LIST', + }, + ], + signature: + 'apoc.refactor.normalizeAsBoolean(entity :: ANY, propertyKey :: STRING, trueValues :: LIST, falseValues :: LIST)', + returnDescription: [], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.refactor.rename.label': { + name: 'apoc.refactor.rename.label', + description: + 'Renames the given label from `oldLabel` to `newLabel` for all `NODE` values.\nIf a `LIST` is provided, the renaming is applied to the `NODE` values within this `LIST` only.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'oldLabel :: STRING', + name: 'oldLabel', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'newLabel :: STRING', + name: 'newLabel', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=[], type=LIST}', + description: 'nodes = [] :: LIST', + name: 'nodes', + type: 'LIST', + }, + ], + signature: + 'apoc.refactor.rename.label(oldLabel :: STRING, newLabel :: STRING, nodes = [] :: LIST) :: (batches :: INTEGER, total :: INTEGER, timeTaken :: INTEGER, committedOperations :: INTEGER, failedOperations :: INTEGER, failedBatches :: INTEGER, retries :: INTEGER, errorMessages :: MAP, batch :: MAP, operations :: MAP, constraints :: LIST, indexes :: LIST)', + returnDescription: [ + { + isDeprecated: false, + description: 'batches :: INTEGER', + name: 'batches', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'total :: INTEGER', + name: 'total', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'timeTaken :: INTEGER', + name: 'timeTaken', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'committedOperations :: INTEGER', + name: 'committedOperations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'failedOperations :: INTEGER', + name: 'failedOperations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'failedBatches :: INTEGER', + name: 'failedBatches', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'retries :: INTEGER', + name: 'retries', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'errorMessages :: MAP', + name: 'errorMessages', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'batch :: MAP', + name: 'batch', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'operations :: MAP', + name: 'operations', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'constraints :: LIST', + name: 'constraints', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'indexes :: LIST', + name: 'indexes', + type: 'LIST', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.refactor.rename.nodeProperty': { + name: 'apoc.refactor.rename.nodeProperty', + description: + 'Renames the given property from `oldName` to `newName` for all `NODE` values.\nIf a `LIST` is provided, the renaming is applied to the `NODE` values within this `LIST` only.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'oldName :: STRING', + name: 'oldName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'newName :: STRING', + name: 'newName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=[], type=LIST}', + description: 'nodes = [] :: LIST', + name: 'nodes', + type: 'LIST', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.refactor.rename.nodeProperty(oldName :: STRING, newName :: STRING, nodes = [] :: LIST, config = {} :: MAP) :: (batches :: INTEGER, total :: INTEGER, timeTaken :: INTEGER, committedOperations :: INTEGER, failedOperations :: INTEGER, failedBatches :: INTEGER, retries :: INTEGER, errorMessages :: MAP, batch :: MAP, operations :: MAP, constraints :: LIST, indexes :: LIST)', + returnDescription: [ + { + isDeprecated: false, + description: 'batches :: INTEGER', + name: 'batches', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'total :: INTEGER', + name: 'total', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'timeTaken :: INTEGER', + name: 'timeTaken', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'committedOperations :: INTEGER', + name: 'committedOperations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'failedOperations :: INTEGER', + name: 'failedOperations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'failedBatches :: INTEGER', + name: 'failedBatches', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'retries :: INTEGER', + name: 'retries', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'errorMessages :: MAP', + name: 'errorMessages', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'batch :: MAP', + name: 'batch', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'operations :: MAP', + name: 'operations', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'constraints :: LIST', + name: 'constraints', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'indexes :: LIST', + name: 'indexes', + type: 'LIST', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.refactor.rename.type': { + name: 'apoc.refactor.rename.type', + description: + 'Renames all `RELATIONSHIP` values with type `oldType` to `newType`.\nIf a `LIST` is provided, the renaming is applied to the `RELATIONSHIP` values within this `LIST` only.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'oldType :: STRING', + name: 'oldType', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'newType :: STRING', + name: 'newType', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=[], type=LIST}', + description: 'rels = [] :: LIST', + name: 'rels', + type: 'LIST', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.refactor.rename.type(oldType :: STRING, newType :: STRING, rels = [] :: LIST, config = {} :: MAP) :: (batches :: INTEGER, total :: INTEGER, timeTaken :: INTEGER, committedOperations :: INTEGER, failedOperations :: INTEGER, failedBatches :: INTEGER, retries :: INTEGER, errorMessages :: MAP, batch :: MAP, operations :: MAP, constraints :: LIST, indexes :: LIST)', + returnDescription: [ + { + isDeprecated: false, + description: 'batches :: INTEGER', + name: 'batches', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'total :: INTEGER', + name: 'total', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'timeTaken :: INTEGER', + name: 'timeTaken', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'committedOperations :: INTEGER', + name: 'committedOperations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'failedOperations :: INTEGER', + name: 'failedOperations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'failedBatches :: INTEGER', + name: 'failedBatches', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'retries :: INTEGER', + name: 'retries', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'errorMessages :: MAP', + name: 'errorMessages', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'batch :: MAP', + name: 'batch', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'operations :: MAP', + name: 'operations', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'constraints :: LIST', + name: 'constraints', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'indexes :: LIST', + name: 'indexes', + type: 'LIST', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.refactor.rename.typeProperty': { + name: 'apoc.refactor.rename.typeProperty', + description: + 'Renames the given property from `oldName` to `newName` for all `RELATIONSHIP` values.\nIf a `LIST` is provided, the renaming is applied to the `RELATIONSHIP` values within this `LIST` only.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'oldName :: STRING', + name: 'oldName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'newName :: STRING', + name: 'newName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=[], type=LIST}', + description: 'rels = [] :: LIST', + name: 'rels', + type: 'LIST', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.refactor.rename.typeProperty(oldName :: STRING, newName :: STRING, rels = [] :: LIST, config = {} :: MAP) :: (batches :: INTEGER, total :: INTEGER, timeTaken :: INTEGER, committedOperations :: INTEGER, failedOperations :: INTEGER, failedBatches :: INTEGER, retries :: INTEGER, errorMessages :: MAP, batch :: MAP, operations :: MAP, constraints :: LIST, indexes :: LIST)', + returnDescription: [ + { + isDeprecated: false, + description: 'batches :: INTEGER', + name: 'batches', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'total :: INTEGER', + name: 'total', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'timeTaken :: INTEGER', + name: 'timeTaken', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'committedOperations :: INTEGER', + name: 'committedOperations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'failedOperations :: INTEGER', + name: 'failedOperations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'failedBatches :: INTEGER', + name: 'failedBatches', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'retries :: INTEGER', + name: 'retries', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'errorMessages :: MAP', + name: 'errorMessages', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'batch :: MAP', + name: 'batch', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'operations :: MAP', + name: 'operations', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'constraints :: LIST', + name: 'constraints', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'indexes :: LIST', + name: 'indexes', + type: 'LIST', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.refactor.setType': { + name: 'apoc.refactor.setType', + description: 'Changes the type of the given `RELATIONSHIP`.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'rel :: RELATIONSHIP', + name: 'rel', + type: 'RELATIONSHIP', + }, + { + isDeprecated: false, + description: 'newType :: STRING', + name: 'newType', + type: 'STRING', + }, + ], + signature: + 'apoc.refactor.setType(rel :: RELATIONSHIP, newType :: STRING) :: (input :: INTEGER, output :: RELATIONSHIP, error :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'input :: INTEGER', + name: 'input', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'output :: RELATIONSHIP', + name: 'output', + type: 'RELATIONSHIP', + }, + { + isDeprecated: false, + description: 'error :: STRING', + name: 'error', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.refactor.to': { + name: 'apoc.refactor.to', + description: + 'Redirects the given `RELATIONSHIP` to the given end `NODE`.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'rel :: RELATIONSHIP', + name: 'rel', + type: 'RELATIONSHIP', + }, + { + isDeprecated: false, + description: 'endNode :: NODE', + name: 'endNode', + type: 'NODE', + }, + ], + signature: + 'apoc.refactor.to(rel :: RELATIONSHIP, endNode :: NODE) :: (input :: INTEGER, output :: RELATIONSHIP, error :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'input :: INTEGER', + name: 'input', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'output :: RELATIONSHIP', + name: 'output', + type: 'RELATIONSHIP', + }, + { + isDeprecated: false, + description: 'error :: STRING', + name: 'error', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.schema.assert': { + name: 'apoc.schema.assert', + description: + 'Drops all other existing indexes and constraints when `dropExisting` is `true` (default is `true`).\nAsserts at the end of the operation that the given indexes and unique constraints are there.', + mode: 'SCHEMA', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'indexes :: MAP', + name: 'indexes', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'constraints :: MAP', + name: 'constraints', + type: 'MAP', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=true, type=BOOLEAN}', + description: 'dropExisting = true :: BOOLEAN', + name: 'dropExisting', + type: 'BOOLEAN', + }, + ], + signature: + 'apoc.schema.assert(indexes :: MAP, constraints :: MAP, dropExisting = true :: BOOLEAN) :: (label :: ANY, key :: STRING, keys :: LIST, unique :: BOOLEAN, action :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'label :: ANY', + name: 'label', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'key :: STRING', + name: 'key', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'keys :: LIST', + name: 'keys', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'unique :: BOOLEAN', + name: 'unique', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'action :: STRING', + name: 'action', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.schema.nodes': { + name: 'apoc.schema.nodes', + description: + 'Returns all indexes and constraints information for all `NODE` labels in the database.\nIt is possible to define a set of labels to include or exclude in the config parameters.', + mode: 'SCHEMA', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.schema.nodes(config = {} :: MAP) :: (name :: STRING, label :: ANY, properties :: LIST, status :: STRING, type :: STRING, failure :: STRING, populationProgress :: FLOAT, size :: INTEGER, valuesSelectivity :: FLOAT, userDescription :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'label :: ANY', + name: 'label', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'properties :: LIST', + name: 'properties', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'status :: STRING', + name: 'status', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'type :: STRING', + name: 'type', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'failure :: STRING', + name: 'failure', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'populationProgress :: FLOAT', + name: 'populationProgress', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'size :: INTEGER', + name: 'size', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'valuesSelectivity :: FLOAT', + name: 'valuesSelectivity', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'userDescription :: STRING', + name: 'userDescription', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.schema.properties.distinct': { + name: 'apoc.schema.properties.distinct', + description: + 'Returns all distinct `NODE` property values for the given key.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'label :: STRING', + name: 'label', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'key :: STRING', + name: 'key', + type: 'STRING', + }, + ], + signature: + 'apoc.schema.properties.distinct(label :: STRING, key :: STRING) :: (value :: LIST)', + returnDescription: [ + { + isDeprecated: false, + description: 'value :: LIST', + name: 'value', + type: 'LIST', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.schema.properties.distinctCount': { + name: 'apoc.schema.properties.distinctCount', + description: + 'Returns all distinct property values and counts for the given key.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'label = :: STRING', + name: 'label', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'key = :: STRING', + name: 'key', + type: 'STRING', + }, + ], + signature: + 'apoc.schema.properties.distinctCount(label = :: STRING, key = :: STRING) :: (label :: STRING, key :: STRING, value :: ANY, count :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'label :: STRING', + name: 'label', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'key :: STRING', + name: 'key', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'count :: INTEGER', + name: 'count', + type: 'INTEGER', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.schema.relationships': { + name: 'apoc.schema.relationships', + description: + 'Returns the indexes and constraints information for all the relationship types in the database.\nIt is possible to define a set of relationship types to include or exclude in the config parameters.', + mode: 'SCHEMA', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.schema.relationships(config = {} :: MAP) :: (name :: STRING, type :: STRING, properties :: LIST, status :: STRING, relationshipType :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'type :: STRING', + name: 'type', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'properties :: LIST', + name: 'properties', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'status :: STRING', + name: 'status', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'relationshipType :: ANY', + name: 'relationshipType', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.search.multiSearchReduced': { + name: 'apoc.search.multiSearchReduced', + description: + 'Returns a reduced representation of the `NODE` values found after a parallel search over multiple indexes.\nThe reduced `NODE` values representation includes: node id, node labels, and the searched properties.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'labelPropertyMap :: ANY', + name: 'labelPropertyMap', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'operator :: STRING', + name: 'operator', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'value :: STRING', + name: 'value', + type: 'STRING', + }, + ], + signature: + 'apoc.search.multiSearchReduced(labelPropertyMap :: ANY, operator :: STRING, value :: STRING) :: (id :: INTEGER, labels :: LIST, values :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'id :: INTEGER', + name: 'id', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'labels :: LIST', + name: 'labels', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'values :: MAP', + name: 'values', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.search.node': { + name: 'apoc.search.node', + description: + 'Returns all the distinct `NODE` values found after a parallel search over multiple indexes.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'labelPropertyMap :: ANY', + name: 'labelPropertyMap', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'operator :: STRING', + name: 'operator', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'value :: STRING', + name: 'value', + type: 'STRING', + }, + ], + signature: + 'apoc.search.node(labelPropertyMap :: ANY, operator :: STRING, value :: STRING) :: (node :: NODE)', + returnDescription: [ + { + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.search.nodeAll': { + name: 'apoc.search.nodeAll', + description: + 'Returns all the `NODE` values found after a parallel search over multiple indexes.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'labelPropertyMap :: ANY', + name: 'labelPropertyMap', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'operator :: STRING', + name: 'operator', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'value :: STRING', + name: 'value', + type: 'STRING', + }, + ], + signature: + 'apoc.search.nodeAll(labelPropertyMap :: ANY, operator :: STRING, value :: STRING) :: (node :: NODE)', + returnDescription: [ + { + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.search.nodeAllReduced': { + name: 'apoc.search.nodeAllReduced', + description: + 'Returns a reduced representation of the `NODE` values found after a parallel search over multiple indexes.\nThe reduced `NODE` values representation includes: node id, node labels, and the searched properties.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'labelPropertyMap :: ANY', + name: 'labelPropertyMap', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'operator :: STRING', + name: 'operator', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', + }, + ], + signature: + 'apoc.search.nodeAllReduced(labelPropertyMap :: ANY, operator :: STRING, value :: ANY) :: (id :: INTEGER, labels :: LIST, values :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'id :: INTEGER', + name: 'id', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'labels :: LIST', + name: 'labels', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'values :: MAP', + name: 'values', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.search.nodeReduced': { + name: 'apoc.search.nodeReduced', + description: + 'Returns a reduced representation of the distinct `NODE` values found after a parallel search over multiple indexes.\nThe reduced `NODE` values representation includes: node id, node labels, and the searched properties.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'labelPropertyMap :: ANY', + name: 'labelPropertyMap', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'operator :: STRING', + name: 'operator', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'value :: STRING', + name: 'value', + type: 'STRING', + }, + ], + signature: + 'apoc.search.nodeReduced(labelPropertyMap :: ANY, operator :: STRING, value :: STRING) :: (id :: INTEGER, labels :: LIST, values :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'id :: INTEGER', + name: 'id', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'labels :: LIST', + name: 'labels', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'values :: MAP', + name: 'values', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.spatial.geocode': { + name: 'apoc.spatial.geocode', + description: + 'Returns the geographic location (latitude, longitude, and description) of the given address using a geocoding service (default: OpenStreetMap).', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'location :: STRING', + name: 'location', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=100, type=INTEGER}', + description: 'maxResults = 100 :: INTEGER', + name: 'maxResults', + type: 'INTEGER', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=false, type=BOOLEAN}', + description: 'quotaException = false :: BOOLEAN', + name: 'quotaException', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.spatial.geocode(location :: STRING, maxResults = 100 :: INTEGER, quotaException = false :: BOOLEAN, config = {} :: MAP) :: (location :: MAP, data :: MAP, latitude :: FLOAT, longitude :: FLOAT, description :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'location :: MAP', + name: 'location', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'data :: MAP', + name: 'data', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'latitude :: FLOAT', + name: 'latitude', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'longitude :: FLOAT', + name: 'longitude', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'description :: STRING', + name: 'description', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.spatial.geocodeOnce': { + name: 'apoc.spatial.geocodeOnce', + description: + 'Returns the geographic location (latitude, longitude, and description) of the given address using a geocoding service (default: OpenStreetMap).\nThis procedure returns at most one result.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'location :: STRING', + name: 'location', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.spatial.geocodeOnce(location :: STRING, config = {} :: MAP) :: (location :: MAP, data :: MAP, latitude :: FLOAT, longitude :: FLOAT, description :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'location :: MAP', + name: 'location', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'data :: MAP', + name: 'data', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'latitude :: FLOAT', + name: 'latitude', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'longitude :: FLOAT', + name: 'longitude', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'description :: STRING', + name: 'description', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.spatial.reverseGeocode': { + name: 'apoc.spatial.reverseGeocode', + description: + 'Returns a textual address from the given geographic location (latitude, longitude) using a geocoding service (default: OpenStreetMap).\nThis procedure returns at most one result.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'latitude :: FLOAT', + name: 'latitude', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'longitude :: FLOAT', + name: 'longitude', + type: 'FLOAT', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=false, type=BOOLEAN}', + description: 'quotaException = false :: BOOLEAN', + name: 'quotaException', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.spatial.reverseGeocode(latitude :: FLOAT, longitude :: FLOAT, quotaException = false :: BOOLEAN, config = {} :: MAP) :: (location :: MAP, data :: MAP, latitude :: FLOAT, longitude :: FLOAT, description :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'location :: MAP', + name: 'location', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'data :: MAP', + name: 'data', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'latitude :: FLOAT', + name: 'latitude', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'longitude :: FLOAT', + name: 'longitude', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'description :: STRING', + name: 'description', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.spatial.sortByDistance': { + name: 'apoc.spatial.sortByDistance', + description: + 'Sorts the given collection of `PATH` values by the sum of their distance based on the latitude/longitude values in the `NODE` values.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'paths :: LIST', + name: 'paths', + type: 'LIST', + }, + ], + signature: + 'apoc.spatial.sortByDistance(paths :: LIST) :: (path :: PATH, distance :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'path :: PATH', + name: 'path', + type: 'PATH', + }, + { + isDeprecated: false, + description: 'distance :: FLOAT', + name: 'distance', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.stats.degrees': { + name: 'apoc.stats.degrees', + description: + 'Returns the percentile groupings of the degrees on the `NODE` values connected by the given `RELATIONSHIP` types.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'relTypes = :: STRING', + name: 'relTypes', + type: 'STRING', + }, + ], + signature: + 'apoc.stats.degrees(relTypes = :: STRING) :: (type :: STRING, direction :: STRING, total :: INTEGER, p50 :: INTEGER, p75 :: INTEGER, p90 :: INTEGER, p95 :: INTEGER, p99 :: INTEGER, p999 :: INTEGER, max :: INTEGER, min :: INTEGER, mean :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'type :: STRING', + name: 'type', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'direction :: STRING', + name: 'direction', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'total :: INTEGER', + name: 'total', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'p50 :: INTEGER', + name: 'p50', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'p75 :: INTEGER', + name: 'p75', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'p90 :: INTEGER', + name: 'p90', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'p95 :: INTEGER', + name: 'p95', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'p99 :: INTEGER', + name: 'p99', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'p999 :: INTEGER', + name: 'p999', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'max :: INTEGER', + name: 'max', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'min :: INTEGER', + name: 'min', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'mean :: FLOAT', + name: 'mean', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.text.phoneticDelta': { + name: 'apoc.text.phoneticDelta', + description: + 'Returns the US_ENGLISH soundex character difference between the two given `STRING` values.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'text1 :: STRING', + name: 'text1', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'text2 :: STRING', + name: 'text2', + type: 'STRING', + }, + ], + signature: + 'apoc.text.phoneticDelta(text1 :: STRING, text2 :: STRING) :: (phonetic1 :: STRING, phonetic2 :: STRING, delta :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'phonetic1 :: STRING', + name: 'phonetic1', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'phonetic2 :: STRING', + name: 'phonetic2', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'delta :: INTEGER', + name: 'delta', + type: 'INTEGER', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.trigger.add': { + name: 'apoc.trigger.add', + description: + "Adds a trigger to the given Cypher statement.\nThe selector for this procedure is {phase:'before/after/rollback/afterAsync'}.", + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'statement :: STRING', + name: 'statement', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'selector :: MAP', + name: 'selector', + type: 'MAP', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.trigger.add(name :: STRING, statement :: STRING, selector :: MAP, config = {} :: MAP) :: (name :: STRING, query :: STRING, selector :: MAP, params :: MAP, installed :: BOOLEAN, paused :: BOOLEAN)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'query :: STRING', + name: 'query', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'selector :: MAP', + name: 'selector', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'params :: MAP', + name: 'params', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'installed :: BOOLEAN', + name: 'installed', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'paused :: BOOLEAN', + name: 'paused', + type: 'BOOLEAN', + }, + ], + admin: true, + option: { + deprecated: true, + }, + }, + 'apoc.trigger.drop': { + name: 'apoc.trigger.drop', + description: 'Eventually removes the given trigger.', + mode: 'WRITE', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + description: 'databaseName :: STRING', + name: 'databaseName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + ], + signature: + 'apoc.trigger.drop(databaseName :: STRING, name :: STRING) :: (name :: STRING, query :: STRING, selector :: MAP, params :: MAP, installed :: BOOLEAN, paused :: BOOLEAN)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'query :: STRING', + name: 'query', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'selector :: MAP', + name: 'selector', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'params :: MAP', + name: 'params', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'installed :: BOOLEAN', + name: 'installed', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'paused :: BOOLEAN', + name: 'paused', + type: 'BOOLEAN', + }, + ], + admin: true, + option: { + deprecated: false, + }, + }, + 'apoc.trigger.dropAll': { + name: 'apoc.trigger.dropAll', + description: 'Eventually removes all triggers from the given database.', + mode: 'WRITE', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + description: 'databaseName :: STRING', + name: 'databaseName', + type: 'STRING', + }, + ], + signature: + 'apoc.trigger.dropAll(databaseName :: STRING) :: (name :: STRING, query :: STRING, selector :: MAP, params :: MAP, installed :: BOOLEAN, paused :: BOOLEAN)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'query :: STRING', + name: 'query', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'selector :: MAP', + name: 'selector', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'params :: MAP', + name: 'params', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'installed :: BOOLEAN', + name: 'installed', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'paused :: BOOLEAN', + name: 'paused', + type: 'BOOLEAN', + }, + ], + admin: true, + option: { + deprecated: false, + }, + }, + 'apoc.trigger.install': { + name: 'apoc.trigger.install', + description: + 'Eventually adds a trigger for a given database which is invoked when a successful transaction occurs.', + mode: 'WRITE', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + description: 'databaseName :: STRING', + name: 'databaseName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'statement :: STRING', + name: 'statement', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'selector :: MAP', + name: 'selector', + type: 'MAP', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'apoc.trigger.install(databaseName :: STRING, name :: STRING, statement :: STRING, selector :: MAP, config = {} :: MAP) :: (name :: STRING, query :: STRING, selector :: MAP, params :: MAP, installed :: BOOLEAN, paused :: BOOLEAN)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'query :: STRING', + name: 'query', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'selector :: MAP', + name: 'selector', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'params :: MAP', + name: 'params', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'installed :: BOOLEAN', + name: 'installed', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'paused :: BOOLEAN', + name: 'paused', + type: 'BOOLEAN', + }, + ], + admin: true, + option: { + deprecated: false, + }, + }, + 'apoc.trigger.list': { + name: 'apoc.trigger.list', + description: + 'Lists all currently installed triggers for the session database.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [], + signature: + 'apoc.trigger.list() :: (name :: STRING, query :: STRING, selector :: MAP, params :: MAP, installed :: BOOLEAN, paused :: BOOLEAN)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'query :: STRING', + name: 'query', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'selector :: MAP', + name: 'selector', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'params :: MAP', + name: 'params', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'installed :: BOOLEAN', + name: 'installed', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'paused :: BOOLEAN', + name: 'paused', + type: 'BOOLEAN', + }, + ], + admin: true, + option: { + deprecated: false, + }, + }, + 'apoc.trigger.pause': { + name: 'apoc.trigger.pause', + description: 'Pauses the given trigger.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + ], + signature: + 'apoc.trigger.pause(name :: STRING) :: (name :: STRING, query :: STRING, selector :: MAP, params :: MAP, installed :: BOOLEAN, paused :: BOOLEAN)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'query :: STRING', + name: 'query', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'selector :: MAP', + name: 'selector', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'params :: MAP', + name: 'params', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'installed :: BOOLEAN', + name: 'installed', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'paused :: BOOLEAN', + name: 'paused', + type: 'BOOLEAN', + }, + ], + admin: true, + option: { + deprecated: true, + }, + }, + 'apoc.trigger.remove': { + name: 'apoc.trigger.remove', + description: 'Removes the given trigger.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + ], + signature: + 'apoc.trigger.remove(name :: STRING) :: (name :: STRING, query :: STRING, selector :: MAP, params :: MAP, installed :: BOOLEAN, paused :: BOOLEAN)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'query :: STRING', + name: 'query', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'selector :: MAP', + name: 'selector', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'params :: MAP', + name: 'params', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'installed :: BOOLEAN', + name: 'installed', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'paused :: BOOLEAN', + name: 'paused', + type: 'BOOLEAN', + }, + ], + admin: true, + option: { + deprecated: true, + }, + }, + 'apoc.trigger.removeAll': { + name: 'apoc.trigger.removeAll', + description: 'Removes all previously added triggers.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [], + signature: + 'apoc.trigger.removeAll() :: (name :: STRING, query :: STRING, selector :: MAP, params :: MAP, installed :: BOOLEAN, paused :: BOOLEAN)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'query :: STRING', + name: 'query', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'selector :: MAP', + name: 'selector', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'params :: MAP', + name: 'params', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'installed :: BOOLEAN', + name: 'installed', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'paused :: BOOLEAN', + name: 'paused', + type: 'BOOLEAN', + }, + ], + admin: true, + option: { + deprecated: true, + }, + }, + 'apoc.trigger.resume': { + name: 'apoc.trigger.resume', + description: 'Resumes the given paused trigger.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + ], + signature: + 'apoc.trigger.resume(name :: STRING) :: (name :: STRING, query :: STRING, selector :: MAP, params :: MAP, installed :: BOOLEAN, paused :: BOOLEAN)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'query :: STRING', + name: 'query', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'selector :: MAP', + name: 'selector', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'params :: MAP', + name: 'params', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'installed :: BOOLEAN', + name: 'installed', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'paused :: BOOLEAN', + name: 'paused', + type: 'BOOLEAN', + }, + ], + admin: true, + option: { + deprecated: true, + }, + }, + 'apoc.trigger.show': { + name: 'apoc.trigger.show', + description: 'Lists all eventually installed triggers for a database.', + mode: 'READ', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + description: 'databaseName :: STRING', + name: 'databaseName', + type: 'STRING', + }, + ], + signature: + 'apoc.trigger.show(databaseName :: STRING) :: (name :: STRING, query :: STRING, selector :: MAP, params :: MAP, installed :: BOOLEAN, paused :: BOOLEAN)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'query :: STRING', + name: 'query', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'selector :: MAP', + name: 'selector', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'params :: MAP', + name: 'params', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'installed :: BOOLEAN', + name: 'installed', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'paused :: BOOLEAN', + name: 'paused', + type: 'BOOLEAN', + }, + ], + admin: true, + option: { + deprecated: false, + }, + }, + 'apoc.trigger.start': { + name: 'apoc.trigger.start', + description: 'Eventually restarts the given paused trigger.', + mode: 'WRITE', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + description: 'databaseName :: STRING', + name: 'databaseName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + ], + signature: + 'apoc.trigger.start(databaseName :: STRING, name :: STRING) :: (name :: STRING, query :: STRING, selector :: MAP, params :: MAP, installed :: BOOLEAN, paused :: BOOLEAN)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'query :: STRING', + name: 'query', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'selector :: MAP', + name: 'selector', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'params :: MAP', + name: 'params', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'installed :: BOOLEAN', + name: 'installed', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'paused :: BOOLEAN', + name: 'paused', + type: 'BOOLEAN', + }, + ], + admin: true, + option: { + deprecated: false, + }, + }, + 'apoc.trigger.stop': { + name: 'apoc.trigger.stop', + description: 'Eventually stops the given trigger.', + mode: 'WRITE', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + description: 'databaseName :: STRING', + name: 'databaseName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + ], + signature: + 'apoc.trigger.stop(databaseName :: STRING, name :: STRING) :: (name :: STRING, query :: STRING, selector :: MAP, params :: MAP, installed :: BOOLEAN, paused :: BOOLEAN)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'query :: STRING', + name: 'query', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'selector :: MAP', + name: 'selector', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'params :: MAP', + name: 'params', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'installed :: BOOLEAN', + name: 'installed', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'paused :: BOOLEAN', + name: 'paused', + type: 'BOOLEAN', + }, + ], + admin: true, + option: { + deprecated: false, + }, + }, + 'apoc.util.sleep': { + name: 'apoc.util.sleep', + description: + 'Causes the currently running Cypher to sleep for the given duration of milliseconds (the transaction termination is honored).', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'duration :: INTEGER', + name: 'duration', + type: 'INTEGER', + }, + ], + signature: 'apoc.util.sleep(duration :: INTEGER)', + returnDescription: [], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.util.validate': { + name: 'apoc.util.validate', + description: 'If the given predicate is true an exception is thrown.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'predicate :: BOOLEAN', + name: 'predicate', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'message :: STRING', + name: 'message', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'params :: LIST', + name: 'params', + type: 'LIST', + }, + ], + signature: + 'apoc.util.validate(predicate :: BOOLEAN, message :: STRING, params :: LIST)', + returnDescription: [], + admin: false, + option: { + deprecated: false, + }, + }, + 'apoc.warmup.run': { + name: 'apoc.warmup.run', + description: + 'Loads all `NODE` and `RELATIONSHIP` values in the database into memory.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + default: 'DefaultParameterValue{value=false, type=BOOLEAN}', + description: 'loadProperties = false :: BOOLEAN', + name: 'loadProperties', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=false, type=BOOLEAN}', + description: 'loadDynamicProperties = false :: BOOLEAN', + name: 'loadDynamicProperties', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=false, type=BOOLEAN}', + description: 'loadIndexes = false :: BOOLEAN', + name: 'loadIndexes', + type: 'BOOLEAN', + }, + ], + signature: + 'apoc.warmup.run(loadProperties = false :: BOOLEAN, loadDynamicProperties = false :: BOOLEAN, loadIndexes = false :: BOOLEAN) :: (pageSize :: INTEGER, totalTime :: INTEGER, transactionWasTerminated :: BOOLEAN, nodesPerPage :: INTEGER, nodesTotal :: INTEGER, nodePages :: INTEGER, nodesTime :: INTEGER, relsPerPage :: INTEGER, relsTotal :: INTEGER, relPages :: INTEGER, relsTime :: INTEGER, relGroupsPerPage :: INTEGER, relGroupsTotal :: INTEGER, relGroupPages :: INTEGER, relGroupsTime :: INTEGER, propertiesLoaded :: BOOLEAN, dynamicPropertiesLoaded :: BOOLEAN, propsPerPage :: INTEGER, propRecordsTotal :: INTEGER, propPages :: INTEGER, propsTime :: INTEGER, stringPropsPerPage :: INTEGER, stringPropRecordsTotal :: INTEGER, stringPropPages :: INTEGER, stringPropsTime :: INTEGER, arrayPropsPerPage :: INTEGER, arrayPropRecordsTotal :: INTEGER, arrayPropPages :: INTEGER, arrayPropsTime :: INTEGER, indexesLoaded :: BOOLEAN, indexPages :: INTEGER, indexTime :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'pageSize :: INTEGER', + name: 'pageSize', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'totalTime :: INTEGER', + name: 'totalTime', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'transactionWasTerminated :: BOOLEAN', + name: 'transactionWasTerminated', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'nodesPerPage :: INTEGER', + name: 'nodesPerPage', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodesTotal :: INTEGER', + name: 'nodesTotal', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodePages :: INTEGER', + name: 'nodePages', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodesTime :: INTEGER', + name: 'nodesTime', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relsPerPage :: INTEGER', + name: 'relsPerPage', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relsTotal :: INTEGER', + name: 'relsTotal', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relPages :: INTEGER', + name: 'relPages', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relsTime :: INTEGER', + name: 'relsTime', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relGroupsPerPage :: INTEGER', + name: 'relGroupsPerPage', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relGroupsTotal :: INTEGER', + name: 'relGroupsTotal', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relGroupPages :: INTEGER', + name: 'relGroupPages', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relGroupsTime :: INTEGER', + name: 'relGroupsTime', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'propertiesLoaded :: BOOLEAN', + name: 'propertiesLoaded', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'dynamicPropertiesLoaded :: BOOLEAN', + name: 'dynamicPropertiesLoaded', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'propsPerPage :: INTEGER', + name: 'propsPerPage', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'propRecordsTotal :: INTEGER', + name: 'propRecordsTotal', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'propPages :: INTEGER', + name: 'propPages', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'propsTime :: INTEGER', + name: 'propsTime', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'stringPropsPerPage :: INTEGER', + name: 'stringPropsPerPage', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'stringPropRecordsTotal :: INTEGER', + name: 'stringPropRecordsTotal', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'stringPropPages :: INTEGER', + name: 'stringPropPages', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'stringPropsTime :: INTEGER', + name: 'stringPropsTime', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'arrayPropsPerPage :: INTEGER', + name: 'arrayPropsPerPage', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'arrayPropRecordsTotal :: INTEGER', + name: 'arrayPropRecordsTotal', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'arrayPropPages :: INTEGER', + name: 'arrayPropPages', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'arrayPropsTime :: INTEGER', + name: 'arrayPropsTime', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'indexesLoaded :: BOOLEAN', + name: 'indexesLoaded', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'indexPages :: INTEGER', + name: 'indexPages', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'indexTime :: INTEGER', + name: 'indexTime', + type: 'INTEGER', + }, + ], + admin: false, + option: { + deprecated: true, + }, + }, + 'apoc.when': { + name: 'apoc.when', + description: + 'This procedure will run the read-only `ifQuery` if the conditional has evaluated to true, otherwise the `elseQuery` will run.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'condition :: BOOLEAN', + name: 'condition', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'ifQuery :: STRING', + name: 'ifQuery', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'elseQuery = :: STRING', + name: 'elseQuery', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'params = {} :: MAP', + name: 'params', + type: 'MAP', + }, + ], + signature: + 'apoc.when(condition :: BOOLEAN, ifQuery :: STRING, elseQuery = :: STRING, params = {} :: MAP) :: (value :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'value :: MAP', + name: 'value', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'cdc.current': { + name: 'cdc.current', + description: + 'Returns the current change identifier that can be used to stream changes from.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [], + signature: 'cdc.current() :: (id :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'id :: STRING', + name: 'id', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'cdc.earliest': { + name: 'cdc.earliest', + description: + 'Returns the earliest change identifier that can be used to stream changes from.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [], + signature: 'cdc.earliest() :: (id :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'id :: STRING', + name: 'id', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'cdc.query': { + name: 'cdc.query', + description: + 'Query changes happened from the provided change identifier.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'from = :: STRING', + name: 'from', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=[], type=LIST}', + description: 'selectors = [] :: LIST', + name: 'selectors', + type: 'LIST', + }, + ], + signature: + 'cdc.query(from = :: STRING, selectors = [] :: LIST) :: (id :: STRING, txId :: INTEGER, seq :: INTEGER, metadata :: MAP, event :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'id :: STRING', + name: 'id', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'txId :: INTEGER', + name: 'txId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'seq :: INTEGER', + name: 'seq', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'metadata :: MAP', + name: 'metadata', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'event :: MAP', + name: 'event', + type: 'MAP', + }, + ], + admin: true, + option: { + deprecated: false, + }, + }, + 'db.awaitIndex': { + name: 'db.awaitIndex', + description: + 'Wait for an index to come online (for example: CALL db.awaitIndex("MyIndex", 300)).', + mode: 'READ', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + description: 'indexName :: STRING', + name: 'indexName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=300, type=INTEGER}', + description: 'timeOutSeconds = 300 :: INTEGER', + name: 'timeOutSeconds', + type: 'INTEGER', + }, + ], + signature: + 'db.awaitIndex(indexName :: STRING, timeOutSeconds = 300 :: INTEGER)', + returnDescription: [], + admin: false, + option: { + deprecated: false, + }, + }, + 'db.awaitIndexes': { + name: 'db.awaitIndexes', + description: + 'Wait for all indexes to come online (for example: CALL db.awaitIndexes(300)).', + mode: 'READ', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + default: 'DefaultParameterValue{value=300, type=INTEGER}', + description: 'timeOutSeconds = 300 :: INTEGER', + name: 'timeOutSeconds', + type: 'INTEGER', + }, + ], + signature: 'db.awaitIndexes(timeOutSeconds = 300 :: INTEGER)', + returnDescription: [], + admin: false, + option: { + deprecated: false, + }, + }, + 'db.checkpoint': { + name: 'db.checkpoint', + description: + 'Initiate and wait for a new check point, or wait any already on-going check point to complete. Note that this temporarily disables the `db.checkpoint.iops.limit` setting in order to make the check point complete faster. This might cause transaction throughput to degrade slightly, due to increased IO load.', + mode: 'DBMS', + worksOnSystem: true, + argumentDescription: [], + signature: 'db.checkpoint() :: (success :: BOOLEAN, message :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'success :: BOOLEAN', + name: 'success', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'message :: STRING', + name: 'message', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'db.clearQueryCaches': { + name: 'db.clearQueryCaches', + description: 'Clears all query caches.', + mode: 'DBMS', + worksOnSystem: true, + argumentDescription: [], + signature: 'db.clearQueryCaches() :: (value :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'value :: STRING', + name: 'value', + type: 'STRING', + }, + ], + admin: true, + option: { + deprecated: false, + }, + }, + 'db.create.setNodeVectorProperty': { + name: 'db.create.setNodeVectorProperty', + description: + "Set a vector property on a given node in a more space efficient representation than Cypher's SET.", + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', + }, + { + isDeprecated: false, + description: 'key :: STRING', + name: 'key', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'vector :: LIST', + name: 'vector', + type: 'LIST', + }, + ], + signature: + 'db.create.setNodeVectorProperty(node :: NODE, key :: STRING, vector :: LIST)', + returnDescription: [], + admin: false, + option: { + deprecated: false, + }, + }, + 'db.create.setVectorProperty': { + name: 'db.create.setVectorProperty', + description: + "Set a vector property on a given node in a more space efficient representation than Cypher's SET.", + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', + }, + { + isDeprecated: false, + description: 'key :: STRING', + name: 'key', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'vector :: LIST', + name: 'vector', + type: 'LIST', + }, + ], + signature: + 'db.create.setVectorProperty(node :: NODE, key :: STRING, vector :: LIST) :: (node :: NODE)', + returnDescription: [ + { + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', + }, + ], + admin: false, + option: { + deprecated: true, + }, + }, + 'db.createLabel': { + name: 'db.createLabel', + description: 'Create a label', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'newLabel :: STRING', + name: 'newLabel', + type: 'STRING', + }, + ], + signature: 'db.createLabel(newLabel :: STRING)', + returnDescription: [], + admin: false, + option: { + deprecated: false, + }, + }, + 'db.createProperty': { + name: 'db.createProperty', + description: 'Create a Property', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'newProperty :: STRING', + name: 'newProperty', + type: 'STRING', + }, + ], + signature: 'db.createProperty(newProperty :: STRING)', + returnDescription: [], + admin: false, + option: { + deprecated: false, + }, + }, + 'db.createRelationshipType': { + name: 'db.createRelationshipType', + description: 'Create a RelationshipType', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'newRelationshipType :: STRING', + name: 'newRelationshipType', + type: 'STRING', + }, + ], + signature: 'db.createRelationshipType(newRelationshipType :: STRING)', + returnDescription: [], + admin: false, + option: { + deprecated: false, + }, + }, + 'db.index.fulltext.awaitEventuallyConsistentIndexRefresh': { + name: 'db.index.fulltext.awaitEventuallyConsistentIndexRefresh', + description: + 'Wait for the updates from recently committed transactions to be applied to any eventually-consistent full-text indexes.', + mode: 'READ', + worksOnSystem: true, + argumentDescription: [], + signature: 'db.index.fulltext.awaitEventuallyConsistentIndexRefresh()', + returnDescription: [], + admin: false, + option: { + deprecated: false, + }, + }, + 'db.index.fulltext.listAvailableAnalyzers': { + name: 'db.index.fulltext.listAvailableAnalyzers', + description: + 'List the available analyzers that the full-text indexes can be configured with.', + mode: 'READ', + worksOnSystem: true, + argumentDescription: [], + signature: + 'db.index.fulltext.listAvailableAnalyzers() :: (analyzer :: STRING, description :: STRING, stopwords :: LIST)', + returnDescription: [ + { + isDeprecated: false, + description: 'analyzer :: STRING', + name: 'analyzer', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'description :: STRING', + name: 'description', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'stopwords :: LIST', + name: 'stopwords', + type: 'LIST', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'db.index.fulltext.queryNodes': { + name: 'db.index.fulltext.queryNodes', + description: + "Query the given full-text index. Returns the matching nodes, and their Lucene query score, ordered by score. Valid keys for the options map are: 'skip' to skip the top N results; 'limit' to limit the number of results returned; 'analyzer' to use the specified analyzer as a search analyzer for this query.", + mode: 'READ', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + description: 'indexName :: STRING', + name: 'indexName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'queryString :: STRING', + name: 'queryString', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'options = {} :: MAP', + name: 'options', + type: 'MAP', + }, + ], + signature: + 'db.index.fulltext.queryNodes(indexName :: STRING, queryString :: STRING, options = {} :: MAP) :: (node :: NODE, score :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', + }, + { + isDeprecated: false, + description: 'score :: FLOAT', + name: 'score', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'db.index.fulltext.queryRelationships': { + name: 'db.index.fulltext.queryRelationships', + description: + "Query the given full-text index. Returns the matching relationships, and their Lucene query score, ordered by score. Valid keys for the options map are: 'skip' to skip the top N results; 'limit' to limit the number of results returned; 'analyzer' to use the specified analyzer as search analyzer for this query.", + mode: 'READ', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + description: 'indexName :: STRING', + name: 'indexName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'queryString :: STRING', + name: 'queryString', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'options = {} :: MAP', + name: 'options', + type: 'MAP', + }, + ], + signature: + 'db.index.fulltext.queryRelationships(indexName :: STRING, queryString :: STRING, options = {} :: MAP) :: (relationship :: RELATIONSHIP, score :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'relationship :: RELATIONSHIP', + name: 'relationship', + type: 'RELATIONSHIP', + }, + { + isDeprecated: false, + description: 'score :: FLOAT', + name: 'score', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'db.index.vector.createNodeIndex': { + name: 'db.index.vector.createNodeIndex', + description: + "Create a named node vector index for the given label and property for a specified vector dimensionality.\nValid similarity functions are 'EUCLIDEAN' and 'COSINE', and are case-insensitive.\nUse the `db.index.vector.queryNodes` procedure to query the named index.\n", + mode: 'SCHEMA', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'indexName :: STRING', + name: 'indexName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'label :: STRING', + name: 'label', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'propertyKey :: STRING', + name: 'propertyKey', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'vectorDimension :: INTEGER', + name: 'vectorDimension', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'vectorSimilarityFunction :: STRING', + name: 'vectorSimilarityFunction', + type: 'STRING', + }, + ], + signature: + 'db.index.vector.createNodeIndex(indexName :: STRING, label :: STRING, propertyKey :: STRING, vectorDimension :: INTEGER, vectorSimilarityFunction :: STRING)', + returnDescription: [], + admin: false, + option: { + deprecated: false, + }, + }, + 'db.index.vector.queryNodes': { + name: 'db.index.vector.queryNodes', + description: + 'Query the given vector index.\nReturns requested number of nearest neighbors to the provided query vector,\nand their similarity score to that query vector, based on the configured similarity function for the index.\nThe similarity score is a value between [0, 1]; where 0 indicates least similar, 1 most similar.\n', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'indexName :: STRING', + name: 'indexName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'numberOfNearestNeighbours :: INTEGER', + name: 'numberOfNearestNeighbours', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'query :: LIST', + name: 'query', + type: 'LIST', + }, + ], + signature: + 'db.index.vector.queryNodes(indexName :: STRING, numberOfNearestNeighbours :: INTEGER, query :: LIST) :: (node :: NODE, score :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'node :: NODE', + name: 'node', + type: 'NODE', + }, + { + isDeprecated: false, + description: 'score :: FLOAT', + name: 'score', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'db.info': { + name: 'db.info', + description: 'Provides information regarding the database.', + mode: 'READ', + worksOnSystem: true, + argumentDescription: [], + signature: + 'db.info() :: (id :: STRING, name :: STRING, creationDate :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'id :: STRING', + name: 'id', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'creationDate :: STRING', + name: 'creationDate', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'db.labels': { + name: 'db.labels', + description: + "List all labels attached to nodes within a database according to the user's access rights. The procedure returns empty results if the user is not authorized to view those labels.", + mode: 'READ', + worksOnSystem: true, + argumentDescription: [], + signature: 'db.labels() :: (label :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'label :: STRING', + name: 'label', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'db.listLocks': { + name: 'db.listLocks', + description: 'List all locks at this database.', + mode: 'DBMS', + worksOnSystem: true, + argumentDescription: [], + signature: + 'db.listLocks() :: (mode :: STRING, resourceType :: STRING, resourceId :: INTEGER, transactionId :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'mode :: STRING', + name: 'mode', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'resourceType :: STRING', + name: 'resourceType', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'resourceId :: INTEGER', + name: 'resourceId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'transactionId :: STRING', + name: 'transactionId', + type: 'STRING', + }, + ], + admin: true, + option: { + deprecated: false, + }, + }, + 'db.ping': { + name: 'db.ping', + description: + 'This procedure can be used by client side tooling to test whether they are correctly connected to a database. The procedure is available in all databases and always returns true. A faulty connection can be detected by not being able to call this procedure.', + mode: 'READ', + worksOnSystem: true, + argumentDescription: [], + signature: 'db.ping() :: (success :: BOOLEAN)', + returnDescription: [ + { + isDeprecated: false, + description: 'success :: BOOLEAN', + name: 'success', + type: 'BOOLEAN', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'db.prepareForReplanning': { + name: 'db.prepareForReplanning', + description: + 'Triggers an index resample and waits for it to complete, and after that clears query caches. After this procedure has finished queries will be planned using the latest database statistics.', + mode: 'READ', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + default: 'DefaultParameterValue{value=300, type=INTEGER}', + description: 'timeOutSeconds = 300 :: INTEGER', + name: 'timeOutSeconds', + type: 'INTEGER', + }, + ], + signature: 'db.prepareForReplanning(timeOutSeconds = 300 :: INTEGER)', + returnDescription: [], + admin: true, + option: { + deprecated: false, + }, + }, + 'db.propertyKeys': { + name: 'db.propertyKeys', + description: 'List all property keys in the database.', + mode: 'READ', + worksOnSystem: true, + argumentDescription: [], + signature: 'db.propertyKeys() :: (propertyKey :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'propertyKey :: STRING', + name: 'propertyKey', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'db.relationshipTypes': { + name: 'db.relationshipTypes', + description: + "List all types attached to relationships within a database according to the user's access rights. The procedure returns empty results if the user is not authorized to view those relationship types.", + mode: 'READ', + worksOnSystem: true, + argumentDescription: [], + signature: 'db.relationshipTypes() :: (relationshipType :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'relationshipType :: STRING', + name: 'relationshipType', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'db.resampleIndex': { + name: 'db.resampleIndex', + description: + 'Schedule resampling of an index (for example: CALL db.resampleIndex("MyIndex")).', + mode: 'READ', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + description: 'indexName :: STRING', + name: 'indexName', + type: 'STRING', + }, + ], + signature: 'db.resampleIndex(indexName :: STRING)', + returnDescription: [], + admin: false, + option: { + deprecated: false, + }, + }, + 'db.resampleOutdatedIndexes': { + name: 'db.resampleOutdatedIndexes', + description: 'Schedule resampling of all outdated indexes.', + mode: 'READ', + worksOnSystem: true, + argumentDescription: [], + signature: 'db.resampleOutdatedIndexes()', + returnDescription: [], + admin: false, + option: { + deprecated: false, + }, + }, + 'db.schema.nodeTypeProperties': { + name: 'db.schema.nodeTypeProperties', + description: + 'Show the derived property schema of the nodes in tabular form.', + mode: 'READ', + worksOnSystem: true, + argumentDescription: [], + signature: + 'db.schema.nodeTypeProperties() :: (nodeType :: STRING, nodeLabels :: LIST, propertyName :: STRING, propertyTypes :: LIST, mandatory :: BOOLEAN)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeType :: STRING', + name: 'nodeType', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodeLabels :: LIST', + name: 'nodeLabels', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'propertyName :: STRING', + name: 'propertyName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'propertyTypes :: LIST', + name: 'propertyTypes', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'mandatory :: BOOLEAN', + name: 'mandatory', + type: 'BOOLEAN', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'db.schema.relTypeProperties': { + name: 'db.schema.relTypeProperties', + description: + 'Show the derived property schema of the relationships in tabular form.', + mode: 'READ', + worksOnSystem: true, + argumentDescription: [], + signature: + 'db.schema.relTypeProperties() :: (relType :: STRING, propertyName :: STRING, propertyTypes :: LIST, mandatory :: BOOLEAN)', + returnDescription: [ + { + isDeprecated: false, + description: 'relType :: STRING', + name: 'relType', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'propertyName :: STRING', + name: 'propertyName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'propertyTypes :: LIST', + name: 'propertyTypes', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'mandatory :: BOOLEAN', + name: 'mandatory', + type: 'BOOLEAN', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'db.schema.visualization': { + name: 'db.schema.visualization', + description: + 'Visualizes the schema of the data based on available statistics. A new node is returned for each label. The properties represented on the node include: `name` (label name), `indexes` (list of indexes), and `constraints` (list of constraints). A relationship of a given type is returned for all possible combinations of start and end nodes. The properties represented on the relationship include: `name` (type name). Note that this may include additional relationships that do not exist in the data due to the information available in the count store. ', + mode: 'READ', + worksOnSystem: true, + argumentDescription: [], + signature: + 'db.schema.visualization() :: (nodes :: LIST, relationships :: LIST)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodes :: LIST', + name: 'nodes', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'relationships :: LIST', + name: 'relationships', + type: 'LIST', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'db.stats.clear': { + name: 'db.stats.clear', + description: + "Clear collected data of a given data section. Valid sections are 'QUERIES'", + mode: 'READ', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + description: 'section :: STRING', + name: 'section', + type: 'STRING', + }, + ], + signature: + 'db.stats.clear(section :: STRING) :: (section :: STRING, success :: BOOLEAN, message :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'section :: STRING', + name: 'section', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'success :: BOOLEAN', + name: 'success', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'message :: STRING', + name: 'message', + type: 'STRING', + }, + ], + admin: true, + option: { + deprecated: false, + }, + }, + 'db.stats.collect': { + name: 'db.stats.collect', + description: + "Start data collection of a given data section. Valid sections are 'QUERIES'", + mode: 'READ', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + description: 'section :: STRING', + name: 'section', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'db.stats.collect(section :: STRING, config = {} :: MAP) :: (section :: STRING, success :: BOOLEAN, message :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'section :: STRING', + name: 'section', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'success :: BOOLEAN', + name: 'success', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'message :: STRING', + name: 'message', + type: 'STRING', + }, + ], + admin: true, + option: { + deprecated: false, + }, + }, + 'db.stats.retrieve': { + name: 'db.stats.retrieve', + description: + "Retrieve statistical data about the current database. Valid sections are 'GRAPH COUNTS', 'TOKENS', 'QUERIES', 'META'", + mode: 'READ', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + description: 'section :: STRING', + name: 'section', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'db.stats.retrieve(section :: STRING, config = {} :: MAP) :: (section :: STRING, data :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'section :: STRING', + name: 'section', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'data :: MAP', + name: 'data', + type: 'MAP', + }, + ], + admin: true, + option: { + deprecated: false, + }, + }, + 'db.stats.retrieveAllAnonymized': { + name: 'db.stats.retrieveAllAnonymized', + description: + 'Retrieve all available statistical data about the current database, in an anonymized form.', + mode: 'READ', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphToken :: STRING', + name: 'graphToken', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'db.stats.retrieveAllAnonymized(graphToken :: STRING, config = {} :: MAP) :: (section :: STRING, data :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'section :: STRING', + name: 'section', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'data :: MAP', + name: 'data', + type: 'MAP', + }, + ], + admin: true, + option: { + deprecated: false, + }, + }, + 'db.stats.status': { + name: 'db.stats.status', + description: + 'Retrieve the status of all available collector daemons, for this database.', + mode: 'READ', + worksOnSystem: true, + argumentDescription: [], + signature: + 'db.stats.status() :: (section :: STRING, status :: STRING, data :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'section :: STRING', + name: 'section', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'status :: STRING', + name: 'status', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'data :: MAP', + name: 'data', + type: 'MAP', + }, + ], + admin: true, + option: { + deprecated: false, + }, + }, + 'db.stats.stop': { + name: 'db.stats.stop', + description: + "Stop data collection of a given data section. Valid sections are 'QUERIES'", + mode: 'READ', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + description: 'section :: STRING', + name: 'section', + type: 'STRING', + }, + ], + signature: + 'db.stats.stop(section :: STRING) :: (section :: STRING, success :: BOOLEAN, message :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'section :: STRING', + name: 'section', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'success :: BOOLEAN', + name: 'success', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'message :: STRING', + name: 'message', + type: 'STRING', + }, + ], + admin: true, + option: { + deprecated: false, + }, + }, + 'dbms.checkConfigValue': { + name: 'dbms.checkConfigValue', + description: 'Check if a potential config setting value is valid.', + mode: 'DBMS', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + description: 'setting :: STRING', + name: 'setting', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'value :: STRING', + name: 'value', + type: 'STRING', + }, + ], + signature: + 'dbms.checkConfigValue(setting :: STRING, value :: STRING) :: (valid :: BOOLEAN, message :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'valid :: BOOLEAN', + name: 'valid', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'message :: STRING', + name: 'message', + type: 'STRING', + }, + ], + admin: true, + option: { + deprecated: false, + }, + }, + 'dbms.cluster.checkConnectivity': { + name: 'dbms.cluster.checkConnectivity', + description: + "Check the connectivity of this instance to other cluster members. Not all ports are relevant to all members. Valid values for 'port-name' are: [CLUSTER, RAFT]", + mode: 'DBMS', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + default: 'DefaultParameterValue{value=null, type=STRING}', + description: 'port-name = null :: STRING', + name: 'port-name', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=null, type=STRING}', + description: 'server = null :: STRING', + name: 'server', + type: 'STRING', + }, + ], + signature: + 'dbms.cluster.checkConnectivity(port-name = null :: STRING, server = null :: STRING) :: (serverId :: STRING, mode-constraint :: STRING, port-name :: STRING, port-address :: STRING, result :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'serverId :: STRING', + name: 'serverId', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mode-constraint :: STRING', + name: 'mode-constraint', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'port-name :: STRING', + name: 'port-name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'port-address :: STRING', + name: 'port-address', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'result :: STRING', + name: 'result', + type: 'STRING', + }, + ], + admin: true, + option: { + deprecated: false, + }, + }, + 'dbms.cluster.cordonServer': { + name: 'dbms.cluster.cordonServer', + description: + 'Mark a server in the topology as not suitable for new allocations. It will not force current allocations off the server. This is useful when deallocating databases when you have multiple unavailable servers.', + mode: 'WRITE', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + description: 'server :: STRING', + name: 'server', + type: 'STRING', + }, + ], + signature: 'dbms.cluster.cordonServer(server :: STRING)', + returnDescription: [], + admin: true, + option: { + deprecated: false, + }, + }, + 'dbms.cluster.protocols': { + name: 'dbms.cluster.protocols', + description: 'Overview of installed protocols', + mode: 'DBMS', + worksOnSystem: true, + argumentDescription: [], + signature: + 'dbms.cluster.protocols() :: (orientation :: STRING, remoteAddress :: STRING, applicationProtocol :: STRING, applicationProtocolVersion :: INTEGER, modifierProtocols :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'orientation :: STRING', + name: 'orientation', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'remoteAddress :: STRING', + name: 'remoteAddress', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'applicationProtocol :: STRING', + name: 'applicationProtocol', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'applicationProtocolVersion :: INTEGER', + name: 'applicationProtocolVersion', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'modifierProtocols :: STRING', + name: 'modifierProtocols', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'dbms.cluster.readReplicaToggle': { + name: 'dbms.cluster.readReplicaToggle', + description: + 'The toggle can pause or resume read replica (deprecated in favor of dbms.cluster.secondaryReplicationDisable)', + mode: 'DBMS', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + description: 'databaseName :: STRING', + name: 'databaseName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'pause :: BOOLEAN', + name: 'pause', + type: 'BOOLEAN', + }, + ], + signature: + 'dbms.cluster.readReplicaToggle(databaseName :: STRING, pause :: BOOLEAN) :: (state :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'state :: STRING', + name: 'state', + type: 'STRING', + }, + ], + admin: true, + option: { + deprecated: true, + }, + }, + 'dbms.cluster.routing.getRoutingTable': { + name: 'dbms.cluster.routing.getRoutingTable', + description: + "Returns the advertised bolt capable endpoints for a given database, divided by each endpoint's capabilities. For example, an endpoint may serve read queries, write queries, and/or future `getRoutingTable` requests.", + mode: 'DBMS', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + description: 'context :: MAP', + name: 'context', + type: 'MAP', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=null, type=STRING}', + description: 'database = null :: STRING', + name: 'database', + type: 'STRING', + }, + ], + signature: + 'dbms.cluster.routing.getRoutingTable(context :: MAP, database = null :: STRING) :: (ttl :: INTEGER, servers :: LIST)', + returnDescription: [ + { + isDeprecated: false, + description: 'ttl :: INTEGER', + name: 'ttl', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'servers :: LIST', + name: 'servers', + type: 'LIST', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'dbms.cluster.secondaryReplicationDisable': { + name: 'dbms.cluster.secondaryReplicationDisable', + description: + 'The toggle can pause or resume the secondary replication process.', + mode: 'DBMS', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + description: 'databaseName :: STRING', + name: 'databaseName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'pause :: BOOLEAN', + name: 'pause', + type: 'BOOLEAN', + }, + ], + signature: + 'dbms.cluster.secondaryReplicationDisable(databaseName :: STRING, pause :: BOOLEAN) :: (state :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'state :: STRING', + name: 'state', + type: 'STRING', + }, + ], + admin: true, + option: { + deprecated: false, + }, + }, + 'dbms.cluster.setAutomaticallyEnableFreeServers': { + name: 'dbms.cluster.setAutomaticallyEnableFreeServers', + description: + 'With this method you can set whether free servers are automatically enabled.', + mode: 'WRITE', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + description: 'autoEnable :: BOOLEAN', + name: 'autoEnable', + type: 'BOOLEAN', + }, + ], + signature: + 'dbms.cluster.setAutomaticallyEnableFreeServers(autoEnable :: BOOLEAN)', + returnDescription: [], + admin: true, + option: { + deprecated: false, + }, + }, + 'dbms.cluster.uncordonServer': { + name: 'dbms.cluster.uncordonServer', + description: "Remove the cordon on a server, returning it to 'enabled'.", + mode: 'WRITE', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + description: 'server :: STRING', + name: 'server', + type: 'STRING', + }, + ], + signature: 'dbms.cluster.uncordonServer(server :: STRING)', + returnDescription: [], + admin: true, + option: { + deprecated: false, + }, + }, + 'dbms.components': { + name: 'dbms.components', + description: 'List DBMS components and their versions.', + mode: 'DBMS', + worksOnSystem: true, + argumentDescription: [], + signature: + 'dbms.components() :: (name :: STRING, versions :: LIST, edition :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'versions :: LIST', + name: 'versions', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'edition :: STRING', + name: 'edition', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'dbms.info': { + name: 'dbms.info', + description: 'Provides information regarding the DBMS.', + mode: 'DBMS', + worksOnSystem: true, + argumentDescription: [], + signature: + 'dbms.info() :: (id :: STRING, name :: STRING, creationDate :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'id :: STRING', + name: 'id', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'creationDate :: STRING', + name: 'creationDate', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'dbms.killConnection': { + name: 'dbms.killConnection', + description: 'Kill network connection with the given connection id.', + mode: 'DBMS', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + description: 'id :: STRING', + name: 'id', + type: 'STRING', + }, + ], + signature: + 'dbms.killConnection(id :: STRING) :: (connectionId :: STRING, username :: STRING, message :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'connectionId :: STRING', + name: 'connectionId', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'username :: STRING', + name: 'username', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'message :: STRING', + name: 'message', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'dbms.killConnections': { + name: 'dbms.killConnections', + description: + 'Kill all network connections with the given connection ids.', + mode: 'DBMS', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + description: 'ids :: LIST', + name: 'ids', + type: 'LIST', + }, + ], + signature: + 'dbms.killConnections(ids :: LIST) :: (connectionId :: STRING, username :: STRING, message :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'connectionId :: STRING', + name: 'connectionId', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'username :: STRING', + name: 'username', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'message :: STRING', + name: 'message', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'dbms.listActiveLocks': { + name: 'dbms.listActiveLocks', + description: + 'List the active lock requests granted for the transaction executing the query with the given query id.', + mode: 'DBMS', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + description: 'queryId :: STRING', + name: 'queryId', + type: 'STRING', + }, + ], + signature: + 'dbms.listActiveLocks(queryId :: STRING) :: (mode :: STRING, resourceType :: STRING, resourceId :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'mode :: STRING', + name: 'mode', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'resourceType :: STRING', + name: 'resourceType', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'resourceId :: INTEGER', + name: 'resourceId', + type: 'INTEGER', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'dbms.listCapabilities': { + name: 'dbms.listCapabilities', + description: 'List capabilities.', + mode: 'DBMS', + worksOnSystem: true, + argumentDescription: [], + signature: + 'dbms.listCapabilities() :: (name :: STRING, description :: STRING, value :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'description :: STRING', + name: 'description', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'dbms.listConfig': { + name: 'dbms.listConfig', + description: 'List the currently active configuration settings of Neo4j.', + mode: 'DBMS', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'searchString = :: STRING', + name: 'searchString', + type: 'STRING', + }, + ], + signature: + 'dbms.listConfig(searchString = :: STRING) :: (name :: STRING, description :: STRING, value :: STRING, dynamic :: BOOLEAN, defaultValue :: STRING, startupValue :: STRING, explicitlySet :: BOOLEAN, validValues :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'description :: STRING', + name: 'description', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'value :: STRING', + name: 'value', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'dynamic :: BOOLEAN', + name: 'dynamic', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'defaultValue :: STRING', + name: 'defaultValue', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'startupValue :: STRING', + name: 'startupValue', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'explicitlySet :: BOOLEAN', + name: 'explicitlySet', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'validValues :: STRING', + name: 'validValues', + type: 'STRING', + }, + ], + admin: true, + option: { + deprecated: false, + }, + }, + 'dbms.listConnections': { + name: 'dbms.listConnections', + description: + 'List all accepted network connections at this instance that are visible to the user.', + mode: 'DBMS', + worksOnSystem: true, + argumentDescription: [], + signature: + 'dbms.listConnections() :: (connectionId :: STRING, connectTime :: STRING, connector :: STRING, username :: STRING, userAgent :: STRING, serverAddress :: STRING, clientAddress :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'connectionId :: STRING', + name: 'connectionId', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'connectTime :: STRING', + name: 'connectTime', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'connector :: STRING', + name: 'connector', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'username :: STRING', + name: 'username', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'userAgent :: STRING', + name: 'userAgent', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'serverAddress :: STRING', + name: 'serverAddress', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'clientAddress :: STRING', + name: 'clientAddress', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'dbms.listPools': { + name: 'dbms.listPools', + description: + 'List all memory pools, including sub pools, currently registered at this instance that are visible to the user.', + mode: 'DBMS', + worksOnSystem: true, + argumentDescription: [], + signature: + 'dbms.listPools() :: (pool :: STRING, databaseName :: STRING, heapMemoryUsed :: STRING, heapMemoryUsedBytes :: STRING, nativeMemoryUsed :: STRING, nativeMemoryUsedBytes :: STRING, freeMemory :: STRING, freeMemoryBytes :: STRING, totalPoolMemory :: STRING, totalPoolMemoryBytes :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'pool :: STRING', + name: 'pool', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'databaseName :: STRING', + name: 'databaseName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'heapMemoryUsed :: STRING', + name: 'heapMemoryUsed', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'heapMemoryUsedBytes :: STRING', + name: 'heapMemoryUsedBytes', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nativeMemoryUsed :: STRING', + name: 'nativeMemoryUsed', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nativeMemoryUsedBytes :: STRING', + name: 'nativeMemoryUsedBytes', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'freeMemory :: STRING', + name: 'freeMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'freeMemoryBytes :: STRING', + name: 'freeMemoryBytes', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'totalPoolMemory :: STRING', + name: 'totalPoolMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'totalPoolMemoryBytes :: STRING', + name: 'totalPoolMemoryBytes', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'dbms.quarantineDatabase': { + name: 'dbms.quarantineDatabase', + description: 'Place a database into quarantine or remove it from it.', + mode: 'DBMS', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + description: 'databaseName :: STRING', + name: 'databaseName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'setStatus :: BOOLEAN', + name: 'setStatus', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=No reason given, type=STRING}', + description: 'reason = No reason given :: STRING', + name: 'reason', + type: 'STRING', + }, + ], + signature: + 'dbms.quarantineDatabase(databaseName :: STRING, setStatus :: BOOLEAN, reason = No reason given :: STRING) :: (databaseName :: STRING, quarantined :: BOOLEAN, result :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'databaseName :: STRING', + name: 'databaseName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'quarantined :: BOOLEAN', + name: 'quarantined', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'result :: STRING', + name: 'result', + type: 'STRING', + }, + ], + admin: true, + option: { + deprecated: false, + }, + }, + 'dbms.queryJmx': { + name: 'dbms.queryJmx', + description: + 'Query JMX management data by domain and name. For instance, use `*:*` to find all JMX beans.', + mode: 'DBMS', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + description: 'query :: STRING', + name: 'query', + type: 'STRING', + }, + ], + signature: + 'dbms.queryJmx(query :: STRING) :: (name :: STRING, description :: STRING, attributes :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'description :: STRING', + name: 'description', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'attributes :: MAP', + name: 'attributes', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'dbms.routing.getRoutingTable': { + name: 'dbms.routing.getRoutingTable', + description: + "Returns the advertised bolt capable endpoints for a given database, divided by each endpoint's capabilities. For example, an endpoint may serve read queries, write queries, and/or future `getRoutingTable` requests.", + mode: 'DBMS', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + description: 'context :: MAP', + name: 'context', + type: 'MAP', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=null, type=STRING}', + description: 'database = null :: STRING', + name: 'database', + type: 'STRING', + }, + ], + signature: + 'dbms.routing.getRoutingTable(context :: MAP, database = null :: STRING) :: (ttl :: INTEGER, servers :: LIST)', + returnDescription: [ + { + isDeprecated: false, + description: 'ttl :: INTEGER', + name: 'ttl', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'servers :: LIST', + name: 'servers', + type: 'LIST', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'dbms.scheduler.failedJobs': { + name: 'dbms.scheduler.failedJobs', + description: + 'List failed job runs. There is a limit for amount of historical data.', + mode: 'DBMS', + worksOnSystem: true, + argumentDescription: [], + signature: + 'dbms.scheduler.failedJobs() :: (jobId :: STRING, group :: STRING, database :: STRING, submitter :: STRING, description :: STRING, type :: STRING, submitted :: STRING, executionStart :: STRING, failureTime :: STRING, failureDescription :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'jobId :: STRING', + name: 'jobId', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'group :: STRING', + name: 'group', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'database :: STRING', + name: 'database', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'submitter :: STRING', + name: 'submitter', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'description :: STRING', + name: 'description', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'type :: STRING', + name: 'type', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'submitted :: STRING', + name: 'submitted', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'executionStart :: STRING', + name: 'executionStart', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'failureTime :: STRING', + name: 'failureTime', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'failureDescription :: STRING', + name: 'failureDescription', + type: 'STRING', + }, + ], + admin: true, + option: { + deprecated: false, + }, + }, + 'dbms.scheduler.groups': { + name: 'dbms.scheduler.groups', + description: + 'List the job groups that are active in the database internal job scheduler.', + mode: 'DBMS', + worksOnSystem: true, + argumentDescription: [], + signature: + 'dbms.scheduler.groups() :: (group :: STRING, threads :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'group :: STRING', + name: 'group', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'threads :: INTEGER', + name: 'threads', + type: 'INTEGER', + }, + ], + admin: true, + option: { + deprecated: false, + }, + }, + 'dbms.scheduler.jobs': { + name: 'dbms.scheduler.jobs', + description: + 'List all jobs that are active in the database internal job scheduler.', + mode: 'DBMS', + worksOnSystem: true, + argumentDescription: [], + signature: + 'dbms.scheduler.jobs() :: (jobId :: STRING, group :: STRING, submitted :: STRING, database :: STRING, submitter :: STRING, description :: STRING, type :: STRING, scheduledAt :: STRING, period :: STRING, state :: STRING, currentStateDescription :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'jobId :: STRING', + name: 'jobId', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'group :: STRING', + name: 'group', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'submitted :: STRING', + name: 'submitted', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'database :: STRING', + name: 'database', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'submitter :: STRING', + name: 'submitter', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'description :: STRING', + name: 'description', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'type :: STRING', + name: 'type', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'scheduledAt :: STRING', + name: 'scheduledAt', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'period :: STRING', + name: 'period', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'state :: STRING', + name: 'state', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'currentStateDescription :: STRING', + name: 'currentStateDescription', + type: 'STRING', + }, + ], + admin: true, + option: { + deprecated: false, + }, + }, + 'dbms.security.clearAuthCache': { + name: 'dbms.security.clearAuthCache', + description: 'Clears authentication and authorization cache.', + mode: 'DBMS', + worksOnSystem: true, + argumentDescription: [], + signature: 'dbms.security.clearAuthCache()', + returnDescription: [], + admin: true, + option: { + deprecated: false, + }, + }, + 'dbms.setConfigValue': { + name: 'dbms.setConfigValue', + description: + 'Update a given setting value. Passing an empty value results in removing the configured value and falling back to the default value. Changes do not persist and are lost if the server is restarted. In a clustered environment, `dbms.setConfigValue` affects only the cluster member it is run against.', + mode: 'DBMS', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + description: 'setting :: STRING', + name: 'setting', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'value :: STRING', + name: 'value', + type: 'STRING', + }, + ], + signature: 'dbms.setConfigValue(setting :: STRING, value :: STRING)', + returnDescription: [], + admin: true, + option: { + deprecated: false, + }, + }, + 'dbms.setDatabaseAllocator': { + name: 'dbms.setDatabaseAllocator', + description: + 'With this method you can set the allocator that is responsible for selecting servers for hosting databases.', + mode: 'WRITE', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + description: 'allocator :: STRING', + name: 'allocator', + type: 'STRING', + }, + ], + signature: 'dbms.setDatabaseAllocator(allocator :: STRING)', + returnDescription: [], + admin: true, + option: { + deprecated: false, + }, + }, + 'dbms.setDefaultAllocationNumbers': { + name: 'dbms.setDefaultAllocationNumbers', + description: + 'With this method you can set the default number of primaries and secondaries.', + mode: 'WRITE', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + description: 'primaries :: INTEGER', + name: 'primaries', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'secondaries :: INTEGER', + name: 'secondaries', + type: 'INTEGER', + }, + ], + signature: + 'dbms.setDefaultAllocationNumbers(primaries :: INTEGER, secondaries :: INTEGER)', + returnDescription: [], + admin: true, + option: { + deprecated: false, + }, + }, + 'dbms.setDefaultDatabase': { + name: 'dbms.setDefaultDatabase', + description: + 'Change the default database to the provided value. The database must exist and the old default database must be stopped.', + mode: 'WRITE', + worksOnSystem: true, + argumentDescription: [ + { + isDeprecated: false, + description: 'databaseName :: STRING', + name: 'databaseName', + type: 'STRING', + }, + ], + signature: + 'dbms.setDefaultDatabase(databaseName :: STRING) :: (result :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'result :: STRING', + name: 'result', + type: 'STRING', + }, + ], + admin: true, + option: { + deprecated: false, + }, + }, + 'dbms.showCurrentUser': { + name: 'dbms.showCurrentUser', + description: 'Show the current user.', + mode: 'DBMS', + worksOnSystem: true, + argumentDescription: [], + signature: + 'dbms.showCurrentUser() :: (username :: STRING, roles :: LIST, flags :: LIST)', + returnDescription: [ + { + isDeprecated: false, + description: 'username :: STRING', + name: 'username', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'roles :: LIST', + name: 'roles', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'flags :: LIST', + name: 'flags', + type: 'LIST', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'dbms.showTopologyGraphConfig': { + name: 'dbms.showTopologyGraphConfig', + description: + 'With this method the configuration of the Topology Graph can be displayed.', + mode: 'READ', + worksOnSystem: true, + argumentDescription: [], + signature: + 'dbms.showTopologyGraphConfig() :: (allocator :: STRING, defaultPrimariesCount :: INTEGER, defaultSecondariesCount :: INTEGER, defaultDatabase :: STRING, autoEnableFreeServers :: BOOLEAN)', + returnDescription: [ + { + isDeprecated: false, + description: 'allocator :: STRING', + name: 'allocator', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'defaultPrimariesCount :: INTEGER', + name: 'defaultPrimariesCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'defaultSecondariesCount :: INTEGER', + name: 'defaultSecondariesCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'defaultDatabase :: STRING', + name: 'defaultDatabase', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'autoEnableFreeServers :: BOOLEAN', + name: 'autoEnableFreeServers', + type: 'BOOLEAN', + }, + ], + admin: true, + option: { + deprecated: false, + }, + }, + 'dbms.upgrade': { + name: 'dbms.upgrade', + description: + 'Upgrade the system database schema if it is not the current schema.', + mode: 'WRITE', + worksOnSystem: true, + argumentDescription: [], + signature: + 'dbms.upgrade() :: (status :: STRING, upgradeResult :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'status :: STRING', + name: 'status', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'upgradeResult :: STRING', + name: 'upgradeResult', + type: 'STRING', + }, + ], + admin: true, + option: { + deprecated: true, + }, + }, + 'dbms.upgradeStatus': { + name: 'dbms.upgradeStatus', + description: + 'Report the current status of the system database sub-graph schema.', + mode: 'READ', + worksOnSystem: true, + argumentDescription: [], + signature: + 'dbms.upgradeStatus() :: (status :: STRING, description :: STRING, resolution :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'status :: STRING', + name: 'status', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'description :: STRING', + name: 'description', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'resolution :: STRING', + name: 'resolution', + type: 'STRING', + }, + ], + admin: true, + option: { + deprecated: true, + }, + }, + 'gds.allShortestPaths.delta.mutate': { + name: 'gds.allShortestPaths.delta.mutate', + description: + 'The Delta Stepping shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph. The computation is run multi-threaded', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.allShortestPaths.delta.mutate(graphName :: STRING, configuration = {} :: MAP) :: (relationshipsWritten :: INTEGER, mutateMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'relationshipsWritten :: INTEGER', + name: 'relationshipsWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.allShortestPaths.delta.mutate.estimate': { + name: 'gds.allShortestPaths.delta.mutate.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.allShortestPaths.delta.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.allShortestPaths.delta.stats': { + name: 'gds.allShortestPaths.delta.stats', + description: + 'The Delta Stepping shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph. The computation is run multi-threaded', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.allShortestPaths.delta.stats(graphName :: STRING, configuration = {} :: MAP) :: (postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.allShortestPaths.delta.stats.estimate': { + name: 'gds.allShortestPaths.delta.stats.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.allShortestPaths.delta.stats.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.allShortestPaths.delta.stream': { + name: 'gds.allShortestPaths.delta.stream', + description: + 'The Delta Stepping shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph. The computation is run multi-threaded', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.allShortestPaths.delta.stream(graphName :: STRING, configuration = {} :: MAP) :: (index :: INTEGER, sourceNode :: INTEGER, targetNode :: INTEGER, totalCost :: FLOAT, nodeIds :: LIST, costs :: LIST, path :: PATH)', + returnDescription: [ + { + isDeprecated: false, + description: 'index :: INTEGER', + name: 'index', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'sourceNode :: INTEGER', + name: 'sourceNode', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'targetNode :: INTEGER', + name: 'targetNode', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'totalCost :: FLOAT', + name: 'totalCost', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'nodeIds :: LIST', + name: 'nodeIds', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'costs :: LIST', + name: 'costs', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'path :: PATH', + name: 'path', + type: 'PATH', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.allShortestPaths.delta.stream.estimate': { + name: 'gds.allShortestPaths.delta.stream.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.allShortestPaths.delta.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.allShortestPaths.delta.write': { + name: 'gds.allShortestPaths.delta.write', + description: + 'The Delta Stepping shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph. The computation is run multi-threaded', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.allShortestPaths.delta.write(graphName :: STRING, configuration = {} :: MAP) :: (relationshipsWritten :: INTEGER, writeMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'relationshipsWritten :: INTEGER', + name: 'relationshipsWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.allShortestPaths.delta.write.estimate': { + name: 'gds.allShortestPaths.delta.write.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.allShortestPaths.delta.write.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.allShortestPaths.dijkstra.mutate': { + name: 'gds.allShortestPaths.dijkstra.mutate', + description: + 'The Dijkstra shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.allShortestPaths.dijkstra.mutate(graphName :: STRING, configuration = {} :: MAP) :: (relationshipsWritten :: INTEGER, mutateMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'relationshipsWritten :: INTEGER', + name: 'relationshipsWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.allShortestPaths.dijkstra.mutate.estimate': { + name: 'gds.allShortestPaths.dijkstra.mutate.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.allShortestPaths.dijkstra.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.allShortestPaths.dijkstra.stream': { + name: 'gds.allShortestPaths.dijkstra.stream', + description: + 'The Dijkstra shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.allShortestPaths.dijkstra.stream(graphName :: STRING, configuration = {} :: MAP) :: (index :: INTEGER, sourceNode :: INTEGER, targetNode :: INTEGER, totalCost :: FLOAT, nodeIds :: LIST, costs :: LIST, path :: PATH)', + returnDescription: [ + { + isDeprecated: false, + description: 'index :: INTEGER', + name: 'index', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'sourceNode :: INTEGER', + name: 'sourceNode', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'targetNode :: INTEGER', + name: 'targetNode', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'totalCost :: FLOAT', + name: 'totalCost', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'nodeIds :: LIST', + name: 'nodeIds', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'costs :: LIST', + name: 'costs', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'path :: PATH', + name: 'path', + type: 'PATH', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.allShortestPaths.dijkstra.stream.estimate': { + name: 'gds.allShortestPaths.dijkstra.stream.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.allShortestPaths.dijkstra.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.allShortestPaths.dijkstra.write': { + name: 'gds.allShortestPaths.dijkstra.write', + description: + 'The Dijkstra shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.allShortestPaths.dijkstra.write(graphName :: STRING, configuration = {} :: MAP) :: (relationshipsWritten :: INTEGER, writeMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'relationshipsWritten :: INTEGER', + name: 'relationshipsWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.allShortestPaths.dijkstra.write.estimate': { + name: 'gds.allShortestPaths.dijkstra.write.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.allShortestPaths.dijkstra.write.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.allShortestPaths.stream': { + name: 'gds.allShortestPaths.stream', + description: + 'The All Pairs Shortest Path (APSP) calculates the shortest (weighted) path between all pairs of nodes.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.allShortestPaths.stream(graphName :: STRING, configuration = {} :: MAP) :: (sourceNodeId :: INTEGER, targetNodeId :: INTEGER, distance :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'sourceNodeId :: INTEGER', + name: 'sourceNodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'targetNodeId :: INTEGER', + name: 'targetNodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'distance :: FLOAT', + name: 'distance', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.alpha.ml.splitRelationships.mutate': { + name: 'gds.alpha.ml.splitRelationships.mutate', + description: + 'Splits a graph into holdout and remaining relationship types and adds them to the graph.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.alpha.ml.splitRelationships.mutate(graphName :: STRING, configuration = {} :: MAP) :: (preProcessingMillis :: INTEGER, computeMillis :: INTEGER, mutateMillis :: INTEGER, relationshipsWritten :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipsWritten :: INTEGER', + name: 'relationshipsWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.alpha.pipeline.linkPrediction.addMLP': { + name: 'gds.alpha.pipeline.linkPrediction.addMLP', + description: + 'Add a multilayer perceptron configuration to the parameter space of the link prediction train pipeline.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'pipelineName :: STRING', + name: 'pipelineName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'gds.alpha.pipeline.linkPrediction.addMLP(pipelineName :: STRING, config = {} :: MAP) :: (name :: STRING, nodePropertySteps :: LIST, featureSteps :: LIST, splitConfig :: MAP, autoTuningConfig :: MAP, parameterSpace :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodePropertySteps :: LIST', + name: 'nodePropertySteps', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'featureSteps :: LIST', + name: 'featureSteps', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'splitConfig :: MAP', + name: 'splitConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'autoTuningConfig :: MAP', + name: 'autoTuningConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'parameterSpace :: ANY', + name: 'parameterSpace', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.alpha.pipeline.linkPrediction.configureAutoTuning': { + name: 'gds.alpha.pipeline.linkPrediction.configureAutoTuning', + description: + 'Configures the auto-tuning of the link prediction pipeline.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'pipelineName :: STRING', + name: 'pipelineName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.alpha.pipeline.linkPrediction.configureAutoTuning(pipelineName :: STRING, configuration :: MAP) :: (name :: STRING, nodePropertySteps :: LIST, featureSteps :: LIST, splitConfig :: MAP, autoTuningConfig :: MAP, parameterSpace :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodePropertySteps :: LIST', + name: 'nodePropertySteps', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'featureSteps :: LIST', + name: 'featureSteps', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'splitConfig :: MAP', + name: 'splitConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'autoTuningConfig :: MAP', + name: 'autoTuningConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'parameterSpace :: ANY', + name: 'parameterSpace', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.alpha.pipeline.nodeClassification.addMLP': { + name: 'gds.alpha.pipeline.nodeClassification.addMLP', + description: + 'Add a multilayer perceptron configuration to the parameter space of the node classification train pipeline.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'pipelineName :: STRING', + name: 'pipelineName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'gds.alpha.pipeline.nodeClassification.addMLP(pipelineName :: STRING, config = {} :: MAP) :: (name :: STRING, nodePropertySteps :: LIST, featureProperties :: LIST, splitConfig :: MAP, autoTuningConfig :: MAP, parameterSpace :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodePropertySteps :: LIST', + name: 'nodePropertySteps', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'featureProperties :: LIST', + name: 'featureProperties', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'splitConfig :: MAP', + name: 'splitConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'autoTuningConfig :: MAP', + name: 'autoTuningConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'parameterSpace :: ANY', + name: 'parameterSpace', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.alpha.pipeline.nodeClassification.configureAutoTuning': { + name: 'gds.alpha.pipeline.nodeClassification.configureAutoTuning', + description: + 'Configures the auto-tuning of the node classification pipeline.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'pipelineName :: STRING', + name: 'pipelineName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.alpha.pipeline.nodeClassification.configureAutoTuning(pipelineName :: STRING, configuration :: MAP) :: (name :: STRING, nodePropertySteps :: LIST, featureProperties :: LIST, splitConfig :: MAP, autoTuningConfig :: MAP, parameterSpace :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodePropertySteps :: LIST', + name: 'nodePropertySteps', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'featureProperties :: LIST', + name: 'featureProperties', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'splitConfig :: MAP', + name: 'splitConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'autoTuningConfig :: MAP', + name: 'autoTuningConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'parameterSpace :: ANY', + name: 'parameterSpace', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.alpha.pipeline.nodeRegression.addLinearRegression': { + name: 'gds.alpha.pipeline.nodeRegression.addLinearRegression', + description: + 'Add a linear regression model candidate to a node regression pipeline.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'pipelineName :: STRING', + name: 'pipelineName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.alpha.pipeline.nodeRegression.addLinearRegression(pipelineName :: STRING, configuration = {} :: MAP) :: (name :: STRING, nodePropertySteps :: LIST, featureProperties :: LIST, splitConfig :: MAP, autoTuningConfig :: MAP, parameterSpace :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodePropertySteps :: LIST', + name: 'nodePropertySteps', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'featureProperties :: LIST', + name: 'featureProperties', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'splitConfig :: MAP', + name: 'splitConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'autoTuningConfig :: MAP', + name: 'autoTuningConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'parameterSpace :: ANY', + name: 'parameterSpace', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.alpha.pipeline.nodeRegression.addNodeProperty': { + name: 'gds.alpha.pipeline.nodeRegression.addNodeProperty', + description: + 'Add a node property step to an existing node regression training pipeline.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'pipelineName :: STRING', + name: 'pipelineName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'procedureName :: STRING', + name: 'procedureName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'procedureConfiguration :: MAP', + name: 'procedureConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.alpha.pipeline.nodeRegression.addNodeProperty(pipelineName :: STRING, procedureName :: STRING, procedureConfiguration :: MAP) :: (name :: STRING, nodePropertySteps :: LIST, featureProperties :: LIST, splitConfig :: MAP, autoTuningConfig :: MAP, parameterSpace :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodePropertySteps :: LIST', + name: 'nodePropertySteps', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'featureProperties :: LIST', + name: 'featureProperties', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'splitConfig :: MAP', + name: 'splitConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'autoTuningConfig :: MAP', + name: 'autoTuningConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'parameterSpace :: ANY', + name: 'parameterSpace', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.alpha.pipeline.nodeRegression.addRandomForest': { + name: 'gds.alpha.pipeline.nodeRegression.addRandomForest', + description: + 'Add a random forest model candidate to a node regression pipeline.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'pipelineName :: STRING', + name: 'pipelineName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.alpha.pipeline.nodeRegression.addRandomForest(pipelineName :: STRING, configuration :: MAP) :: (name :: STRING, nodePropertySteps :: LIST, featureProperties :: LIST, splitConfig :: MAP, autoTuningConfig :: MAP, parameterSpace :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodePropertySteps :: LIST', + name: 'nodePropertySteps', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'featureProperties :: LIST', + name: 'featureProperties', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'splitConfig :: MAP', + name: 'splitConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'autoTuningConfig :: MAP', + name: 'autoTuningConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'parameterSpace :: ANY', + name: 'parameterSpace', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.alpha.pipeline.nodeRegression.configureAutoTuning': { + name: 'gds.alpha.pipeline.nodeRegression.configureAutoTuning', + description: 'Configures the auto-tuning of a node regression pipeline.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'pipelineName :: STRING', + name: 'pipelineName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.alpha.pipeline.nodeRegression.configureAutoTuning(pipelineName :: STRING, configuration :: MAP) :: (name :: STRING, nodePropertySteps :: LIST, featureProperties :: LIST, splitConfig :: MAP, autoTuningConfig :: MAP, parameterSpace :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodePropertySteps :: LIST', + name: 'nodePropertySteps', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'featureProperties :: LIST', + name: 'featureProperties', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'splitConfig :: MAP', + name: 'splitConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'autoTuningConfig :: MAP', + name: 'autoTuningConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'parameterSpace :: ANY', + name: 'parameterSpace', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.alpha.pipeline.nodeRegression.configureSplit': { + name: 'gds.alpha.pipeline.nodeRegression.configureSplit', + description: + 'Configures the graph splitting of a node regression pipeline.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'pipelineName :: STRING', + name: 'pipelineName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.alpha.pipeline.nodeRegression.configureSplit(pipelineName :: STRING, configuration :: MAP) :: (name :: STRING, nodePropertySteps :: LIST, featureProperties :: LIST, splitConfig :: MAP, autoTuningConfig :: MAP, parameterSpace :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodePropertySteps :: LIST', + name: 'nodePropertySteps', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'featureProperties :: LIST', + name: 'featureProperties', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'splitConfig :: MAP', + name: 'splitConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'autoTuningConfig :: MAP', + name: 'autoTuningConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'parameterSpace :: ANY', + name: 'parameterSpace', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.alpha.pipeline.nodeRegression.create': { + name: 'gds.alpha.pipeline.nodeRegression.create', + description: + 'Creates a node regression training pipeline in the pipeline catalog.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'pipelineName :: STRING', + name: 'pipelineName', + type: 'STRING', + }, + ], + signature: + 'gds.alpha.pipeline.nodeRegression.create(pipelineName :: STRING) :: (name :: STRING, nodePropertySteps :: LIST, featureProperties :: LIST, splitConfig :: MAP, autoTuningConfig :: MAP, parameterSpace :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodePropertySteps :: LIST', + name: 'nodePropertySteps', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'featureProperties :: LIST', + name: 'featureProperties', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'splitConfig :: MAP', + name: 'splitConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'autoTuningConfig :: MAP', + name: 'autoTuningConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'parameterSpace :: ANY', + name: 'parameterSpace', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.alpha.pipeline.nodeRegression.predict.mutate': { + name: 'gds.alpha.pipeline.nodeRegression.predict.mutate', + description: + 'Predicts target node property using a previously trained `NodeRegression` model', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.alpha.pipeline.nodeRegression.predict.mutate(graphName :: STRING, configuration = {} :: MAP) :: (nodePropertiesWritten :: INTEGER, mutateMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.alpha.pipeline.nodeRegression.predict.stream': { + name: 'gds.alpha.pipeline.nodeRegression.predict.stream', + description: + 'Predicts target node property using a previously trained `NodeRegression` model', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.alpha.pipeline.nodeRegression.predict.stream(graphName :: STRING, configuration :: MAP) :: (nodeId :: INTEGER, predictedValue :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeId :: INTEGER', + name: 'nodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'predictedValue :: FLOAT', + name: 'predictedValue', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.alpha.pipeline.nodeRegression.selectFeatures': { + name: 'gds.alpha.pipeline.nodeRegression.selectFeatures', + description: + 'Add one or several features to an existing node regression training pipeline.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'pipelineName :: STRING', + name: 'pipelineName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'featureProperties :: ANY', + name: 'featureProperties', + type: 'ANY', + }, + ], + signature: + 'gds.alpha.pipeline.nodeRegression.selectFeatures(pipelineName :: STRING, featureProperties :: ANY) :: (name :: STRING, nodePropertySteps :: LIST, featureProperties :: LIST, splitConfig :: MAP, autoTuningConfig :: MAP, parameterSpace :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodePropertySteps :: LIST', + name: 'nodePropertySteps', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'featureProperties :: LIST', + name: 'featureProperties', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'splitConfig :: MAP', + name: 'splitConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'autoTuningConfig :: MAP', + name: 'autoTuningConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'parameterSpace :: ANY', + name: 'parameterSpace', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.alpha.pipeline.nodeRegression.train': { + name: 'gds.alpha.pipeline.nodeRegression.train', + description: 'Trains a node classification model based on a pipeline', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.alpha.pipeline.nodeRegression.train(graphName :: STRING, configuration = {} :: MAP) :: (modelSelectionStats :: MAP, trainMillis :: INTEGER, modelInfo :: MAP, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'modelSelectionStats :: MAP', + name: 'modelSelectionStats', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'trainMillis :: INTEGER', + name: 'trainMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'modelInfo :: MAP', + name: 'modelInfo', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.articleRank.mutate': { + name: 'gds.articleRank.mutate', + description: + 'Article Rank is a variant of the Page Rank algorithm, which measures the transitive influence or connectivity of nodes.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.articleRank.mutate(graphName :: STRING, configuration = {} :: MAP) :: (mutateMillis :: INTEGER, nodePropertiesWritten :: INTEGER, ranIterations :: INTEGER, didConverge :: BOOLEAN, centralityDistribution :: MAP, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'ranIterations :: INTEGER', + name: 'ranIterations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'didConverge :: BOOLEAN', + name: 'didConverge', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'centralityDistribution :: MAP', + name: 'centralityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.articleRank.mutate.estimate': { + name: 'gds.articleRank.mutate.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.articleRank.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.articleRank.stats': { + name: 'gds.articleRank.stats', + description: + 'Executes the algorithm and returns result statistics without writing the result to Neo4j.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.articleRank.stats(graphName :: STRING, configuration = {} :: MAP) :: (ranIterations :: INTEGER, didConverge :: BOOLEAN, centralityDistribution :: MAP, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'ranIterations :: INTEGER', + name: 'ranIterations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'didConverge :: BOOLEAN', + name: 'didConverge', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'centralityDistribution :: MAP', + name: 'centralityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.articleRank.stats.estimate': { + name: 'gds.articleRank.stats.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.articleRank.stats.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.articleRank.stream': { + name: 'gds.articleRank.stream', + description: + 'Article Rank is a variant of the Page Rank algorithm, which measures the transitive influence or connectivity of nodes.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.articleRank.stream(graphName :: STRING, configuration = {} :: MAP) :: (nodeId :: INTEGER, score :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeId :: INTEGER', + name: 'nodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'score :: FLOAT', + name: 'score', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.articleRank.stream.estimate': { + name: 'gds.articleRank.stream.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.articleRank.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.articleRank.write': { + name: 'gds.articleRank.write', + description: + 'Article Rank is a variant of the Page Rank algorithm, which measures the transitive influence or connectivity of nodes.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.articleRank.write(graphName :: STRING, configuration = {} :: MAP) :: (writeMillis :: INTEGER, nodePropertiesWritten :: INTEGER, ranIterations :: INTEGER, didConverge :: BOOLEAN, centralityDistribution :: MAP, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'ranIterations :: INTEGER', + name: 'ranIterations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'didConverge :: BOOLEAN', + name: 'didConverge', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'centralityDistribution :: MAP', + name: 'centralityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.articleRank.write.estimate': { + name: 'gds.articleRank.write.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.articleRank.write.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.backup': { + name: 'gds.backup', + description: 'The back-up procedure persists graphs and models to disk', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.backup(configuration = {} :: MAP) :: (graphName :: STRING, modelName :: STRING, backupTime :: ZONED DATETIME, exportPath :: STRING, exportMillis :: INTEGER, status :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'modelName :: STRING', + name: 'modelName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'backupTime :: ZONED DATETIME', + name: 'backupTime', + type: 'ZONED DATETIME', + }, + { + isDeprecated: false, + description: 'exportPath :: STRING', + name: 'exportPath', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'exportMillis :: INTEGER', + name: 'exportMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'status :: STRING', + name: 'status', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.bellmanFord.mutate': { + name: 'gds.bellmanFord.mutate', + description: + 'The Bellman-Ford shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph without negative cycles.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.bellmanFord.mutate(graphName :: STRING, configuration = {} :: MAP) :: (containsNegativeCycle :: BOOLEAN, relationshipsWritten :: INTEGER, mutateMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'containsNegativeCycle :: BOOLEAN', + name: 'containsNegativeCycle', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'relationshipsWritten :: INTEGER', + name: 'relationshipsWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.bellmanFord.mutate.estimate': { + name: 'gds.bellmanFord.mutate.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.bellmanFord.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.bellmanFord.stats': { + name: 'gds.bellmanFord.stats', + description: + 'The Bellman-Ford shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph without negative cycles.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.bellmanFord.stats(graphName :: STRING, configuration = {} :: MAP) :: (containsNegativeCycle :: BOOLEAN, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'containsNegativeCycle :: BOOLEAN', + name: 'containsNegativeCycle', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.bellmanFord.stats.estimate': { + name: 'gds.bellmanFord.stats.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.bellmanFord.stats.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.bellmanFord.stream': { + name: 'gds.bellmanFord.stream', + description: + 'The Bellman-Ford shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph without negative cycles.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.bellmanFord.stream(graphName :: STRING, configuration = {} :: MAP) :: (index :: INTEGER, sourceNode :: INTEGER, targetNode :: INTEGER, totalCost :: FLOAT, nodeIds :: LIST, costs :: LIST, route :: PATH, isNegativeCycle :: BOOLEAN)', + returnDescription: [ + { + isDeprecated: false, + description: 'index :: INTEGER', + name: 'index', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'sourceNode :: INTEGER', + name: 'sourceNode', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'targetNode :: INTEGER', + name: 'targetNode', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'totalCost :: FLOAT', + name: 'totalCost', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'nodeIds :: LIST', + name: 'nodeIds', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'costs :: LIST', + name: 'costs', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'route :: PATH', + name: 'route', + type: 'PATH', + }, + { + isDeprecated: false, + description: 'isNegativeCycle :: BOOLEAN', + name: 'isNegativeCycle', + type: 'BOOLEAN', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.bellmanFord.stream.estimate': { + name: 'gds.bellmanFord.stream.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.bellmanFord.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.bellmanFord.write': { + name: 'gds.bellmanFord.write', + description: + 'The Bellman-Ford shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph without negative cycles.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.bellmanFord.write(graphName :: STRING, configuration = {} :: MAP) :: (relationshipsWritten :: INTEGER, containsNegativeCycle :: BOOLEAN, writeMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'relationshipsWritten :: INTEGER', + name: 'relationshipsWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'containsNegativeCycle :: BOOLEAN', + name: 'containsNegativeCycle', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.bellmanFord.write.estimate': { + name: 'gds.bellmanFord.write.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.bellmanFord.write.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.beta.graphSage.mutate': { + name: 'gds.beta.graphSage.mutate', + description: + 'The GraphSage algorithm inductively computes embeddings for nodes based on a their features and neighborhoods.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.beta.graphSage.mutate(graphName :: STRING, configuration = {} :: MAP) :: (nodePropertiesWritten :: INTEGER, mutateMillis :: INTEGER, nodeCount :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.beta.graphSage.mutate.estimate': { + name: 'gds.beta.graphSage.mutate.estimate', + description: + 'The GraphSage algorithm inductively computes embeddings for nodes based on a their features and neighborhoods.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.beta.graphSage.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.beta.graphSage.stream': { + name: 'gds.beta.graphSage.stream', + description: + 'The GraphSage algorithm inductively computes embeddings for nodes based on a their features and neighborhoods.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.beta.graphSage.stream(graphName :: STRING, configuration = {} :: MAP) :: (nodeId :: INTEGER, embedding :: LIST)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeId :: INTEGER', + name: 'nodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'embedding :: LIST', + name: 'embedding', + type: 'LIST', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.beta.graphSage.stream.estimate': { + name: 'gds.beta.graphSage.stream.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.beta.graphSage.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.beta.graphSage.train': { + name: 'gds.beta.graphSage.train', + description: + 'The GraphSage algorithm inductively computes embeddings for nodes based on a their features and neighborhoods.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.beta.graphSage.train(graphName :: STRING, configuration = {} :: MAP) :: (modelInfo :: MAP, configuration :: MAP, trainMillis :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'modelInfo :: MAP', + name: 'modelInfo', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'trainMillis :: INTEGER', + name: 'trainMillis', + type: 'INTEGER', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.beta.graphSage.train.estimate': { + name: 'gds.beta.graphSage.train.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.beta.graphSage.train.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.beta.graphSage.write': { + name: 'gds.beta.graphSage.write', + description: + 'The GraphSage algorithm inductively computes embeddings for nodes based on a their features and neighborhoods.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.beta.graphSage.write(graphName :: STRING, configuration = {} :: MAP) :: (nodeCount :: INTEGER, nodePropertiesWritten :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, writeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.beta.graphSage.write.estimate': { + name: 'gds.beta.graphSage.write.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.beta.graphSage.write.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.beta.pipeline.linkPrediction.addFeature': { + name: 'gds.beta.pipeline.linkPrediction.addFeature', + description: + 'Add a feature step to an existing link prediction pipeline.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'pipelineName :: STRING', + name: 'pipelineName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'featureType :: STRING', + name: 'featureType', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.beta.pipeline.linkPrediction.addFeature(pipelineName :: STRING, featureType :: STRING, configuration :: MAP) :: (name :: STRING, nodePropertySteps :: LIST, featureSteps :: LIST, splitConfig :: MAP, autoTuningConfig :: MAP, parameterSpace :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodePropertySteps :: LIST', + name: 'nodePropertySteps', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'featureSteps :: LIST', + name: 'featureSteps', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'splitConfig :: MAP', + name: 'splitConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'autoTuningConfig :: MAP', + name: 'autoTuningConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'parameterSpace :: ANY', + name: 'parameterSpace', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.beta.pipeline.linkPrediction.addLogisticRegression': { + name: 'gds.beta.pipeline.linkPrediction.addLogisticRegression', + description: + 'Add a logistic regression configuration to the parameter space of the link prediction train pipeline.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'pipelineName :: STRING', + name: 'pipelineName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'gds.beta.pipeline.linkPrediction.addLogisticRegression(pipelineName :: STRING, config = {} :: MAP) :: (name :: STRING, nodePropertySteps :: LIST, featureSteps :: LIST, splitConfig :: MAP, autoTuningConfig :: MAP, parameterSpace :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodePropertySteps :: LIST', + name: 'nodePropertySteps', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'featureSteps :: LIST', + name: 'featureSteps', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'splitConfig :: MAP', + name: 'splitConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'autoTuningConfig :: MAP', + name: 'autoTuningConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'parameterSpace :: ANY', + name: 'parameterSpace', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.beta.pipeline.linkPrediction.addNodeProperty': { + name: 'gds.beta.pipeline.linkPrediction.addNodeProperty', + description: + 'Add a node property step to an existing link prediction pipeline.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'pipelineName :: STRING', + name: 'pipelineName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'procedureName :: STRING', + name: 'procedureName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'procedureConfiguration :: MAP', + name: 'procedureConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.beta.pipeline.linkPrediction.addNodeProperty(pipelineName :: STRING, procedureName :: STRING, procedureConfiguration :: MAP) :: (name :: STRING, nodePropertySteps :: LIST, featureSteps :: LIST, splitConfig :: MAP, autoTuningConfig :: MAP, parameterSpace :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodePropertySteps :: LIST', + name: 'nodePropertySteps', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'featureSteps :: LIST', + name: 'featureSteps', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'splitConfig :: MAP', + name: 'splitConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'autoTuningConfig :: MAP', + name: 'autoTuningConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'parameterSpace :: ANY', + name: 'parameterSpace', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.beta.pipeline.linkPrediction.addRandomForest': { + name: 'gds.beta.pipeline.linkPrediction.addRandomForest', + description: + 'Add a random forest configuration to the parameter space of the link prediction train pipeline.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'pipelineName :: STRING', + name: 'pipelineName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'config :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'gds.beta.pipeline.linkPrediction.addRandomForest(pipelineName :: STRING, config :: MAP) :: (name :: STRING, nodePropertySteps :: LIST, featureSteps :: LIST, splitConfig :: MAP, autoTuningConfig :: MAP, parameterSpace :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodePropertySteps :: LIST', + name: 'nodePropertySteps', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'featureSteps :: LIST', + name: 'featureSteps', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'splitConfig :: MAP', + name: 'splitConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'autoTuningConfig :: MAP', + name: 'autoTuningConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'parameterSpace :: ANY', + name: 'parameterSpace', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.beta.pipeline.linkPrediction.configureSplit': { + name: 'gds.beta.pipeline.linkPrediction.configureSplit', + description: 'Configures the split of the link prediction pipeline.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'pipelineName :: STRING', + name: 'pipelineName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.beta.pipeline.linkPrediction.configureSplit(pipelineName :: STRING, configuration :: MAP) :: (name :: STRING, nodePropertySteps :: LIST, featureSteps :: LIST, splitConfig :: MAP, autoTuningConfig :: MAP, parameterSpace :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodePropertySteps :: LIST', + name: 'nodePropertySteps', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'featureSteps :: LIST', + name: 'featureSteps', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'splitConfig :: MAP', + name: 'splitConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'autoTuningConfig :: MAP', + name: 'autoTuningConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'parameterSpace :: ANY', + name: 'parameterSpace', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.beta.pipeline.linkPrediction.create': { + name: 'gds.beta.pipeline.linkPrediction.create', + description: + 'Creates a link prediction pipeline in the pipeline catalog.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'pipelineName :: STRING', + name: 'pipelineName', + type: 'STRING', + }, + ], + signature: + 'gds.beta.pipeline.linkPrediction.create(pipelineName :: STRING) :: (name :: STRING, nodePropertySteps :: LIST, featureSteps :: LIST, splitConfig :: MAP, autoTuningConfig :: MAP, parameterSpace :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodePropertySteps :: LIST', + name: 'nodePropertySteps', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'featureSteps :: LIST', + name: 'featureSteps', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'splitConfig :: MAP', + name: 'splitConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'autoTuningConfig :: MAP', + name: 'autoTuningConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'parameterSpace :: ANY', + name: 'parameterSpace', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.beta.pipeline.linkPrediction.predict.mutate': { + name: 'gds.beta.pipeline.linkPrediction.predict.mutate', + description: + 'Predicts relationships for all non-connected node pairs based on a previously trained LinkPrediction model.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.beta.pipeline.linkPrediction.predict.mutate(graphName :: STRING, configuration = {} :: MAP) :: (relationshipsWritten :: INTEGER, probabilityDistribution :: MAP, samplingStats :: MAP, mutateMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'relationshipsWritten :: INTEGER', + name: 'relationshipsWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'probabilityDistribution :: MAP', + name: 'probabilityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'samplingStats :: MAP', + name: 'samplingStats', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.beta.pipeline.linkPrediction.predict.mutate.estimate': { + name: 'gds.beta.pipeline.linkPrediction.predict.mutate.estimate', + description: + 'Estimates memory for predicting relationships for all non-connected node pairs based on a previously trained LinkPrediction model', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.beta.pipeline.linkPrediction.predict.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.beta.pipeline.linkPrediction.predict.stream': { + name: 'gds.beta.pipeline.linkPrediction.predict.stream', + description: + 'Predicts relationships for all non-connected node pairs based on a previously trained LinkPrediction model.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.beta.pipeline.linkPrediction.predict.stream(graphName :: STRING, configuration = {} :: MAP) :: (node1 :: INTEGER, node2 :: INTEGER, probability :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'node1 :: INTEGER', + name: 'node1', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'node2 :: INTEGER', + name: 'node2', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'probability :: FLOAT', + name: 'probability', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.beta.pipeline.linkPrediction.predict.stream.estimate': { + name: 'gds.beta.pipeline.linkPrediction.predict.stream.estimate', + description: + 'Estimates memory for predicting relationships for all non-connected node pairs based on a previously trained LinkPrediction model', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.beta.pipeline.linkPrediction.predict.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.beta.pipeline.linkPrediction.train': { + name: 'gds.beta.pipeline.linkPrediction.train', + description: 'Trains a link prediction model based on a pipeline', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.beta.pipeline.linkPrediction.train(graphName :: STRING, configuration = {} :: MAP) :: (modelSelectionStats :: MAP, trainMillis :: INTEGER, modelInfo :: MAP, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'modelSelectionStats :: MAP', + name: 'modelSelectionStats', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'trainMillis :: INTEGER', + name: 'trainMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'modelInfo :: MAP', + name: 'modelInfo', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.beta.pipeline.linkPrediction.train.estimate': { + name: 'gds.beta.pipeline.linkPrediction.train.estimate', + description: 'Estimates memory for applying a linkPrediction model', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.beta.pipeline.linkPrediction.train.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.beta.pipeline.nodeClassification.addLogisticRegression': { + name: 'gds.beta.pipeline.nodeClassification.addLogisticRegression', + description: + 'Add a logistic regression configuration to the parameter space of the node classification train pipeline.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'pipelineName :: STRING', + name: 'pipelineName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'config = {} :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'gds.beta.pipeline.nodeClassification.addLogisticRegression(pipelineName :: STRING, config = {} :: MAP) :: (name :: STRING, nodePropertySteps :: LIST, featureProperties :: LIST, splitConfig :: MAP, autoTuningConfig :: MAP, parameterSpace :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodePropertySteps :: LIST', + name: 'nodePropertySteps', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'featureProperties :: LIST', + name: 'featureProperties', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'splitConfig :: MAP', + name: 'splitConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'autoTuningConfig :: MAP', + name: 'autoTuningConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'parameterSpace :: ANY', + name: 'parameterSpace', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.beta.pipeline.nodeClassification.addNodeProperty': { + name: 'gds.beta.pipeline.nodeClassification.addNodeProperty', + description: + 'Add a node property step to an existing node classification training pipeline.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'pipelineName :: STRING', + name: 'pipelineName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'procedureName :: STRING', + name: 'procedureName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'procedureConfiguration :: MAP', + name: 'procedureConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.beta.pipeline.nodeClassification.addNodeProperty(pipelineName :: STRING, procedureName :: STRING, procedureConfiguration :: MAP) :: (name :: STRING, nodePropertySteps :: LIST, featureProperties :: LIST, splitConfig :: MAP, autoTuningConfig :: MAP, parameterSpace :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodePropertySteps :: LIST', + name: 'nodePropertySteps', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'featureProperties :: LIST', + name: 'featureProperties', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'splitConfig :: MAP', + name: 'splitConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'autoTuningConfig :: MAP', + name: 'autoTuningConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'parameterSpace :: ANY', + name: 'parameterSpace', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.beta.pipeline.nodeClassification.addRandomForest': { + name: 'gds.beta.pipeline.nodeClassification.addRandomForest', + description: + 'Add a random forest configuration to the parameter space of the node classification train pipeline.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'pipelineName :: STRING', + name: 'pipelineName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'config :: MAP', + name: 'config', + type: 'MAP', + }, + ], + signature: + 'gds.beta.pipeline.nodeClassification.addRandomForest(pipelineName :: STRING, config :: MAP) :: (name :: STRING, nodePropertySteps :: LIST, featureProperties :: LIST, splitConfig :: MAP, autoTuningConfig :: MAP, parameterSpace :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodePropertySteps :: LIST', + name: 'nodePropertySteps', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'featureProperties :: LIST', + name: 'featureProperties', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'splitConfig :: MAP', + name: 'splitConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'autoTuningConfig :: MAP', + name: 'autoTuningConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'parameterSpace :: ANY', + name: 'parameterSpace', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.beta.pipeline.nodeClassification.configureSplit': { + name: 'gds.beta.pipeline.nodeClassification.configureSplit', + description: + 'Configures the split of the node classification training pipeline.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'pipelineName :: STRING', + name: 'pipelineName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.beta.pipeline.nodeClassification.configureSplit(pipelineName :: STRING, configuration :: MAP) :: (name :: STRING, nodePropertySteps :: LIST, featureProperties :: LIST, splitConfig :: MAP, autoTuningConfig :: MAP, parameterSpace :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodePropertySteps :: LIST', + name: 'nodePropertySteps', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'featureProperties :: LIST', + name: 'featureProperties', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'splitConfig :: MAP', + name: 'splitConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'autoTuningConfig :: MAP', + name: 'autoTuningConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'parameterSpace :: ANY', + name: 'parameterSpace', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.beta.pipeline.nodeClassification.create': { + name: 'gds.beta.pipeline.nodeClassification.create', + description: + 'Creates a node classification training pipeline in the pipeline catalog.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'pipelineName :: STRING', + name: 'pipelineName', + type: 'STRING', + }, + ], + signature: + 'gds.beta.pipeline.nodeClassification.create(pipelineName :: STRING) :: (name :: STRING, nodePropertySteps :: LIST, featureProperties :: LIST, splitConfig :: MAP, autoTuningConfig :: MAP, parameterSpace :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodePropertySteps :: LIST', + name: 'nodePropertySteps', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'featureProperties :: LIST', + name: 'featureProperties', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'splitConfig :: MAP', + name: 'splitConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'autoTuningConfig :: MAP', + name: 'autoTuningConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'parameterSpace :: ANY', + name: 'parameterSpace', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.beta.pipeline.nodeClassification.predict.mutate': { + name: 'gds.beta.pipeline.nodeClassification.predict.mutate', + description: + 'Predicts classes for all nodes based on a previously trained pipeline model', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.beta.pipeline.nodeClassification.predict.mutate(graphName :: STRING, configuration = {} :: MAP) :: (nodePropertiesWritten :: INTEGER, mutateMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.beta.pipeline.nodeClassification.predict.mutate.estimate': { + name: 'gds.beta.pipeline.nodeClassification.predict.mutate.estimate', + description: + 'Estimates memory for predicting classes for all nodes based on a previously trained pipeline model', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: ANY', + name: 'graphName', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.beta.pipeline.nodeClassification.predict.mutate.estimate(graphName :: ANY, configuration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.beta.pipeline.nodeClassification.predict.stream': { + name: 'gds.beta.pipeline.nodeClassification.predict.stream', + description: + 'Predicts classes for all nodes based on a previously trained pipeline model', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.beta.pipeline.nodeClassification.predict.stream(graphName :: STRING, configuration = {} :: MAP) :: (nodeId :: INTEGER, predictedClass :: INTEGER, predictedProbabilities :: LIST)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeId :: INTEGER', + name: 'nodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'predictedClass :: INTEGER', + name: 'predictedClass', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'predictedProbabilities :: LIST', + name: 'predictedProbabilities', + type: 'LIST', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.beta.pipeline.nodeClassification.predict.stream.estimate': { + name: 'gds.beta.pipeline.nodeClassification.predict.stream.estimate', + description: + 'Estimates memory for predicting classes for all nodes based on a previously trained pipeline model', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: ANY', + name: 'graphName', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.beta.pipeline.nodeClassification.predict.stream.estimate(graphName :: ANY, configuration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.beta.pipeline.nodeClassification.predict.write': { + name: 'gds.beta.pipeline.nodeClassification.predict.write', + description: + 'Predicts classes for all nodes based on a previously trained pipeline model', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.beta.pipeline.nodeClassification.predict.write(graphName :: STRING, configuration = {} :: MAP) :: (nodePropertiesWritten :: INTEGER, writeMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.beta.pipeline.nodeClassification.predict.write.estimate': { + name: 'gds.beta.pipeline.nodeClassification.predict.write.estimate', + description: + 'Estimates memory for predicting classes for all nodes based on a previously trained pipeline model', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.beta.pipeline.nodeClassification.predict.write.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.beta.pipeline.nodeClassification.selectFeatures': { + name: 'gds.beta.pipeline.nodeClassification.selectFeatures', + description: + 'Add one or several features to an existing node classification training pipeline.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'pipelineName :: STRING', + name: 'pipelineName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodeProperties :: ANY', + name: 'nodeProperties', + type: 'ANY', + }, + ], + signature: + 'gds.beta.pipeline.nodeClassification.selectFeatures(pipelineName :: STRING, nodeProperties :: ANY) :: (name :: STRING, nodePropertySteps :: LIST, featureProperties :: LIST, splitConfig :: MAP, autoTuningConfig :: MAP, parameterSpace :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodePropertySteps :: LIST', + name: 'nodePropertySteps', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'featureProperties :: LIST', + name: 'featureProperties', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'splitConfig :: MAP', + name: 'splitConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'autoTuningConfig :: MAP', + name: 'autoTuningConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'parameterSpace :: ANY', + name: 'parameterSpace', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.beta.pipeline.nodeClassification.train': { + name: 'gds.beta.pipeline.nodeClassification.train', + description: 'Trains a node classification model based on a pipeline', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.beta.pipeline.nodeClassification.train(graphName :: STRING, configuration = {} :: MAP) :: (modelSelectionStats :: MAP, trainMillis :: INTEGER, modelInfo :: MAP, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'modelSelectionStats :: MAP', + name: 'modelSelectionStats', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'trainMillis :: INTEGER', + name: 'trainMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'modelInfo :: MAP', + name: 'modelInfo', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.beta.pipeline.nodeClassification.train.estimate': { + name: 'gds.beta.pipeline.nodeClassification.train.estimate', + description: + 'Estimates memory for training a node classification model based on a pipeline', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.beta.pipeline.nodeClassification.train.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.betweenness.mutate': { + name: 'gds.betweenness.mutate', + description: + 'Betweenness centrality measures the relative information flow that passes through a node.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.betweenness.mutate(graphName :: STRING, configuration = {} :: MAP) :: (nodePropertiesWritten :: INTEGER, mutateMillis :: INTEGER, centralityDistribution :: MAP, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'centralityDistribution :: MAP', + name: 'centralityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.betweenness.mutate.estimate': { + name: 'gds.betweenness.mutate.estimate', + description: + 'Betweenness centrality measures the relative information flow that passes through a node.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.betweenness.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.betweenness.stats': { + name: 'gds.betweenness.stats', + description: + 'Betweenness centrality measures the relative information flow that passes through a node.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.betweenness.stats(graphName :: STRING, configuration = {} :: MAP) :: (centralityDistribution :: MAP, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'centralityDistribution :: MAP', + name: 'centralityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.betweenness.stats.estimate': { + name: 'gds.betweenness.stats.estimate', + description: + 'Betweenness centrality measures the relative information flow that passes through a node.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.betweenness.stats.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.betweenness.stream': { + name: 'gds.betweenness.stream', + description: + 'Betweenness centrality measures the relative information flow that passes through a node.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.betweenness.stream(graphName :: STRING, configuration = {} :: MAP) :: (nodeId :: INTEGER, score :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeId :: INTEGER', + name: 'nodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'score :: FLOAT', + name: 'score', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.betweenness.stream.estimate': { + name: 'gds.betweenness.stream.estimate', + description: + 'Betweenness centrality measures the relative information flow that passes through a node.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.betweenness.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.betweenness.write': { + name: 'gds.betweenness.write', + description: + 'Betweenness centrality measures the relative information flow that passes through a node.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.betweenness.write(graphName :: STRING, configuration = {} :: MAP) :: (nodePropertiesWritten :: INTEGER, writeMillis :: INTEGER, centralityDistribution :: MAP, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'centralityDistribution :: MAP', + name: 'centralityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.betweenness.write.estimate': { + name: 'gds.betweenness.write.estimate', + description: + 'Betweenness centrality measures the relative information flow that passes through a node.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.betweenness.write.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.bfs.mutate': { + name: 'gds.bfs.mutate', + description: + 'BFS is a traversal algorithm, which explores all of the neighbor nodes at the present depth prior to moving on to the nodes at the next depth level.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.bfs.mutate(graphName :: STRING, configuration = {} :: MAP) :: (relationshipsWritten :: INTEGER, mutateMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'relationshipsWritten :: INTEGER', + name: 'relationshipsWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.bfs.mutate.estimate': { + name: 'gds.bfs.mutate.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.bfs.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.bfs.stats': { + name: 'gds.bfs.stats', + description: + 'BFS is a traversal algorithm, which explores all of the neighbor nodes at the present depth prior to moving on to the nodes at the next depth level.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.bfs.stats(graphName :: STRING, configuration = {} :: MAP) :: (postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.bfs.stats.estimate': { + name: 'gds.bfs.stats.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.bfs.stats.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.bfs.stream': { + name: 'gds.bfs.stream', + description: + 'BFS is a traversal algorithm, which explores all of the neighbor nodes at the present depth prior to moving on to the nodes at the next depth level.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.bfs.stream(graphName :: STRING, configuration = {} :: MAP) :: (sourceNode :: INTEGER, nodeIds :: LIST, path :: PATH)', + returnDescription: [ + { + isDeprecated: false, + description: 'sourceNode :: INTEGER', + name: 'sourceNode', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeIds :: LIST', + name: 'nodeIds', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'path :: PATH', + name: 'path', + type: 'PATH', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.bfs.stream.estimate': { + name: 'gds.bfs.stream.estimate', + description: + 'BFS is a traversal algorithm, which explores all of the neighbor nodes at the present depth prior to moving on to the nodes at the next depth level.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: ANY', + name: 'graphName', + type: 'ANY', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.bfs.stream.estimate(graphName :: ANY, configuration = {} :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.closeness.harmonic.mutate': { + name: 'gds.closeness.harmonic.mutate', + description: + 'Harmonic centrality is a way of detecting nodes that are able to spread information very efficiently through a graph.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.closeness.harmonic.mutate(graphName :: STRING, configuration = {} :: MAP) :: (nodePropertiesWritten :: INTEGER, centralityDistribution :: MAP, mutateMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'centralityDistribution :: MAP', + name: 'centralityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.closeness.harmonic.stats': { + name: 'gds.closeness.harmonic.stats', + description: + 'Harmonic centrality is a way of detecting nodes that are able to spread information very efficiently through a graph.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.closeness.harmonic.stats(graphName :: STRING, configuration = {} :: MAP) :: (centralityDistribution :: MAP, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'centralityDistribution :: MAP', + name: 'centralityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.closeness.harmonic.stream': { + name: 'gds.closeness.harmonic.stream', + description: + 'Harmonic centrality is a way of detecting nodes that are able to spread information very efficiently through a graph.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.closeness.harmonic.stream(graphName :: STRING, configuration = {} :: MAP) :: (nodeId :: INTEGER, score :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeId :: INTEGER', + name: 'nodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'score :: FLOAT', + name: 'score', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.closeness.harmonic.write': { + name: 'gds.closeness.harmonic.write', + description: + 'Harmonic centrality is a way of detecting nodes that are able to spread information very efficiently through a graph.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.closeness.harmonic.write(graphName :: STRING, configuration = {} :: MAP) :: (nodePropertiesWritten :: INTEGER, writeMillis :: INTEGER, centralityDistribution :: MAP, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'centralityDistribution :: MAP', + name: 'centralityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.closeness.mutate': { + name: 'gds.closeness.mutate', + description: + 'Closeness centrality is a way of detecting nodes that are able to spread information very efficiently through a graph.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.closeness.mutate(graphName :: STRING, configuration = {} :: MAP) :: (nodePropertiesWritten :: INTEGER, centralityDistribution :: MAP, mutateMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'centralityDistribution :: MAP', + name: 'centralityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.closeness.stats': { + name: 'gds.closeness.stats', + description: + 'Closeness centrality is a way of detecting nodes that are able to spread information very efficiently through a graph.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.closeness.stats(graphName :: STRING, configuration = {} :: MAP) :: (centralityDistribution :: MAP, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'centralityDistribution :: MAP', + name: 'centralityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.closeness.stream': { + name: 'gds.closeness.stream', + description: + 'Closeness centrality is a way of detecting nodes that are able to spread information very efficiently through a graph.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.closeness.stream(graphName :: STRING, configuration = {} :: MAP) :: (nodeId :: INTEGER, score :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeId :: INTEGER', + name: 'nodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'score :: FLOAT', + name: 'score', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.closeness.write': { + name: 'gds.closeness.write', + description: + 'Closeness centrality is a way of detecting nodes that are able to spread information very efficiently through a graph.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.closeness.write(graphName :: STRING, configuration = {} :: MAP) :: (nodePropertiesWritten :: INTEGER, centralityDistribution :: MAP, writeMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'centralityDistribution :: MAP', + name: 'centralityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.collapsePath.mutate': { + name: 'gds.collapsePath.mutate', + description: + 'Collapse Path algorithm is a traversal algorithm capable of creating relationships between the start and end nodes of a traversal', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.collapsePath.mutate(graphName :: STRING, configuration = {} :: MAP) :: (preProcessingMillis :: INTEGER, computeMillis :: INTEGER, mutateMillis :: INTEGER, relationshipsWritten :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipsWritten :: INTEGER', + name: 'relationshipsWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.conductance.stream': { + name: 'gds.conductance.stream', + description: + 'Evaluates a division of nodes into communities based on the proportion of relationships that cross community boundaries.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.conductance.stream(graphName :: STRING, configuration = {} :: MAP) :: (community :: INTEGER, conductance :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'community :: INTEGER', + name: 'community', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'conductance :: FLOAT', + name: 'conductance', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.config.defaults.list': { + name: 'gds.config.defaults.list', + description: + 'List defaults; global by default, but also optionally for a specific user and/ or key', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'parameters = {} :: MAP', + name: 'parameters', + type: 'MAP', + }, + ], + signature: + 'gds.config.defaults.list(parameters = {} :: MAP) :: (key :: STRING, value :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'key :: STRING', + name: 'key', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.config.defaults.set': { + name: 'gds.config.defaults.set', + description: + 'Set a default; global by, default, but also optionally for a specific user', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'key :: STRING', + name: 'key', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', + }, + { + isDeprecated: false, + default: + 'DefaultParameterValue{value=d81eb72e-c499-4f78-90c7-0c76123606a2, type=STRING}', + description: + 'username = d81eb72e-c499-4f78-90c7-0c76123606a2 :: STRING', + name: 'username', + type: 'STRING', + }, + ], + signature: + 'gds.config.defaults.set(key :: STRING, value :: ANY, username = d81eb72e-c499-4f78-90c7-0c76123606a2 :: STRING)', + returnDescription: [], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.config.limits.list': { + name: 'gds.config.limits.list', + description: + 'List limits; global by default, but also optionally for a specific user and/ or key', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'parameters = {} :: MAP', + name: 'parameters', + type: 'MAP', + }, + ], + signature: + 'gds.config.limits.list(parameters = {} :: MAP) :: (key :: STRING, value :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'key :: STRING', + name: 'key', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.config.limits.set': { + name: 'gds.config.limits.set', + description: + 'Set a limit; global by, default, but also optionally for a specific user', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'key :: STRING', + name: 'key', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', + }, + { + isDeprecated: false, + default: + 'DefaultParameterValue{value=d81eb72e-c499-4f78-90c7-0c76123606a2, type=STRING}', + description: + 'username = d81eb72e-c499-4f78-90c7-0c76123606a2 :: STRING', + name: 'username', + type: 'STRING', + }, + ], + signature: + 'gds.config.limits.set(key :: STRING, value :: ANY, username = d81eb72e-c499-4f78-90c7-0c76123606a2 :: STRING)', + returnDescription: [], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.dag.longestPath.stream': { + name: 'gds.dag.longestPath.stream', + description: 'Returns the longest paths ending in given target nodes', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.dag.longestPath.stream(graphName :: STRING, configuration = {} :: MAP) :: (index :: INTEGER, sourceNode :: INTEGER, targetNode :: INTEGER, totalCost :: FLOAT, nodeIds :: LIST, costs :: LIST, path :: PATH)', + returnDescription: [ + { + isDeprecated: false, + description: 'index :: INTEGER', + name: 'index', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'sourceNode :: INTEGER', + name: 'sourceNode', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'targetNode :: INTEGER', + name: 'targetNode', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'totalCost :: FLOAT', + name: 'totalCost', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'nodeIds :: LIST', + name: 'nodeIds', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'costs :: LIST', + name: 'costs', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'path :: PATH', + name: 'path', + type: 'PATH', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.dag.topologicalSort.stream': { + name: 'gds.dag.topologicalSort.stream', + description: + 'Returns all the nodes in the graph that are not part of a cycle or depend on a cycle, sorted in a topological order', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.dag.topologicalSort.stream(graphName :: STRING, configuration = {} :: MAP) :: (nodeId :: INTEGER, maxDistanceFromSource :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeId :: INTEGER', + name: 'nodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'maxDistanceFromSource :: FLOAT', + name: 'maxDistanceFromSource', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.debug.arrow': { + name: 'gds.debug.arrow', + description: 'Returns details about the status of the GDS Flight server', + mode: 'DEFAULT', + worksOnSystem: true, + argumentDescription: [], + signature: + 'gds.debug.arrow() :: (running :: BOOLEAN, enabled :: BOOLEAN, listenAddress :: STRING, advertisedListenAddress :: STRING, serverLocation :: STRING, batchSize :: INTEGER, abortionTimeout :: DURATION)', + returnDescription: [ + { + isDeprecated: false, + description: 'running :: BOOLEAN', + name: 'running', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'enabled :: BOOLEAN', + name: 'enabled', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'listenAddress :: STRING', + name: 'listenAddress', + type: 'STRING', + }, + { + isDeprecated: true, + description: 'advertisedListenAddress :: STRING', + name: 'advertisedListenAddress', + type: 'STRING', + }, + { + isDeprecated: true, + description: 'serverLocation :: STRING', + name: 'serverLocation', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'batchSize :: INTEGER', + name: 'batchSize', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'abortionTimeout :: DURATION', + name: 'abortionTimeout', + type: 'DURATION', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.debug.sysInfo': { + name: 'gds.debug.sysInfo', + description: 'Returns details about the status of the system', + mode: 'DEFAULT', + worksOnSystem: true, + argumentDescription: [], + signature: 'gds.debug.sysInfo() :: (key :: STRING, value :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'key :: STRING', + name: 'key', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'value :: ANY', + name: 'value', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.degree.mutate': { + name: 'gds.degree.mutate', + description: + 'Degree centrality measures the number of incoming and outgoing relationships from a node.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.degree.mutate(graphName :: STRING, configuration = {} :: MAP) :: (nodePropertiesWritten :: INTEGER, centralityDistribution :: MAP, mutateMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'centralityDistribution :: MAP', + name: 'centralityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.degree.mutate.estimate': { + name: 'gds.degree.mutate.estimate', + description: + 'Degree centrality measures the number of incoming and outgoing relationships from a node.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.degree.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.degree.stats': { + name: 'gds.degree.stats', + description: + 'Degree centrality measures the number of incoming and outgoing relationships from a node.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.degree.stats(graphName :: STRING, configuration = {} :: MAP) :: (centralityDistribution :: MAP, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'centralityDistribution :: MAP', + name: 'centralityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.degree.stats.estimate': { + name: 'gds.degree.stats.estimate', + description: + 'Degree centrality measures the number of incoming and outgoing relationships from a node.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.degree.stats.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.degree.stream': { + name: 'gds.degree.stream', + description: + 'Degree centrality measures the number of incoming and outgoing relationships from a node.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.degree.stream(graphName :: STRING, configuration = {} :: MAP) :: (nodeId :: INTEGER, score :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeId :: INTEGER', + name: 'nodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'score :: FLOAT', + name: 'score', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.degree.stream.estimate': { + name: 'gds.degree.stream.estimate', + description: + 'Degree centrality measures the number of incoming and outgoing relationships from a node.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.degree.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.degree.write': { + name: 'gds.degree.write', + description: + 'Degree centrality measures the number of incoming and outgoing relationships from a node.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.degree.write(graphName :: STRING, configuration = {} :: MAP) :: (nodePropertiesWritten :: INTEGER, centralityDistribution :: MAP, writeMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'centralityDistribution :: MAP', + name: 'centralityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.degree.write.estimate': { + name: 'gds.degree.write.estimate', + description: + 'Degree centrality measures the number of incoming and outgoing relationships from a node.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.degree.write.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.dfs.mutate': { + name: 'gds.dfs.mutate', + description: + 'Depth-first search (DFS) is an algorithm for traversing or searching tree or graph data structures. The algorithm starts at the root node (selecting some arbitrary node as the root node in the case of a graph) and explores as far as possible along each branch before backtracking.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.dfs.mutate(graphName :: STRING, configuration = {} :: MAP) :: (relationshipsWritten :: INTEGER, mutateMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'relationshipsWritten :: INTEGER', + name: 'relationshipsWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.dfs.mutate.estimate': { + name: 'gds.dfs.mutate.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.dfs.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.dfs.stream': { + name: 'gds.dfs.stream', + description: + 'Depth-first search (DFS) is an algorithm for traversing or searching tree or graph data structures. The algorithm starts at the root node (selecting some arbitrary node as the root node in the case of a graph) and explores as far as possible along each branch before backtracking.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.dfs.stream(graphName :: STRING, configuration = {} :: MAP) :: (sourceNode :: INTEGER, nodeIds :: LIST, path :: PATH)', + returnDescription: [ + { + isDeprecated: false, + description: 'sourceNode :: INTEGER', + name: 'sourceNode', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeIds :: LIST', + name: 'nodeIds', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'path :: PATH', + name: 'path', + type: 'PATH', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.dfs.stream.estimate': { + name: 'gds.dfs.stream.estimate', + description: + 'Depth-first search (DFS) is an algorithm for traversing or searching tree or graph data structures. The algorithm starts at the root node (selecting some arbitrary node as the root node in the case of a graph) and explores as far as possible along each branch before backtracking.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: ANY', + name: 'graphName', + type: 'ANY', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.dfs.stream.estimate(graphName :: ANY, configuration = {} :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.eigenvector.mutate': { + name: 'gds.eigenvector.mutate', + description: + 'Eigenvector Centrality is an algorithm that measures the transitive influence or connectivity of nodes.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.eigenvector.mutate(graphName :: STRING, configuration = {} :: MAP) :: (mutateMillis :: INTEGER, nodePropertiesWritten :: INTEGER, ranIterations :: INTEGER, didConverge :: BOOLEAN, centralityDistribution :: MAP, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'ranIterations :: INTEGER', + name: 'ranIterations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'didConverge :: BOOLEAN', + name: 'didConverge', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'centralityDistribution :: MAP', + name: 'centralityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.eigenvector.mutate.estimate': { + name: 'gds.eigenvector.mutate.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.eigenvector.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.eigenvector.stats': { + name: 'gds.eigenvector.stats', + description: + 'Eigenvector Centrality is an algorithm that measures the transitive influence or connectivity of nodes.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.eigenvector.stats(graphName :: STRING, configuration = {} :: MAP) :: (ranIterations :: INTEGER, didConverge :: BOOLEAN, centralityDistribution :: MAP, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'ranIterations :: INTEGER', + name: 'ranIterations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'didConverge :: BOOLEAN', + name: 'didConverge', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'centralityDistribution :: MAP', + name: 'centralityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.eigenvector.stats.estimate': { + name: 'gds.eigenvector.stats.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.eigenvector.stats.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.eigenvector.stream': { + name: 'gds.eigenvector.stream', + description: + 'Eigenvector Centrality is an algorithm that measures the transitive influence or connectivity of nodes.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.eigenvector.stream(graphName :: STRING, configuration = {} :: MAP) :: (nodeId :: INTEGER, score :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeId :: INTEGER', + name: 'nodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'score :: FLOAT', + name: 'score', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.eigenvector.stream.estimate': { + name: 'gds.eigenvector.stream.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.eigenvector.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.eigenvector.write': { + name: 'gds.eigenvector.write', + description: + 'Eigenvector Centrality is an algorithm that measures the transitive influence or connectivity of nodes.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.eigenvector.write(graphName :: STRING, configuration = {} :: MAP) :: (writeMillis :: INTEGER, nodePropertiesWritten :: INTEGER, ranIterations :: INTEGER, didConverge :: BOOLEAN, centralityDistribution :: MAP, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'ranIterations :: INTEGER', + name: 'ranIterations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'didConverge :: BOOLEAN', + name: 'didConverge', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'centralityDistribution :: MAP', + name: 'centralityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.eigenvector.write.estimate': { + name: 'gds.eigenvector.write.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.eigenvector.write.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.ephemeral.database.create': { + name: 'gds.ephemeral.database.create', + description: 'Creates an ephemeral database from a GDS graph.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'dbName :: STRING', + name: 'dbName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + ], + signature: + 'gds.ephemeral.database.create(dbName :: STRING, graphName :: STRING) :: (dbName :: STRING, graphName :: STRING, createMillis :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'dbName :: STRING', + name: 'dbName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'createMillis :: INTEGER', + name: 'createMillis', + type: 'INTEGER', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.ephemeral.database.drop': { + name: 'gds.ephemeral.database.drop', + description: 'Drop an ephemeral database backed by an in-memory graph', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'dbName :: STRING', + name: 'dbName', + type: 'STRING', + }, + ], + signature: + 'gds.ephemeral.database.drop(dbName :: STRING) :: (dbName :: STRING, dropMillis :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'dbName :: STRING', + name: 'dbName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'dropMillis :: INTEGER', + name: 'dropMillis', + type: 'INTEGER', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.fastRP.mutate': { + name: 'gds.fastRP.mutate', + description: + 'Random Projection produces node embeddings via the fastrp algorithm', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.fastRP.mutate(graphName :: STRING, configuration = {} :: MAP) :: (nodePropertiesWritten :: INTEGER, mutateMillis :: INTEGER, nodeCount :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.fastRP.mutate.estimate': { + name: 'gds.fastRP.mutate.estimate', + description: + 'Random Projection produces node embeddings via the fastrp algorithm', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.fastRP.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.fastRP.stats': { + name: 'gds.fastRP.stats', + description: + 'Random Projection produces node embeddings via the fastrp algorithm', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.fastRP.stats(graphName :: STRING, configuration = {} :: MAP) :: (nodeCount :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.fastRP.stats.estimate': { + name: 'gds.fastRP.stats.estimate', + description: + 'Random Projection produces node embeddings via the fastrp algorithm', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.fastRP.stats.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.fastRP.stream': { + name: 'gds.fastRP.stream', + description: + 'Random Projection produces node embeddings via the fastrp algorithm', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.fastRP.stream(graphName :: STRING, configuration = {} :: MAP) :: (nodeId :: INTEGER, embedding :: LIST)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeId :: INTEGER', + name: 'nodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'embedding :: LIST', + name: 'embedding', + type: 'LIST', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.fastRP.stream.estimate': { + name: 'gds.fastRP.stream.estimate', + description: + 'Random Projection produces node embeddings via the fastrp algorithm', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.fastRP.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.fastRP.write': { + name: 'gds.fastRP.write', + description: + 'Random Projection produces node embeddings via the fastrp algorithm', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.fastRP.write(graphName :: STRING, configuration = {} :: MAP) :: (nodeCount :: INTEGER, nodePropertiesWritten :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, writeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.fastRP.write.estimate': { + name: 'gds.fastRP.write.estimate', + description: + 'Random Projection produces node embeddings via the fastrp algorithm', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.fastRP.write.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.graph.drop': { + name: 'gds.graph.drop', + description: + 'Drops a named graph from the catalog and frees up the resources it occupies.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: ANY', + name: 'graphName', + type: 'ANY', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=true, type=BOOLEAN}', + description: 'failIfMissing = true :: BOOLEAN', + name: 'failIfMissing', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'dbName = :: STRING', + name: 'dbName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'username = :: STRING', + name: 'username', + type: 'STRING', + }, + ], + signature: + 'gds.graph.drop(graphName :: ANY, failIfMissing = true :: BOOLEAN, dbName = :: STRING, username = :: STRING) :: (graphName :: STRING, database :: STRING, memoryUsage :: STRING, sizeInBytes :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, configuration :: MAP, density :: FLOAT, creationTime :: ZONED DATETIME, modificationTime :: ZONED DATETIME, schema :: MAP, schemaWithOrientation :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'database :: STRING', + name: 'database', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'memoryUsage :: STRING', + name: 'memoryUsage', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'sizeInBytes :: INTEGER', + name: 'sizeInBytes', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'density :: FLOAT', + name: 'density', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'creationTime :: ZONED DATETIME', + name: 'creationTime', + type: 'ZONED DATETIME', + }, + { + isDeprecated: false, + description: 'modificationTime :: ZONED DATETIME', + name: 'modificationTime', + type: 'ZONED DATETIME', + }, + { + isDeprecated: true, + description: 'schema :: MAP', + name: 'schema', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'schemaWithOrientation :: MAP', + name: 'schemaWithOrientation', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.graph.exists': { + name: 'gds.graph.exists', + description: 'Checks if a graph exists in the catalog.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + ], + signature: + 'gds.graph.exists(graphName :: STRING) :: (graphName :: STRING, exists :: BOOLEAN)', + returnDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'exists :: BOOLEAN', + name: 'exists', + type: 'BOOLEAN', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.graph.export': { + name: 'gds.graph.export', + description: 'Exports a named graph into a new offline Neo4j database.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.graph.export(graphName :: STRING, configuration = {} :: MAP) :: (dbName :: STRING, graphName :: STRING, nodeCount :: INTEGER, relationshipCount :: INTEGER, relationshipTypeCount :: INTEGER, nodePropertyCount :: INTEGER, relationshipPropertyCount :: INTEGER, writeMillis :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'dbName :: STRING', + name: 'dbName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipTypeCount :: INTEGER', + name: 'relationshipTypeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodePropertyCount :: INTEGER', + name: 'nodePropertyCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipPropertyCount :: INTEGER', + name: 'relationshipPropertyCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.graph.export.csv': { + name: 'gds.graph.export.csv', + description: 'Exports a named graph to CSV files.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.graph.export.csv(graphName :: STRING, configuration = {} :: MAP) :: (exportName :: STRING, graphName :: STRING, nodeCount :: INTEGER, relationshipCount :: INTEGER, relationshipTypeCount :: INTEGER, nodePropertyCount :: INTEGER, relationshipPropertyCount :: INTEGER, writeMillis :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'exportName :: STRING', + name: 'exportName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipTypeCount :: INTEGER', + name: 'relationshipTypeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodePropertyCount :: INTEGER', + name: 'nodePropertyCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipPropertyCount :: INTEGER', + name: 'relationshipPropertyCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.graph.export.csv.estimate': { + name: 'gds.graph.export.csv.estimate', + description: + 'Estimate the required disk space for exporting a named graph to CSV files.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.graph.export.csv.estimate(graphName :: STRING, configuration = {} :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.graph.filter': { + name: 'gds.graph.filter', + description: + 'Applies node and relationship predicates on a graph and stores the result as a new graph in the catalog.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'fromGraphName :: STRING', + name: 'fromGraphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodeFilter :: STRING', + name: 'nodeFilter', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'relationshipFilter :: STRING', + name: 'relationshipFilter', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.graph.filter(graphName :: STRING, fromGraphName :: STRING, nodeFilter :: STRING, relationshipFilter :: STRING, configuration = {} :: MAP) :: (fromGraphName :: STRING, nodeFilter :: STRING, relationshipFilter :: STRING, graphName :: STRING, nodeCount :: INTEGER, relationshipCount :: INTEGER, projectMillis :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'fromGraphName :: STRING', + name: 'fromGraphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodeFilter :: STRING', + name: 'nodeFilter', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'relationshipFilter :: STRING', + name: 'relationshipFilter', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'projectMillis :: INTEGER', + name: 'projectMillis', + type: 'INTEGER', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.graph.generate': { + name: 'gds.graph.generate', + description: + 'Computes a random graph, which will be stored in the graph catalog.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'averageDegree :: INTEGER', + name: 'averageDegree', + type: 'INTEGER', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.graph.generate(graphName :: STRING, nodeCount :: INTEGER, averageDegree :: INTEGER, configuration = {} :: MAP) :: (name :: STRING, nodes :: INTEGER, relationships :: INTEGER, generateMillis :: INTEGER, relationshipSeed :: INTEGER, averageDegree :: FLOAT, relationshipDistribution :: ANY, relationshipProperty :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodes :: INTEGER', + name: 'nodes', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationships :: INTEGER', + name: 'relationships', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'generateMillis :: INTEGER', + name: 'generateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipSeed :: INTEGER', + name: 'relationshipSeed', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'averageDegree :: FLOAT', + name: 'averageDegree', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'relationshipDistribution :: ANY', + name: 'relationshipDistribution', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'relationshipProperty :: ANY', + name: 'relationshipProperty', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.graph.graphProperty.drop': { + name: 'gds.graph.graphProperty.drop', + description: 'Removes a graph property from a projected graph.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'graphProperty :: STRING', + name: 'graphProperty', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.graph.graphProperty.drop(graphName :: STRING, graphProperty :: STRING, configuration = {} :: MAP) :: (graphName :: STRING, graphProperty :: STRING, propertiesRemoved :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'graphProperty :: STRING', + name: 'graphProperty', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'propertiesRemoved :: INTEGER', + name: 'propertiesRemoved', + type: 'INTEGER', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.graph.graphProperty.stream': { + name: 'gds.graph.graphProperty.stream', + description: 'Streams the given graph property.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'graphProperty :: STRING', + name: 'graphProperty', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.graph.graphProperty.stream(graphName :: STRING, graphProperty :: STRING, configuration = {} :: MAP) :: (propertyValue :: ANY)', + returnDescription: [ + { + isDeprecated: false, + description: 'propertyValue :: ANY', + name: 'propertyValue', + type: 'ANY', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.graph.list': { + name: 'gds.graph.list', + description: + 'Lists information about named graphs stored in the catalog.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + default: + 'DefaultParameterValue{value=d9b6394a-9482-4929-adab-f97df578a6c6, type=STRING}', + description: + 'graphName = d9b6394a-9482-4929-adab-f97df578a6c6 :: STRING', + name: 'graphName', + type: 'STRING', + }, + ], + signature: + 'gds.graph.list(graphName = d9b6394a-9482-4929-adab-f97df578a6c6 :: STRING) :: (degreeDistribution :: MAP, graphName :: STRING, database :: STRING, memoryUsage :: STRING, sizeInBytes :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, configuration :: MAP, density :: FLOAT, creationTime :: ZONED DATETIME, modificationTime :: ZONED DATETIME, schema :: MAP, schemaWithOrientation :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'degreeDistribution :: MAP', + name: 'degreeDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'database :: STRING', + name: 'database', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'memoryUsage :: STRING', + name: 'memoryUsage', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'sizeInBytes :: INTEGER', + name: 'sizeInBytes', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'density :: FLOAT', + name: 'density', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'creationTime :: ZONED DATETIME', + name: 'creationTime', + type: 'ZONED DATETIME', + }, + { + isDeprecated: false, + description: 'modificationTime :: ZONED DATETIME', + name: 'modificationTime', + type: 'ZONED DATETIME', + }, + { + isDeprecated: true, + description: 'schema :: MAP', + name: 'schema', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'schemaWithOrientation :: MAP', + name: 'schemaWithOrientation', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.graph.nodeLabel.mutate': { + name: 'gds.graph.nodeLabel.mutate', + description: 'Mutates the in-memory graph with the given node Label.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodeLabel :: STRING', + name: 'nodeLabel', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.graph.nodeLabel.mutate(graphName :: STRING, nodeLabel :: STRING, configuration :: MAP) :: (mutateMillis :: INTEGER, graphName :: STRING, nodeLabel :: STRING, nodeLabelsWritten :: INTEGER, nodeCount :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodeLabel :: STRING', + name: 'nodeLabel', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodeLabelsWritten :: INTEGER', + name: 'nodeLabelsWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.graph.nodeLabel.write': { + name: 'gds.graph.nodeLabel.write', + description: 'Writes the given node Label to an online Neo4j database.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodeLabel :: STRING', + name: 'nodeLabel', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.graph.nodeLabel.write(graphName :: STRING, nodeLabel :: STRING, configuration :: MAP) :: (writeMillis :: INTEGER, graphName :: STRING, nodeLabel :: STRING, nodeCount :: INTEGER, nodeLabelsWritten :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodeLabel :: STRING', + name: 'nodeLabel', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeLabelsWritten :: INTEGER', + name: 'nodeLabelsWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.graph.nodeProperties.drop': { + name: 'gds.graph.nodeProperties.drop', + description: 'Removes node properties from a projected graph.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodeProperties :: ANY', + name: 'nodeProperties', + type: 'ANY', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.graph.nodeProperties.drop(graphName :: STRING, nodeProperties :: ANY, configuration = {} :: MAP) :: (graphName :: STRING, nodeProperties :: LIST, propertiesRemoved :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodeProperties :: LIST', + name: 'nodeProperties', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'propertiesRemoved :: INTEGER', + name: 'propertiesRemoved', + type: 'INTEGER', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.graph.nodeProperties.stream': { + name: 'gds.graph.nodeProperties.stream', + description: 'Streams the given node properties.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodeProperties :: ANY', + name: 'nodeProperties', + type: 'ANY', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=[*], type=ANY}', + description: 'nodeLabels = [*] :: ANY', + name: 'nodeLabels', + type: 'ANY', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.graph.nodeProperties.stream(graphName :: STRING, nodeProperties :: ANY, nodeLabels = [*] :: ANY, configuration = {} :: MAP) :: (nodeId :: INTEGER, nodeProperty :: STRING, propertyValue :: ANY, nodeLabels :: LIST)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeId :: INTEGER', + name: 'nodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeProperty :: STRING', + name: 'nodeProperty', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'propertyValue :: ANY', + name: 'propertyValue', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'nodeLabels :: LIST', + name: 'nodeLabels', + type: 'LIST', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.graph.nodeProperties.write': { + name: 'gds.graph.nodeProperties.write', + description: + 'Writes the given node properties to an online Neo4j database.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodeProperties :: ANY', + name: 'nodeProperties', + type: 'ANY', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=[*], type=ANY}', + description: 'nodeLabels = [*] :: ANY', + name: 'nodeLabels', + type: 'ANY', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.graph.nodeProperties.write(graphName :: STRING, nodeProperties :: ANY, nodeLabels = [*] :: ANY, configuration = {} :: MAP) :: (writeMillis :: INTEGER, graphName :: STRING, nodeProperties :: LIST, propertiesWritten :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodeProperties :: LIST', + name: 'nodeProperties', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'propertiesWritten :: INTEGER', + name: 'propertiesWritten', + type: 'INTEGER', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.graph.nodeProperty.stream': { + name: 'gds.graph.nodeProperty.stream', + description: 'Streams the given node property.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodeProperties :: STRING', + name: 'nodeProperties', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=[*], type=ANY}', + description: 'nodeLabels = [*] :: ANY', + name: 'nodeLabels', + type: 'ANY', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.graph.nodeProperty.stream(graphName :: STRING, nodeProperties :: STRING, nodeLabels = [*] :: ANY, configuration = {} :: MAP) :: (nodeId :: INTEGER, propertyValue :: ANY, nodeLabels :: LIST)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeId :: INTEGER', + name: 'nodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'propertyValue :: ANY', + name: 'propertyValue', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'nodeLabels :: LIST', + name: 'nodeLabels', + type: 'LIST', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.graph.project': { + name: 'gds.graph.project', + description: + 'Creates a named graph in the catalog for use by algorithms.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodeProjection :: ANY', + name: 'nodeProjection', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'relationshipProjection :: ANY', + name: 'relationshipProjection', + type: 'ANY', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.graph.project(graphName :: STRING, nodeProjection :: ANY, relationshipProjection :: ANY, configuration = {} :: MAP) :: (nodeProjection :: MAP, relationshipProjection :: MAP, graphName :: STRING, nodeCount :: INTEGER, relationshipCount :: INTEGER, projectMillis :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeProjection :: MAP', + name: 'nodeProjection', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'relationshipProjection :: MAP', + name: 'relationshipProjection', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'projectMillis :: INTEGER', + name: 'projectMillis', + type: 'INTEGER', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.graph.project.cypher': { + name: 'gds.graph.project.cypher', + description: + 'Creates a named graph in the catalog for use by algorithms.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodeQuery :: STRING', + name: 'nodeQuery', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'relationshipQuery :: STRING', + name: 'relationshipQuery', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.graph.project.cypher(graphName :: STRING, nodeQuery :: STRING, relationshipQuery :: STRING, configuration = {} :: MAP) :: (nodeQuery :: STRING, relationshipQuery :: STRING, graphName :: STRING, nodeCount :: INTEGER, relationshipCount :: INTEGER, projectMillis :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeQuery :: STRING', + name: 'nodeQuery', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'relationshipQuery :: STRING', + name: 'relationshipQuery', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'projectMillis :: INTEGER', + name: 'projectMillis', + type: 'INTEGER', + }, + ], + admin: false, + option: { + deprecated: true, + }, + }, + 'gds.graph.project.cypher.estimate': { + name: 'gds.graph.project.cypher.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'nodeQuery :: STRING', + name: 'nodeQuery', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'relationshipQuery :: STRING', + name: 'relationshipQuery', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.graph.project.cypher.estimate(nodeQuery :: STRING, relationshipQuery :: STRING, configuration = {} :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: true, + }, + }, + 'gds.graph.project.estimate': { + name: 'gds.graph.project.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'nodeProjection :: ANY', + name: 'nodeProjection', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'relationshipProjection :: ANY', + name: 'relationshipProjection', + type: 'ANY', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.graph.project.estimate(nodeProjection :: ANY, relationshipProjection :: ANY, configuration = {} :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.graph.relationship.write': { + name: 'gds.graph.relationship.write', + description: + 'Writes the given relationship and an optional relationship property to an online Neo4j database.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'relationshipType :: STRING', + name: 'relationshipType', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'relationshipProperty = :: STRING', + name: 'relationshipProperty', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.graph.relationship.write(graphName :: STRING, relationshipType :: STRING, relationshipProperty = :: STRING, configuration = {} :: MAP) :: (writeMillis :: INTEGER, graphName :: STRING, relationshipType :: STRING, relationshipProperty :: STRING, relationshipsWritten :: INTEGER, propertiesWritten :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'relationshipType :: STRING', + name: 'relationshipType', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'relationshipProperty :: STRING', + name: 'relationshipProperty', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'relationshipsWritten :: INTEGER', + name: 'relationshipsWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'propertiesWritten :: INTEGER', + name: 'propertiesWritten', + type: 'INTEGER', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.graph.relationshipProperties.stream': { + name: 'gds.graph.relationshipProperties.stream', + description: 'Streams the given relationship properties.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'relationshipProperties :: LIST', + name: 'relationshipProperties', + type: 'LIST', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=[*], type=LIST}', + description: 'relationshipTypes = [*] :: LIST', + name: 'relationshipTypes', + type: 'LIST', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.graph.relationshipProperties.stream(graphName :: STRING, relationshipProperties :: LIST, relationshipTypes = [*] :: LIST, configuration = {} :: MAP) :: (sourceNodeId :: INTEGER, targetNodeId :: INTEGER, relationshipType :: STRING, relationshipProperty :: STRING, propertyValue :: INTEGER | FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'sourceNodeId :: INTEGER', + name: 'sourceNodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'targetNodeId :: INTEGER', + name: 'targetNodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipType :: STRING', + name: 'relationshipType', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'relationshipProperty :: STRING', + name: 'relationshipProperty', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'propertyValue :: INTEGER | FLOAT', + name: 'propertyValue', + type: 'INTEGER | FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.graph.relationshipProperties.write': { + name: 'gds.graph.relationshipProperties.write', + description: + 'Writes the given relationship and a list of relationship properties to an online Neo4j database.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'relationshipType :: STRING', + name: 'relationshipType', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'relationshipProperties :: LIST', + name: 'relationshipProperties', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.graph.relationshipProperties.write(graphName :: STRING, relationshipType :: STRING, relationshipProperties :: LIST, configuration :: MAP) :: (writeMillis :: INTEGER, graphName :: STRING, relationshipType :: STRING, relationshipProperties :: LIST, relationshipsWritten :: INTEGER, propertiesWritten :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'relationshipType :: STRING', + name: 'relationshipType', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'relationshipProperties :: LIST', + name: 'relationshipProperties', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'relationshipsWritten :: INTEGER', + name: 'relationshipsWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'propertiesWritten :: INTEGER', + name: 'propertiesWritten', + type: 'INTEGER', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.graph.relationshipProperty.stream': { + name: 'gds.graph.relationshipProperty.stream', + description: 'Streams the given relationship property.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'relationshipProperty :: STRING', + name: 'relationshipProperty', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=[*], type=LIST}', + description: 'relationshipTypes = [*] :: LIST', + name: 'relationshipTypes', + type: 'LIST', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.graph.relationshipProperty.stream(graphName :: STRING, relationshipProperty :: STRING, relationshipTypes = [*] :: LIST, configuration = {} :: MAP) :: (sourceNodeId :: INTEGER, targetNodeId :: INTEGER, relationshipType :: STRING, propertyValue :: INTEGER | FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'sourceNodeId :: INTEGER', + name: 'sourceNodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'targetNodeId :: INTEGER', + name: 'targetNodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipType :: STRING', + name: 'relationshipType', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'propertyValue :: INTEGER | FLOAT', + name: 'propertyValue', + type: 'INTEGER | FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.graph.relationships.drop': { + name: 'gds.graph.relationships.drop', + description: + 'Delete the relationship type for a given graph stored in the graph-catalog.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'relationshipType :: STRING', + name: 'relationshipType', + type: 'STRING', + }, + ], + signature: + 'gds.graph.relationships.drop(graphName :: STRING, relationshipType :: STRING) :: (graphName :: STRING, relationshipType :: STRING, deletedRelationships :: INTEGER, deletedProperties :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'relationshipType :: STRING', + name: 'relationshipType', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'deletedRelationships :: INTEGER', + name: 'deletedRelationships', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'deletedProperties :: MAP', + name: 'deletedProperties', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.graph.relationships.stream': { + name: 'gds.graph.relationships.stream', + description: 'Streams the given relationship source/target pairs', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=[*], type=LIST}', + description: 'relationshipTypes = [*] :: LIST', + name: 'relationshipTypes', + type: 'LIST', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.graph.relationships.stream(graphName :: STRING, relationshipTypes = [*] :: LIST, configuration = {} :: MAP) :: (sourceNodeId :: INTEGER, targetNodeId :: INTEGER, relationshipType :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'sourceNodeId :: INTEGER', + name: 'sourceNodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'targetNodeId :: INTEGER', + name: 'targetNodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipType :: STRING', + name: 'relationshipType', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.graph.relationships.toUndirected': { + name: 'gds.graph.relationships.toUndirected', + description: + 'The ToUndirected procedure converts directed relationships to undirected relationships', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.graph.relationships.toUndirected(graphName :: STRING, configuration = {} :: MAP) :: (inputRelationships :: INTEGER, relationshipsWritten :: INTEGER, mutateMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'inputRelationships :: INTEGER', + name: 'inputRelationships', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipsWritten :: INTEGER', + name: 'relationshipsWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.graph.relationships.toUndirected.estimate': { + name: 'gds.graph.relationships.toUndirected.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.graph.relationships.toUndirected.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.graph.sample.cnarw': { + name: 'gds.graph.sample.cnarw', + description: + 'Constructs a random subgraph based on common neighbour aware random walks', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'fromGraphName :: STRING', + name: 'fromGraphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.graph.sample.cnarw(graphName :: STRING, fromGraphName :: STRING, configuration = {} :: MAP) :: (fromGraphName :: STRING, startNodeCount :: INTEGER, graphName :: STRING, nodeCount :: INTEGER, relationshipCount :: INTEGER, projectMillis :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'fromGraphName :: STRING', + name: 'fromGraphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'startNodeCount :: INTEGER', + name: 'startNodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'projectMillis :: INTEGER', + name: 'projectMillis', + type: 'INTEGER', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.graph.sample.cnarw.estimate': { + name: 'gds.graph.sample.cnarw.estimate', + description: + 'Estimate memory requirements for sampling graph using CNARW algorithm', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'fromGraphName :: STRING', + name: 'fromGraphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.graph.sample.cnarw.estimate(fromGraphName :: STRING, configuration = {} :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.graph.sample.rwr': { + name: 'gds.graph.sample.rwr', + description: + 'Constructs a random subgraph based on random walks with restarts', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'fromGraphName :: STRING', + name: 'fromGraphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.graph.sample.rwr(graphName :: STRING, fromGraphName :: STRING, configuration = {} :: MAP) :: (fromGraphName :: STRING, startNodeCount :: INTEGER, graphName :: STRING, nodeCount :: INTEGER, relationshipCount :: INTEGER, projectMillis :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'fromGraphName :: STRING', + name: 'fromGraphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'startNodeCount :: INTEGER', + name: 'startNodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'projectMillis :: INTEGER', + name: 'projectMillis', + type: 'INTEGER', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.hashgnn.mutate': { + name: 'gds.hashgnn.mutate', + description: + 'HashGNN creates node embeddings by hashing and message passing.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.hashgnn.mutate(graphName :: STRING, configuration = {} :: MAP) :: (nodePropertiesWritten :: INTEGER, mutateMillis :: INTEGER, nodeCount :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.hashgnn.mutate.estimate': { + name: 'gds.hashgnn.mutate.estimate', + description: + 'HashGNN creates node embeddings by hashing and message passing.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.hashgnn.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.hashgnn.stream': { + name: 'gds.hashgnn.stream', + description: + 'HashGNN creates node embeddings by hashing and message passing.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.hashgnn.stream(graphName :: STRING, configuration = {} :: MAP) :: (nodeId :: INTEGER, embedding :: LIST)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeId :: INTEGER', + name: 'nodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'embedding :: LIST', + name: 'embedding', + type: 'LIST', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.hashgnn.stream.estimate': { + name: 'gds.hashgnn.stream.estimate', + description: + 'HashGNN creates node embeddings by hashing and message passing.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.hashgnn.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.hits.mutate': { + name: 'gds.hits.mutate', + description: + 'Hyperlink-Induced Topic Search (HITS) is a link analysis algorithm that rates nodes', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.hits.mutate(graphName :: STRING, configuration = {} :: MAP) :: (nodePropertiesWritten :: INTEGER, ranIterations :: INTEGER, didConverge :: BOOLEAN, mutateMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'ranIterations :: INTEGER', + name: 'ranIterations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'didConverge :: BOOLEAN', + name: 'didConverge', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.hits.mutate.estimate': { + name: 'gds.hits.mutate.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.hits.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.hits.stats': { + name: 'gds.hits.stats', + description: + 'Hyperlink-Induced Topic Search (HITS) is a link analysis algorithm that rates nodes', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.hits.stats(graphName :: STRING, configuration = {} :: MAP) :: (ranIterations :: INTEGER, didConverge :: BOOLEAN, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'ranIterations :: INTEGER', + name: 'ranIterations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'didConverge :: BOOLEAN', + name: 'didConverge', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.hits.stats.estimate': { + name: 'gds.hits.stats.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.hits.stats.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.hits.stream': { + name: 'gds.hits.stream', + description: + 'Hyperlink-Induced Topic Search (HITS) is a link analysis algorithm that rates nodes', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.hits.stream(graphName :: STRING, configuration = {} :: MAP) :: (nodeId :: INTEGER, values :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeId :: INTEGER', + name: 'nodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'values :: MAP', + name: 'values', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.hits.stream.estimate': { + name: 'gds.hits.stream.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.hits.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.hits.write': { + name: 'gds.hits.write', + description: + 'Hyperlink-Induced Topic Search (HITS) is a link analysis algorithm that rates nodes', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.hits.write(graphName :: STRING, configuration = {} :: MAP) :: (nodePropertiesWritten :: INTEGER, ranIterations :: INTEGER, didConverge :: BOOLEAN, writeMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'ranIterations :: INTEGER', + name: 'ranIterations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'didConverge :: BOOLEAN', + name: 'didConverge', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.hits.write.estimate': { + name: 'gds.hits.write.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.hits.write.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.influenceMaximization.celf.mutate': { + name: 'gds.influenceMaximization.celf.mutate', + description: + 'The Cost Effective Lazy Forward (CELF) algorithm aims to find k nodes that maximize the expected spread of influence in the network.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.influenceMaximization.celf.mutate(graphName :: STRING, configuration = {} :: MAP) :: (mutateMillis :: INTEGER, nodePropertiesWritten :: INTEGER, computeMillis :: INTEGER, totalSpread :: FLOAT, nodeCount :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'totalSpread :: FLOAT', + name: 'totalSpread', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.influenceMaximization.celf.mutate.estimate': { + name: 'gds.influenceMaximization.celf.mutate.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.influenceMaximization.celf.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.influenceMaximization.celf.stats': { + name: 'gds.influenceMaximization.celf.stats', + description: + 'Executes the algorithm and returns result statistics without writing the result to Neo4j.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.influenceMaximization.celf.stats(graphName :: STRING, configuration = {} :: MAP) :: (computeMillis :: INTEGER, totalSpread :: FLOAT, nodeCount :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'totalSpread :: FLOAT', + name: 'totalSpread', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.influenceMaximization.celf.stats.estimate': { + name: 'gds.influenceMaximization.celf.stats.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.influenceMaximization.celf.stats.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.influenceMaximization.celf.stream': { + name: 'gds.influenceMaximization.celf.stream', + description: + 'The Cost Effective Lazy Forward (CELF) algorithm aims to find k nodes that maximize the expected spread of influence in the network.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.influenceMaximization.celf.stream(graphName :: STRING, configuration = {} :: MAP) :: (nodeId :: INTEGER, spread :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeId :: INTEGER', + name: 'nodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'spread :: FLOAT', + name: 'spread', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.influenceMaximization.celf.stream.estimate': { + name: 'gds.influenceMaximization.celf.stream.estimate', + description: + 'The Cost Effective Lazy Forward (CELF) algorithm aims to find k nodes that maximize the expected spread of influence in the network.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: ANY', + name: 'graphName', + type: 'ANY', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.influenceMaximization.celf.stream.estimate(graphName :: ANY, configuration = {} :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.influenceMaximization.celf.write': { + name: 'gds.influenceMaximization.celf.write', + description: + 'The Cost Effective Lazy Forward (CELF) algorithm aims to find k nodes that maximize the expected spread of influence in the network.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.influenceMaximization.celf.write(graphName :: STRING, configuration = {} :: MAP) :: (writeMillis :: INTEGER, nodePropertiesWritten :: INTEGER, computeMillis :: INTEGER, totalSpread :: FLOAT, nodeCount :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'totalSpread :: FLOAT', + name: 'totalSpread', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.influenceMaximization.celf.write.estimate': { + name: 'gds.influenceMaximization.celf.write.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.influenceMaximization.celf.write.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.k1coloring.mutate': { + name: 'gds.k1coloring.mutate', + description: + 'The K-1 Coloring algorithm assigns a color to every node in the graph.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.k1coloring.mutate(graphName :: STRING, configuration = {} :: MAP) :: (preProcessingMillis :: INTEGER, computeMillis :: INTEGER, mutateMillis :: INTEGER, nodeCount :: INTEGER, colorCount :: INTEGER, ranIterations :: INTEGER, didConverge :: BOOLEAN, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'colorCount :: INTEGER', + name: 'colorCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'ranIterations :: INTEGER', + name: 'ranIterations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'didConverge :: BOOLEAN', + name: 'didConverge', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.k1coloring.mutate.estimate': { + name: 'gds.k1coloring.mutate.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.k1coloring.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.k1coloring.stats': { + name: 'gds.k1coloring.stats', + description: + 'The K-1 Coloring algorithm assigns a color to every node in the graph.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.k1coloring.stats(graphName :: STRING, configuration = {} :: MAP) :: (preProcessingMillis :: INTEGER, computeMillis :: INTEGER, nodeCount :: INTEGER, colorCount :: INTEGER, ranIterations :: INTEGER, didConverge :: BOOLEAN, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'colorCount :: INTEGER', + name: 'colorCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'ranIterations :: INTEGER', + name: 'ranIterations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'didConverge :: BOOLEAN', + name: 'didConverge', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.k1coloring.stats.estimate': { + name: 'gds.k1coloring.stats.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.k1coloring.stats.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.k1coloring.stream': { + name: 'gds.k1coloring.stream', + description: + 'The K-1 Coloring algorithm assigns a color to every node in the graph.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.k1coloring.stream(graphName :: STRING, configuration = {} :: MAP) :: (nodeId :: INTEGER, color :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeId :: INTEGER', + name: 'nodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'color :: INTEGER', + name: 'color', + type: 'INTEGER', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.k1coloring.stream.estimate': { + name: 'gds.k1coloring.stream.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.k1coloring.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.k1coloring.write': { + name: 'gds.k1coloring.write', + description: + 'The K-1 Coloring algorithm assigns a color to every node in the graph.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.k1coloring.write(graphName :: STRING, configuration = {} :: MAP) :: (preProcessingMillis :: INTEGER, computeMillis :: INTEGER, writeMillis :: INTEGER, nodeCount :: INTEGER, colorCount :: INTEGER, ranIterations :: INTEGER, didConverge :: BOOLEAN, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'colorCount :: INTEGER', + name: 'colorCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'ranIterations :: INTEGER', + name: 'ranIterations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'didConverge :: BOOLEAN', + name: 'didConverge', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.k1coloring.write.estimate': { + name: 'gds.k1coloring.write.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.k1coloring.write.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.kSpanningTree.write': { + name: 'gds.kSpanningTree.write', + description: + 'The K-spanning tree algorithm starts from a root node and returns a spanning tree with exactly k nodes', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.kSpanningTree.write(graphName :: STRING, configuration = {} :: MAP) :: (effectiveNodeCount :: INTEGER, writeMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'effectiveNodeCount :: INTEGER', + name: 'effectiveNodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.kcore.mutate': { + name: 'gds.kcore.mutate', + description: 'It computes the k-core values in a network', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.kcore.mutate(graphName :: STRING, configuration = {} :: MAP) :: (nodePropertiesWritten :: INTEGER, degeneracy :: INTEGER, mutateMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'degeneracy :: INTEGER', + name: 'degeneracy', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.kcore.mutate.estimate': { + name: 'gds.kcore.mutate.estimate', + description: 'It computes the k-core values in a network', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.kcore.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.kcore.stats': { + name: 'gds.kcore.stats', + description: 'It computes the k-core values in a network', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.kcore.stats(graphName :: STRING, configuration = {} :: MAP) :: (degeneracy :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'degeneracy :: INTEGER', + name: 'degeneracy', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.kcore.stats.estimate': { + name: 'gds.kcore.stats.estimate', + description: 'It computes the k-core values in a network', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.kcore.stats.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.kcore.stream': { + name: 'gds.kcore.stream', + description: 'It computes the k-core values in a network', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.kcore.stream(graphName :: STRING, configuration = {} :: MAP) :: (nodeId :: INTEGER, coreValue :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeId :: INTEGER', + name: 'nodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'coreValue :: INTEGER', + name: 'coreValue', + type: 'INTEGER', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.kcore.stream.estimate': { + name: 'gds.kcore.stream.estimate', + description: 'It computes the k-core values in a network', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.kcore.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.kcore.write': { + name: 'gds.kcore.write', + description: 'It computes the k-core values in a network', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.kcore.write(graphName :: STRING, configuration = {} :: MAP) :: (nodePropertiesWritten :: INTEGER, degeneracy :: INTEGER, writeMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'degeneracy :: INTEGER', + name: 'degeneracy', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.kcore.write.estimate': { + name: 'gds.kcore.write.estimate', + description: 'It computes the k-core values in a network', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.kcore.write.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.kmeans.mutate': { + name: 'gds.kmeans.mutate', + description: + 'The Kmeans algorithm clusters nodes into different communities based on Euclidean distance', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.kmeans.mutate(graphName :: STRING, configuration = {} :: MAP) :: (mutateMillis :: INTEGER, nodePropertiesWritten :: INTEGER, communityDistribution :: MAP, centroids :: LIST>, averageDistanceToCentroid :: FLOAT, averageSilhouette :: FLOAT, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'communityDistribution :: MAP', + name: 'communityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'centroids :: LIST>', + name: 'centroids', + type: 'LIST>', + }, + { + isDeprecated: false, + description: 'averageDistanceToCentroid :: FLOAT', + name: 'averageDistanceToCentroid', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'averageSilhouette :: FLOAT', + name: 'averageSilhouette', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.kmeans.mutate.estimate': { + name: 'gds.kmeans.mutate.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.kmeans.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.kmeans.stats': { + name: 'gds.kmeans.stats', + description: + 'The Kmeans algorithm clusters nodes into different communities based on Euclidean distance', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.kmeans.stats(graphName :: STRING, configuration = {} :: MAP) :: (communityDistribution :: MAP, centroids :: LIST>, averageDistanceToCentroid :: FLOAT, averageSilhouette :: FLOAT, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'communityDistribution :: MAP', + name: 'communityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'centroids :: LIST>', + name: 'centroids', + type: 'LIST>', + }, + { + isDeprecated: false, + description: 'averageDistanceToCentroid :: FLOAT', + name: 'averageDistanceToCentroid', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'averageSilhouette :: FLOAT', + name: 'averageSilhouette', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.kmeans.stats.estimate': { + name: 'gds.kmeans.stats.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.kmeans.stats.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.kmeans.stream': { + name: 'gds.kmeans.stream', + description: + 'The Kmeans algorithm clusters nodes into different communities based on Euclidean distance', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.kmeans.stream(graphName :: STRING, configuration = {} :: MAP) :: (nodeId :: INTEGER, communityId :: INTEGER, distanceFromCentroid :: FLOAT, silhouette :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeId :: INTEGER', + name: 'nodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'communityId :: INTEGER', + name: 'communityId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'distanceFromCentroid :: FLOAT', + name: 'distanceFromCentroid', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'silhouette :: FLOAT', + name: 'silhouette', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.kmeans.stream.estimate': { + name: 'gds.kmeans.stream.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.kmeans.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.kmeans.write': { + name: 'gds.kmeans.write', + description: + 'The Kmeans algorithm clusters nodes into different communities based on Euclidean distance', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.kmeans.write(graphName :: STRING, configuration = {} :: MAP) :: (writeMillis :: INTEGER, nodePropertiesWritten :: INTEGER, communityDistribution :: MAP, centroids :: LIST>, averageDistanceToCentroid :: FLOAT, averageSilhouette :: FLOAT, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'communityDistribution :: MAP', + name: 'communityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'centroids :: LIST>', + name: 'centroids', + type: 'LIST>', + }, + { + isDeprecated: false, + description: 'averageDistanceToCentroid :: FLOAT', + name: 'averageDistanceToCentroid', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'averageSilhouette :: FLOAT', + name: 'averageSilhouette', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.kmeans.write.estimate': { + name: 'gds.kmeans.write.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.kmeans.write.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.knn.filtered.mutate': { + name: 'gds.knn.filtered.mutate', + description: + 'The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance between two nodes is among the k nearest distances compared to other nodes. KNN computes distances based on the similarity of node properties. Filtered KNN extends this functionality, allowing filtering on source nodes and target nodes, respectively.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.knn.filtered.mutate(graphName :: STRING, configuration = {} :: MAP) :: (ranIterations :: INTEGER, nodePairsConsidered :: INTEGER, didConverge :: BOOLEAN, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, mutateMillis :: INTEGER, postProcessingMillis :: INTEGER, nodesCompared :: INTEGER, relationshipsWritten :: INTEGER, similarityDistribution :: MAP, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'ranIterations :: INTEGER', + name: 'ranIterations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodePairsConsidered :: INTEGER', + name: 'nodePairsConsidered', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'didConverge :: BOOLEAN', + name: 'didConverge', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodesCompared :: INTEGER', + name: 'nodesCompared', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipsWritten :: INTEGER', + name: 'relationshipsWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'similarityDistribution :: MAP', + name: 'similarityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.knn.filtered.mutate.estimate': { + name: 'gds.knn.filtered.mutate.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.knn.filtered.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.knn.filtered.stats': { + name: 'gds.knn.filtered.stats', + description: + 'The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance between two nodes is among the k nearest distances compared to other nodes. KNN computes distances based on the similarity of node properties. Filtered KNN extends this functionality, allowing filtering on source nodes and target nodes, respectively.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.knn.filtered.stats(graphName :: STRING, configuration = {} :: MAP) :: (ranIterations :: INTEGER, didConverge :: BOOLEAN, nodePairsConsidered :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, postProcessingMillis :: INTEGER, nodesCompared :: INTEGER, similarityPairs :: INTEGER, similarityDistribution :: MAP, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'ranIterations :: INTEGER', + name: 'ranIterations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'didConverge :: BOOLEAN', + name: 'didConverge', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'nodePairsConsidered :: INTEGER', + name: 'nodePairsConsidered', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodesCompared :: INTEGER', + name: 'nodesCompared', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'similarityPairs :: INTEGER', + name: 'similarityPairs', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'similarityDistribution :: MAP', + name: 'similarityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.knn.filtered.stats.estimate': { + name: 'gds.knn.filtered.stats.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.knn.filtered.stats.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.knn.filtered.stream': { + name: 'gds.knn.filtered.stream', + description: + 'The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance between two nodes is among the k nearest distances compared to other nodes. KNN computes distances based on the similarity of node properties. Filtered KNN extends this functionality, allowing filtering on source nodes and target nodes, respectively.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.knn.filtered.stream(graphName :: STRING, configuration = {} :: MAP) :: (node1 :: INTEGER, node2 :: INTEGER, similarity :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'node1 :: INTEGER', + name: 'node1', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'node2 :: INTEGER', + name: 'node2', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'similarity :: FLOAT', + name: 'similarity', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.knn.filtered.stream.estimate': { + name: 'gds.knn.filtered.stream.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.knn.filtered.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.knn.filtered.write': { + name: 'gds.knn.filtered.write', + description: + 'The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance between two nodes is among the k nearest distances compared to other nodes. KNN computes distances based on the similarity of node properties. Filtered KNN extends this functionality, allowing filtering on source nodes and target nodes, respectively.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.knn.filtered.write(graphName :: STRING, configuration = {} :: MAP) :: (ranIterations :: INTEGER, didConverge :: BOOLEAN, nodePairsConsidered :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, writeMillis :: INTEGER, postProcessingMillis :: INTEGER, nodesCompared :: INTEGER, relationshipsWritten :: INTEGER, similarityDistribution :: MAP, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'ranIterations :: INTEGER', + name: 'ranIterations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'didConverge :: BOOLEAN', + name: 'didConverge', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'nodePairsConsidered :: INTEGER', + name: 'nodePairsConsidered', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodesCompared :: INTEGER', + name: 'nodesCompared', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipsWritten :: INTEGER', + name: 'relationshipsWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'similarityDistribution :: MAP', + name: 'similarityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.knn.filtered.write.estimate': { + name: 'gds.knn.filtered.write.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.knn.filtered.write.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.knn.mutate': { + name: 'gds.knn.mutate', + description: + 'The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance between two nodes is among the k nearest distances compared to other nodes.KNN computes distances based on the similarity of node properties', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.knn.mutate(graphName :: STRING, configuration = {} :: MAP) :: (ranIterations :: INTEGER, nodePairsConsidered :: INTEGER, didConverge :: BOOLEAN, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, mutateMillis :: INTEGER, postProcessingMillis :: INTEGER, nodesCompared :: INTEGER, relationshipsWritten :: INTEGER, similarityDistribution :: MAP, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'ranIterations :: INTEGER', + name: 'ranIterations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodePairsConsidered :: INTEGER', + name: 'nodePairsConsidered', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'didConverge :: BOOLEAN', + name: 'didConverge', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodesCompared :: INTEGER', + name: 'nodesCompared', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipsWritten :: INTEGER', + name: 'relationshipsWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'similarityDistribution :: MAP', + name: 'similarityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.knn.mutate.estimate': { + name: 'gds.knn.mutate.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.knn.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.knn.stats': { + name: 'gds.knn.stats', + description: + 'The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance between two nodes is among the k nearest distances compared to other nodes.KNN computes distances based on the similarity of node properties', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.knn.stats(graphName :: STRING, configuration = {} :: MAP) :: (ranIterations :: INTEGER, didConverge :: BOOLEAN, nodePairsConsidered :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, postProcessingMillis :: INTEGER, nodesCompared :: INTEGER, similarityPairs :: INTEGER, similarityDistribution :: MAP, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'ranIterations :: INTEGER', + name: 'ranIterations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'didConverge :: BOOLEAN', + name: 'didConverge', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'nodePairsConsidered :: INTEGER', + name: 'nodePairsConsidered', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodesCompared :: INTEGER', + name: 'nodesCompared', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'similarityPairs :: INTEGER', + name: 'similarityPairs', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'similarityDistribution :: MAP', + name: 'similarityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.knn.stats.estimate': { + name: 'gds.knn.stats.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.knn.stats.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.knn.stream': { + name: 'gds.knn.stream', + description: + 'The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance between two nodes is among the k nearest distances compared to other nodes.KNN computes distances based on the similarity of node properties', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.knn.stream(graphName :: STRING, configuration = {} :: MAP) :: (node1 :: INTEGER, node2 :: INTEGER, similarity :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'node1 :: INTEGER', + name: 'node1', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'node2 :: INTEGER', + name: 'node2', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'similarity :: FLOAT', + name: 'similarity', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.knn.stream.estimate': { + name: 'gds.knn.stream.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.knn.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.knn.write': { + name: 'gds.knn.write', + description: + 'The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance between two nodes is among the k nearest distances compared to other nodes.KNN computes distances based on the similarity of node properties', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.knn.write(graphName :: STRING, configuration = {} :: MAP) :: (ranIterations :: INTEGER, didConverge :: BOOLEAN, nodePairsConsidered :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, writeMillis :: INTEGER, postProcessingMillis :: INTEGER, nodesCompared :: INTEGER, relationshipsWritten :: INTEGER, similarityDistribution :: MAP, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'ranIterations :: INTEGER', + name: 'ranIterations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'didConverge :: BOOLEAN', + name: 'didConverge', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'nodePairsConsidered :: INTEGER', + name: 'nodePairsConsidered', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodesCompared :: INTEGER', + name: 'nodesCompared', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipsWritten :: INTEGER', + name: 'relationshipsWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'similarityDistribution :: MAP', + name: 'similarityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.knn.write.estimate': { + name: 'gds.knn.write.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.knn.write.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.labelPropagation.mutate': { + name: 'gds.labelPropagation.mutate', + description: + 'The Label Propagation algorithm is a fast algorithm for finding communities in a graph.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.labelPropagation.mutate(graphName :: STRING, configuration = {} :: MAP) :: (mutateMillis :: INTEGER, nodePropertiesWritten :: INTEGER, ranIterations :: INTEGER, didConverge :: BOOLEAN, communityCount :: INTEGER, communityDistribution :: MAP, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'ranIterations :: INTEGER', + name: 'ranIterations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'didConverge :: BOOLEAN', + name: 'didConverge', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'communityCount :: INTEGER', + name: 'communityCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'communityDistribution :: MAP', + name: 'communityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.labelPropagation.mutate.estimate': { + name: 'gds.labelPropagation.mutate.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.labelPropagation.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.labelPropagation.stats': { + name: 'gds.labelPropagation.stats', + description: + 'The Label Propagation algorithm is a fast algorithm for finding communities in a graph.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.labelPropagation.stats(graphName :: STRING, configuration = {} :: MAP) :: (ranIterations :: INTEGER, didConverge :: BOOLEAN, communityCount :: INTEGER, communityDistribution :: MAP, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'ranIterations :: INTEGER', + name: 'ranIterations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'didConverge :: BOOLEAN', + name: 'didConverge', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'communityCount :: INTEGER', + name: 'communityCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'communityDistribution :: MAP', + name: 'communityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.labelPropagation.stats.estimate': { + name: 'gds.labelPropagation.stats.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.labelPropagation.stats.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.labelPropagation.stream': { + name: 'gds.labelPropagation.stream', + description: + 'The Label Propagation algorithm is a fast algorithm for finding communities in a graph.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.labelPropagation.stream(graphName :: STRING, configuration = {} :: MAP) :: (nodeId :: INTEGER, communityId :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeId :: INTEGER', + name: 'nodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'communityId :: INTEGER', + name: 'communityId', + type: 'INTEGER', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.labelPropagation.stream.estimate': { + name: 'gds.labelPropagation.stream.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.labelPropagation.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.labelPropagation.write': { + name: 'gds.labelPropagation.write', + description: + 'The Label Propagation algorithm is a fast algorithm for finding communities in a graph.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.labelPropagation.write(graphName :: STRING, configuration = {} :: MAP) :: (writeMillis :: INTEGER, nodePropertiesWritten :: INTEGER, ranIterations :: INTEGER, didConverge :: BOOLEAN, communityCount :: INTEGER, communityDistribution :: MAP, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'ranIterations :: INTEGER', + name: 'ranIterations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'didConverge :: BOOLEAN', + name: 'didConverge', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'communityCount :: INTEGER', + name: 'communityCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'communityDistribution :: MAP', + name: 'communityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.labelPropagation.write.estimate': { + name: 'gds.labelPropagation.write.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.labelPropagation.write.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.leiden.mutate': { + name: 'gds.leiden.mutate', + description: + 'Leiden is a community detection algorithm, which guarantees that communities are well connected', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.leiden.mutate(graphName :: STRING, configuration = {} :: MAP) :: (mutateMillis :: INTEGER, nodePropertiesWritten :: INTEGER, ranLevels :: INTEGER, didConverge :: BOOLEAN, nodeCount :: INTEGER, communityCount :: INTEGER, communityDistribution :: MAP, modularity :: FLOAT, modularities :: LIST, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'ranLevels :: INTEGER', + name: 'ranLevels', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'didConverge :: BOOLEAN', + name: 'didConverge', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'communityCount :: INTEGER', + name: 'communityCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'communityDistribution :: MAP', + name: 'communityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'modularity :: FLOAT', + name: 'modularity', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'modularities :: LIST', + name: 'modularities', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.leiden.mutate.estimate': { + name: 'gds.leiden.mutate.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.leiden.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.leiden.stats': { + name: 'gds.leiden.stats', + description: + 'Executes the algorithm and returns result statistics without writing the result to Neo4j.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.leiden.stats(graphName :: STRING, configuration = {} :: MAP) :: (ranLevels :: INTEGER, didConverge :: BOOLEAN, nodeCount :: INTEGER, communityCount :: INTEGER, communityDistribution :: MAP, modularity :: FLOAT, modularities :: LIST, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'ranLevels :: INTEGER', + name: 'ranLevels', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'didConverge :: BOOLEAN', + name: 'didConverge', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'communityCount :: INTEGER', + name: 'communityCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'communityDistribution :: MAP', + name: 'communityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'modularity :: FLOAT', + name: 'modularity', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'modularities :: LIST', + name: 'modularities', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.leiden.stats.estimate': { + name: 'gds.leiden.stats.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.leiden.stats.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.leiden.stream': { + name: 'gds.leiden.stream', + description: + 'Leiden is a community detection algorithm, which guarantees that communities are well connected', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.leiden.stream(graphName :: STRING, configuration = {} :: MAP) :: (nodeId :: INTEGER, communityId :: INTEGER, intermediateCommunityIds :: LIST)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeId :: INTEGER', + name: 'nodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'communityId :: INTEGER', + name: 'communityId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'intermediateCommunityIds :: LIST', + name: 'intermediateCommunityIds', + type: 'LIST', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.leiden.stream.estimate': { + name: 'gds.leiden.stream.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.leiden.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.leiden.write': { + name: 'gds.leiden.write', + description: + 'Leiden is a community detection algorithm, which guarantees that communities are well connected', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.leiden.write(graphName :: STRING, configuration = {} :: MAP) :: (writeMillis :: INTEGER, nodePropertiesWritten :: INTEGER, ranLevels :: INTEGER, didConverge :: BOOLEAN, nodeCount :: INTEGER, communityCount :: INTEGER, communityDistribution :: MAP, modularity :: FLOAT, modularities :: LIST, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'ranLevels :: INTEGER', + name: 'ranLevels', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'didConverge :: BOOLEAN', + name: 'didConverge', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'communityCount :: INTEGER', + name: 'communityCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'communityDistribution :: MAP', + name: 'communityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'modularity :: FLOAT', + name: 'modularity', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'modularities :: LIST', + name: 'modularities', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.leiden.write.estimate': { + name: 'gds.leiden.write.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.leiden.write.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.license.state': { + name: 'gds.license.state', + description: 'Returns details about the license state', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [], + signature: + 'gds.license.state() :: (isLicensed :: BOOLEAN, details :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'isLicensed :: BOOLEAN', + name: 'isLicensed', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'details :: STRING', + name: 'details', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.list': { + name: 'gds.list', + description: + 'CALL gds.list - lists all algorithm procedures, their description and signature', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'name = :: STRING', + name: 'name', + type: 'STRING', + }, + ], + signature: + 'gds.list(name = :: STRING) :: (name :: STRING, description :: STRING, signature :: STRING, type :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'name :: STRING', + name: 'name', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'description :: STRING', + name: 'description', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'signature :: STRING', + name: 'signature', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'type :: STRING', + name: 'type', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.listProgress': { + name: 'gds.listProgress', + description: 'List progress events for currently running tasks.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'jobId = :: STRING', + name: 'jobId', + type: 'STRING', + }, + ], + signature: + 'gds.listProgress(jobId = :: STRING) :: (username :: STRING, jobId :: STRING, taskName :: STRING, progress :: STRING, progressBar :: STRING, status :: STRING, timeStarted :: LOCAL TIME, elapsedTime :: STRING)', + returnDescription: [ + { + isDeprecated: false, + description: 'username :: STRING', + name: 'username', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'jobId :: STRING', + name: 'jobId', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'taskName :: STRING', + name: 'taskName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'progress :: STRING', + name: 'progress', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'progressBar :: STRING', + name: 'progressBar', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'status :: STRING', + name: 'status', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'timeStarted :: LOCAL TIME', + name: 'timeStarted', + type: 'LOCAL TIME', + }, + { + isDeprecated: false, + description: 'elapsedTime :: STRING', + name: 'elapsedTime', + type: 'STRING', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.localClusteringCoefficient.mutate': { + name: 'gds.localClusteringCoefficient.mutate', + description: + 'The local clustering coefficient is a metric quantifying how connected the neighborhood of a node is.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.localClusteringCoefficient.mutate(graphName :: STRING, configuration = {} :: MAP) :: (mutateMillis :: INTEGER, nodePropertiesWritten :: INTEGER, averageClusteringCoefficient :: FLOAT, nodeCount :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'averageClusteringCoefficient :: FLOAT', + name: 'averageClusteringCoefficient', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.localClusteringCoefficient.mutate.estimate': { + name: 'gds.localClusteringCoefficient.mutate.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.localClusteringCoefficient.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.localClusteringCoefficient.stats': { + name: 'gds.localClusteringCoefficient.stats', + description: + 'Executes the algorithm and returns result statistics without writing the result to Neo4j.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.localClusteringCoefficient.stats(graphName :: STRING, configuration = {} :: MAP) :: (averageClusteringCoefficient :: FLOAT, nodeCount :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'averageClusteringCoefficient :: FLOAT', + name: 'averageClusteringCoefficient', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.localClusteringCoefficient.stats.estimate': { + name: 'gds.localClusteringCoefficient.stats.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.localClusteringCoefficient.stats.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.localClusteringCoefficient.stream': { + name: 'gds.localClusteringCoefficient.stream', + description: + 'The local clustering coefficient is a metric quantifying how connected the neighborhood of a node is.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.localClusteringCoefficient.stream(graphName :: STRING, configuration = {} :: MAP) :: (nodeId :: INTEGER, localClusteringCoefficient :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeId :: INTEGER', + name: 'nodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'localClusteringCoefficient :: FLOAT', + name: 'localClusteringCoefficient', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.localClusteringCoefficient.stream.estimate': { + name: 'gds.localClusteringCoefficient.stream.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.localClusteringCoefficient.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.localClusteringCoefficient.write': { + name: 'gds.localClusteringCoefficient.write', + description: + 'The local clustering coefficient is a metric quantifying how connected the neighborhood of a node is.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.localClusteringCoefficient.write(graphName :: STRING, configuration = {} :: MAP) :: (writeMillis :: INTEGER, nodePropertiesWritten :: INTEGER, averageClusteringCoefficient :: FLOAT, nodeCount :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'averageClusteringCoefficient :: FLOAT', + name: 'averageClusteringCoefficient', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.localClusteringCoefficient.write.estimate': { + name: 'gds.localClusteringCoefficient.write.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.localClusteringCoefficient.write.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.louvain.mutate': { + name: 'gds.louvain.mutate', + description: + 'The Louvain method for community detection is an algorithm for detecting communities in networks.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.louvain.mutate(graphName :: STRING, configuration = {} :: MAP) :: (mutateMillis :: INTEGER, nodePropertiesWritten :: INTEGER, modularity :: FLOAT, modularities :: LIST, ranLevels :: INTEGER, communityCount :: INTEGER, communityDistribution :: MAP, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'modularity :: FLOAT', + name: 'modularity', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'modularities :: LIST', + name: 'modularities', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'ranLevels :: INTEGER', + name: 'ranLevels', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'communityCount :: INTEGER', + name: 'communityCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'communityDistribution :: MAP', + name: 'communityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.louvain.mutate.estimate': { + name: 'gds.louvain.mutate.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.louvain.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.louvain.stats': { + name: 'gds.louvain.stats', + description: + 'Executes the algorithm and returns result statistics without writing the result to Neo4j.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.louvain.stats(graphName :: STRING, configuration = {} :: MAP) :: (modularity :: FLOAT, modularities :: LIST, ranLevels :: INTEGER, communityCount :: INTEGER, communityDistribution :: MAP, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'modularity :: FLOAT', + name: 'modularity', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'modularities :: LIST', + name: 'modularities', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'ranLevels :: INTEGER', + name: 'ranLevels', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'communityCount :: INTEGER', + name: 'communityCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'communityDistribution :: MAP', + name: 'communityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.louvain.stats.estimate': { + name: 'gds.louvain.stats.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.louvain.stats.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.louvain.stream': { + name: 'gds.louvain.stream', + description: + 'The Louvain method for community detection is an algorithm for detecting communities in networks.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.louvain.stream(graphName :: STRING, configuration = {} :: MAP) :: (nodeId :: INTEGER, communityId :: INTEGER, intermediateCommunityIds :: LIST)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeId :: INTEGER', + name: 'nodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'communityId :: INTEGER', + name: 'communityId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'intermediateCommunityIds :: LIST', + name: 'intermediateCommunityIds', + type: 'LIST', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.louvain.stream.estimate': { + name: 'gds.louvain.stream.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.louvain.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.louvain.write': { + name: 'gds.louvain.write', + description: + 'The Louvain method for community detection is an algorithm for detecting communities in networks.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.louvain.write(graphName :: STRING, configuration = {} :: MAP) :: (writeMillis :: INTEGER, nodePropertiesWritten :: INTEGER, modularity :: FLOAT, modularities :: LIST, ranLevels :: INTEGER, communityCount :: INTEGER, communityDistribution :: MAP, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'modularity :: FLOAT', + name: 'modularity', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'modularities :: LIST', + name: 'modularities', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'ranLevels :: INTEGER', + name: 'ranLevels', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'communityCount :: INTEGER', + name: 'communityCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'communityDistribution :: MAP', + name: 'communityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.louvain.write.estimate': { + name: 'gds.louvain.write.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.louvain.write.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.maxkcut.mutate': { + name: 'gds.maxkcut.mutate', + description: + 'Approximate Maximum k-cut maps each node into one of k disjoint communities trying to maximize the sum of weights of relationships between these communities.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.maxkcut.mutate(graphName :: STRING, configuration = {} :: MAP) :: (nodePropertiesWritten :: INTEGER, cutCost :: FLOAT, mutateMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'cutCost :: FLOAT', + name: 'cutCost', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.maxkcut.mutate.estimate': { + name: 'gds.maxkcut.mutate.estimate', + description: + 'Approximate Maximum k-cut maps each node into one of k disjoint communities trying to maximize the sum of weights of relationships between these communities.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.maxkcut.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.maxkcut.stream': { + name: 'gds.maxkcut.stream', + description: + 'Approximate Maximum k-cut maps each node into one of k disjoint communities trying to maximize the sum of weights of relationships between these communities.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.maxkcut.stream(graphName :: STRING, configuration = {} :: MAP) :: (nodeId :: INTEGER, communityId :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeId :: INTEGER', + name: 'nodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'communityId :: INTEGER', + name: 'communityId', + type: 'INTEGER', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.maxkcut.stream.estimate': { + name: 'gds.maxkcut.stream.estimate', + description: + 'Approximate Maximum k-cut maps each node into one of k disjoint communities trying to maximize the sum of weights of relationships between these communities.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.maxkcut.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.model.delete': { + name: 'gds.model.delete', + description: 'Deletes a stored model from disk.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'modelName :: STRING', + name: 'modelName', + type: 'STRING', + }, + ], + signature: + 'gds.model.delete(modelName :: STRING) :: (modelName :: STRING, deleteMillis :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'modelName :: STRING', + name: 'modelName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'deleteMillis :: INTEGER', + name: 'deleteMillis', + type: 'INTEGER', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.model.drop': { + name: 'gds.model.drop', + description: + 'Drops a loaded model and frees up the resources it occupies.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'modelName :: STRING', + name: 'modelName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=true, type=BOOLEAN}', + description: 'failIfMissing = true :: BOOLEAN', + name: 'failIfMissing', + type: 'BOOLEAN', + }, + ], + signature: + 'gds.model.drop(modelName :: STRING, failIfMissing = true :: BOOLEAN) :: (modelName :: STRING, modelType :: STRING, modelInfo :: MAP, creationTime :: ZONED DATETIME, trainConfig :: MAP, graphSchema :: MAP, loaded :: BOOLEAN, stored :: BOOLEAN, published :: BOOLEAN)', + returnDescription: [ + { + isDeprecated: false, + description: 'modelName :: STRING', + name: 'modelName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'modelType :: STRING', + name: 'modelType', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'modelInfo :: MAP', + name: 'modelInfo', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'creationTime :: ZONED DATETIME', + name: 'creationTime', + type: 'ZONED DATETIME', + }, + { + isDeprecated: false, + description: 'trainConfig :: MAP', + name: 'trainConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'graphSchema :: MAP', + name: 'graphSchema', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'loaded :: BOOLEAN', + name: 'loaded', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'stored :: BOOLEAN', + name: 'stored', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'published :: BOOLEAN', + name: 'published', + type: 'BOOLEAN', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.model.exists': { + name: 'gds.model.exists', + description: 'Checks if a given model exists in the model catalog.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'modelName :: STRING', + name: 'modelName', + type: 'STRING', + }, + ], + signature: + 'gds.model.exists(modelName :: STRING) :: (modelName :: STRING, modelType :: STRING, exists :: BOOLEAN)', + returnDescription: [ + { + isDeprecated: false, + description: 'modelName :: STRING', + name: 'modelName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'modelType :: STRING', + name: 'modelType', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'exists :: BOOLEAN', + name: 'exists', + type: 'BOOLEAN', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.model.list': { + name: 'gds.model.list', + description: 'Lists all models contained in the model catalog.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + default: 'DefaultParameterValue{value=__NO_VALUE, type=STRING}', + description: 'modelName = __NO_VALUE :: STRING', + name: 'modelName', + type: 'STRING', + }, + ], + signature: + 'gds.model.list(modelName = __NO_VALUE :: STRING) :: (modelName :: STRING, modelType :: STRING, modelInfo :: MAP, creationTime :: ZONED DATETIME, trainConfig :: MAP, graphSchema :: MAP, loaded :: BOOLEAN, stored :: BOOLEAN, published :: BOOLEAN)', + returnDescription: [ + { + isDeprecated: false, + description: 'modelName :: STRING', + name: 'modelName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'modelType :: STRING', + name: 'modelType', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'modelInfo :: MAP', + name: 'modelInfo', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'creationTime :: ZONED DATETIME', + name: 'creationTime', + type: 'ZONED DATETIME', + }, + { + isDeprecated: false, + description: 'trainConfig :: MAP', + name: 'trainConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'graphSchema :: MAP', + name: 'graphSchema', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'loaded :: BOOLEAN', + name: 'loaded', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'stored :: BOOLEAN', + name: 'stored', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'published :: BOOLEAN', + name: 'published', + type: 'BOOLEAN', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.model.load': { + name: 'gds.model.load', + description: 'Load a stored model into main memory.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'modelName :: STRING', + name: 'modelName', + type: 'STRING', + }, + ], + signature: + 'gds.model.load(modelName :: STRING) :: (modelName :: STRING, loadMillis :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'modelName :: STRING', + name: 'modelName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'loadMillis :: INTEGER', + name: 'loadMillis', + type: 'INTEGER', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.model.publish': { + name: 'gds.model.publish', + description: 'Make a trained model accessible by all users', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'modelName :: STRING', + name: 'modelName', + type: 'STRING', + }, + ], + signature: + 'gds.model.publish(modelName :: STRING) :: (modelName :: STRING, modelType :: STRING, modelInfo :: MAP, creationTime :: ZONED DATETIME, trainConfig :: MAP, graphSchema :: MAP, loaded :: BOOLEAN, stored :: BOOLEAN, published :: BOOLEAN)', + returnDescription: [ + { + isDeprecated: false, + description: 'modelName :: STRING', + name: 'modelName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'modelType :: STRING', + name: 'modelType', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'modelInfo :: MAP', + name: 'modelInfo', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'creationTime :: ZONED DATETIME', + name: 'creationTime', + type: 'ZONED DATETIME', + }, + { + isDeprecated: false, + description: 'trainConfig :: MAP', + name: 'trainConfig', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'graphSchema :: MAP', + name: 'graphSchema', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'loaded :: BOOLEAN', + name: 'loaded', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'stored :: BOOLEAN', + name: 'stored', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'published :: BOOLEAN', + name: 'published', + type: 'BOOLEAN', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.model.store': { + name: 'gds.model.store', + description: 'Store the selected model to disk.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'modelName :: STRING', + name: 'modelName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=true, type=BOOLEAN}', + description: 'failIfUnsupported = true :: BOOLEAN', + name: 'failIfUnsupported', + type: 'BOOLEAN', + }, + ], + signature: + 'gds.model.store(modelName :: STRING, failIfUnsupported = true :: BOOLEAN) :: (modelName :: STRING, storeMillis :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'modelName :: STRING', + name: 'modelName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'storeMillis :: INTEGER', + name: 'storeMillis', + type: 'INTEGER', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.modularity.stats': { + name: 'gds.modularity.stats', + description: + 'The Modularity procedure computes the modularity scores for a given set of communities/', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.modularity.stats(graphName :: STRING, configuration = {} :: MAP) :: (nodeCount :: INTEGER, relationshipCount :: INTEGER, communityCount :: INTEGER, modularity :: FLOAT, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'communityCount :: INTEGER', + name: 'communityCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'modularity :: FLOAT', + name: 'modularity', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.modularity.stats.estimate': { + name: 'gds.modularity.stats.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.modularity.stats.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.modularity.stream': { + name: 'gds.modularity.stream', + description: + 'The Modularity procedure computes the modularity scores for a given set of communities/', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.modularity.stream(graphName :: STRING, configuration = {} :: MAP) :: (communityId :: INTEGER, modularity :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'communityId :: INTEGER', + name: 'communityId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'modularity :: FLOAT', + name: 'modularity', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.modularity.stream.estimate': { + name: 'gds.modularity.stream.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.modularity.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.modularityOptimization.mutate': { + name: 'gds.modularityOptimization.mutate', + description: + 'The Modularity Optimization algorithm groups the nodes in the graph by optimizing the graphs modularity.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.modularityOptimization.mutate(graphName :: STRING, configuration = {} :: MAP) :: (preProcessingMillis :: INTEGER, computeMillis :: INTEGER, mutateMillis :: INTEGER, postProcessingMillis :: INTEGER, nodes :: INTEGER, didConverge :: BOOLEAN, ranIterations :: INTEGER, modularity :: FLOAT, communityCount :: INTEGER, communityDistribution :: MAP, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodes :: INTEGER', + name: 'nodes', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'didConverge :: BOOLEAN', + name: 'didConverge', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'ranIterations :: INTEGER', + name: 'ranIterations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'modularity :: FLOAT', + name: 'modularity', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'communityCount :: INTEGER', + name: 'communityCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'communityDistribution :: MAP', + name: 'communityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.modularityOptimization.mutate.estimate': { + name: 'gds.modularityOptimization.mutate.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.modularityOptimization.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.modularityOptimization.stats': { + name: 'gds.modularityOptimization.stats', + description: + 'The Modularity Optimization algorithm groups the nodes in the graph by optimizing the graphs modularity.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.modularityOptimization.stats(graphName :: STRING, configuration = {} :: MAP) :: (preProcessingMillis :: INTEGER, computeMillis :: INTEGER, postProcessingMillis :: INTEGER, nodes :: INTEGER, didConverge :: BOOLEAN, ranIterations :: INTEGER, modularity :: FLOAT, communityCount :: INTEGER, communityDistribution :: MAP, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodes :: INTEGER', + name: 'nodes', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'didConverge :: BOOLEAN', + name: 'didConverge', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'ranIterations :: INTEGER', + name: 'ranIterations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'modularity :: FLOAT', + name: 'modularity', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'communityCount :: INTEGER', + name: 'communityCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'communityDistribution :: MAP', + name: 'communityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.modularityOptimization.stats.estimate': { + name: 'gds.modularityOptimization.stats.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.modularityOptimization.stats.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.modularityOptimization.stream': { + name: 'gds.modularityOptimization.stream', + description: + 'The Modularity Optimization algorithm groups the nodes in the graph by optimizing the graphs modularity.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.modularityOptimization.stream(graphName :: STRING, configuration = {} :: MAP) :: (nodeId :: INTEGER, communityId :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeId :: INTEGER', + name: 'nodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'communityId :: INTEGER', + name: 'communityId', + type: 'INTEGER', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.modularityOptimization.stream.estimate': { + name: 'gds.modularityOptimization.stream.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.modularityOptimization.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.modularityOptimization.write': { + name: 'gds.modularityOptimization.write', + description: + 'The Modularity Optimization algorithm groups the nodes in the graph by optimizing the graphs modularity.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.modularityOptimization.write(graphName :: STRING, configuration = {} :: MAP) :: (preProcessingMillis :: INTEGER, computeMillis :: INTEGER, writeMillis :: INTEGER, postProcessingMillis :: INTEGER, nodes :: INTEGER, didConverge :: BOOLEAN, ranIterations :: INTEGER, modularity :: FLOAT, communityCount :: INTEGER, communityDistribution :: MAP, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodes :: INTEGER', + name: 'nodes', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'didConverge :: BOOLEAN', + name: 'didConverge', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'ranIterations :: INTEGER', + name: 'ranIterations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'modularity :: FLOAT', + name: 'modularity', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'communityCount :: INTEGER', + name: 'communityCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'communityDistribution :: MAP', + name: 'communityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.modularityOptimization.write.estimate': { + name: 'gds.modularityOptimization.write.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.modularityOptimization.write.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.node2vec.mutate': { + name: 'gds.node2vec.mutate', + description: + 'The Node2Vec algorithm computes embeddings for nodes based on random walks.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.node2vec.mutate(graphName :: STRING, configuration = {} :: MAP) :: (nodeCount :: INTEGER, nodePropertiesWritten :: INTEGER, lossPerIteration :: LIST, mutateMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'lossPerIteration :: LIST', + name: 'lossPerIteration', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.node2vec.mutate.estimate': { + name: 'gds.node2vec.mutate.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.node2vec.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.node2vec.stream': { + name: 'gds.node2vec.stream', + description: + 'The Node2Vec algorithm computes embeddings for nodes based on random walks.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.node2vec.stream(graphName :: STRING, configuration = {} :: MAP) :: (nodeId :: INTEGER, embedding :: LIST)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeId :: INTEGER', + name: 'nodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'embedding :: LIST', + name: 'embedding', + type: 'LIST', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.node2vec.stream.estimate': { + name: 'gds.node2vec.stream.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.node2vec.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.node2vec.write': { + name: 'gds.node2vec.write', + description: + 'The Node2Vec algorithm computes embeddings for nodes based on random walks.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.node2vec.write(graphName :: STRING, configuration = {} :: MAP) :: (nodeCount :: INTEGER, nodePropertiesWritten :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, writeMillis :: INTEGER, configuration :: MAP, lossPerIteration :: LIST)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'lossPerIteration :: LIST', + name: 'lossPerIteration', + type: 'LIST', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.node2vec.write.estimate': { + name: 'gds.node2vec.write.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.node2vec.write.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.nodeSimilarity.filtered.mutate': { + name: 'gds.nodeSimilarity.filtered.mutate', + description: + 'The Filtered Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. Two nodes are considered similar if they share many of the same neighbors. The algorithm computes pair-wise similarities based on Jaccard or Overlap metrics. The filtered variant supports limiting which nodes to compare via source and target node filters.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.nodeSimilarity.filtered.mutate(graphName :: STRING, configuration = {} :: MAP) :: (preProcessingMillis :: INTEGER, computeMillis :: INTEGER, mutateMillis :: INTEGER, postProcessingMillis :: INTEGER, nodesCompared :: INTEGER, relationshipsWritten :: INTEGER, similarityDistribution :: MAP, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodesCompared :: INTEGER', + name: 'nodesCompared', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipsWritten :: INTEGER', + name: 'relationshipsWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'similarityDistribution :: MAP', + name: 'similarityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.nodeSimilarity.filtered.mutate.estimate': { + name: 'gds.nodeSimilarity.filtered.mutate.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.nodeSimilarity.filtered.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.nodeSimilarity.filtered.stats': { + name: 'gds.nodeSimilarity.filtered.stats', + description: + 'The Filtered Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. Two nodes are considered similar if they share many of the same neighbors. The algorithm computes pair-wise similarities based on Jaccard or Overlap metrics. The filtered variant supports limiting which nodes to compare via source and target node filters.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.nodeSimilarity.filtered.stats(graphName :: STRING, configuration = {} :: MAP) :: (preProcessingMillis :: INTEGER, computeMillis :: INTEGER, postProcessingMillis :: INTEGER, nodesCompared :: INTEGER, similarityPairs :: INTEGER, similarityDistribution :: MAP, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodesCompared :: INTEGER', + name: 'nodesCompared', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'similarityPairs :: INTEGER', + name: 'similarityPairs', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'similarityDistribution :: MAP', + name: 'similarityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.nodeSimilarity.filtered.stats.estimate': { + name: 'gds.nodeSimilarity.filtered.stats.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.nodeSimilarity.filtered.stats.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.nodeSimilarity.filtered.stream': { + name: 'gds.nodeSimilarity.filtered.stream', + description: + 'The Filtered Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. Two nodes are considered similar if they share many of the same neighbors. The algorithm computes pair-wise similarities based on Jaccard or Overlap metrics. The filtered variant supports limiting which nodes to compare via source and target node filters.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.nodeSimilarity.filtered.stream(graphName :: STRING, configuration = {} :: MAP) :: (node1 :: INTEGER, node2 :: INTEGER, similarity :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'node1 :: INTEGER', + name: 'node1', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'node2 :: INTEGER', + name: 'node2', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'similarity :: FLOAT', + name: 'similarity', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.nodeSimilarity.filtered.stream.estimate': { + name: 'gds.nodeSimilarity.filtered.stream.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.nodeSimilarity.filtered.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.nodeSimilarity.filtered.write': { + name: 'gds.nodeSimilarity.filtered.write', + description: + 'The Filtered Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. Two nodes are considered similar if they share many of the same neighbors. The algorithm computes pair-wise similarities based on Jaccard or Overlap metrics. The filtered variant supports limiting which nodes to compare via source and target node filters.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.nodeSimilarity.filtered.write(graphName :: STRING, configuration = {} :: MAP) :: (preProcessingMillis :: INTEGER, computeMillis :: INTEGER, writeMillis :: INTEGER, postProcessingMillis :: INTEGER, nodesCompared :: INTEGER, relationshipsWritten :: INTEGER, similarityDistribution :: MAP, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodesCompared :: INTEGER', + name: 'nodesCompared', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipsWritten :: INTEGER', + name: 'relationshipsWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'similarityDistribution :: MAP', + name: 'similarityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.nodeSimilarity.filtered.write.estimate': { + name: 'gds.nodeSimilarity.filtered.write.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.nodeSimilarity.filtered.write.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.nodeSimilarity.mutate': { + name: 'gds.nodeSimilarity.mutate', + description: + 'The Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. Two nodes are considered similar if they share many of the same neighbors. Node Similarity computes pair-wise similarities based on the Jaccard metric.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.nodeSimilarity.mutate(graphName :: STRING, configuration = {} :: MAP) :: (preProcessingMillis :: INTEGER, computeMillis :: INTEGER, mutateMillis :: INTEGER, postProcessingMillis :: INTEGER, nodesCompared :: INTEGER, relationshipsWritten :: INTEGER, similarityDistribution :: MAP, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodesCompared :: INTEGER', + name: 'nodesCompared', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipsWritten :: INTEGER', + name: 'relationshipsWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'similarityDistribution :: MAP', + name: 'similarityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.nodeSimilarity.mutate.estimate': { + name: 'gds.nodeSimilarity.mutate.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.nodeSimilarity.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.nodeSimilarity.stats': { + name: 'gds.nodeSimilarity.stats', + description: + 'The Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. Two nodes are considered similar if they share many of the same neighbors. Node Similarity computes pair-wise similarities based on the Jaccard metric.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.nodeSimilarity.stats(graphName :: STRING, configuration = {} :: MAP) :: (preProcessingMillis :: INTEGER, computeMillis :: INTEGER, postProcessingMillis :: INTEGER, nodesCompared :: INTEGER, similarityPairs :: INTEGER, similarityDistribution :: MAP, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodesCompared :: INTEGER', + name: 'nodesCompared', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'similarityPairs :: INTEGER', + name: 'similarityPairs', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'similarityDistribution :: MAP', + name: 'similarityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.nodeSimilarity.stats.estimate': { + name: 'gds.nodeSimilarity.stats.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.nodeSimilarity.stats.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.nodeSimilarity.stream': { + name: 'gds.nodeSimilarity.stream', + description: + 'The Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. Two nodes are considered similar if they share many of the same neighbors. Node Similarity computes pair-wise similarities based on the Jaccard metric.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.nodeSimilarity.stream(graphName :: STRING, configuration = {} :: MAP) :: (node1 :: INTEGER, node2 :: INTEGER, similarity :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'node1 :: INTEGER', + name: 'node1', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'node2 :: INTEGER', + name: 'node2', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'similarity :: FLOAT', + name: 'similarity', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.nodeSimilarity.stream.estimate': { + name: 'gds.nodeSimilarity.stream.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.nodeSimilarity.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.nodeSimilarity.write': { + name: 'gds.nodeSimilarity.write', + description: + 'The Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. Two nodes are considered similar if they share many of the same neighbors. Node Similarity computes pair-wise similarities based on the Jaccard metric.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.nodeSimilarity.write(graphName :: STRING, configuration = {} :: MAP) :: (preProcessingMillis :: INTEGER, computeMillis :: INTEGER, writeMillis :: INTEGER, postProcessingMillis :: INTEGER, nodesCompared :: INTEGER, relationshipsWritten :: INTEGER, similarityDistribution :: MAP, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodesCompared :: INTEGER', + name: 'nodesCompared', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipsWritten :: INTEGER', + name: 'relationshipsWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'similarityDistribution :: MAP', + name: 'similarityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.nodeSimilarity.write.estimate': { + name: 'gds.nodeSimilarity.write.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.nodeSimilarity.write.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.pageRank.mutate': { + name: 'gds.pageRank.mutate', + description: + 'Page Rank is an algorithm that measures the transitive influence or connectivity of nodes.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.pageRank.mutate(graphName :: STRING, configuration = {} :: MAP) :: (mutateMillis :: INTEGER, nodePropertiesWritten :: INTEGER, ranIterations :: INTEGER, didConverge :: BOOLEAN, centralityDistribution :: MAP, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'ranIterations :: INTEGER', + name: 'ranIterations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'didConverge :: BOOLEAN', + name: 'didConverge', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'centralityDistribution :: MAP', + name: 'centralityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.pageRank.mutate.estimate': { + name: 'gds.pageRank.mutate.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.pageRank.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.pageRank.stats': { + name: 'gds.pageRank.stats', + description: + 'Executes the algorithm and returns result statistics without writing the result to Neo4j.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.pageRank.stats(graphName :: STRING, configuration = {} :: MAP) :: (ranIterations :: INTEGER, didConverge :: BOOLEAN, centralityDistribution :: MAP, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'ranIterations :: INTEGER', + name: 'ranIterations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'didConverge :: BOOLEAN', + name: 'didConverge', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'centralityDistribution :: MAP', + name: 'centralityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.pageRank.stats.estimate': { + name: 'gds.pageRank.stats.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.pageRank.stats.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.pageRank.stream': { + name: 'gds.pageRank.stream', + description: + 'Page Rank is an algorithm that measures the transitive influence or connectivity of nodes.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.pageRank.stream(graphName :: STRING, configuration = {} :: MAP) :: (nodeId :: INTEGER, score :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeId :: INTEGER', + name: 'nodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'score :: FLOAT', + name: 'score', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.pageRank.stream.estimate': { + name: 'gds.pageRank.stream.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.pageRank.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.pageRank.write': { + name: 'gds.pageRank.write', + description: + 'Page Rank is an algorithm that measures the transitive influence or connectivity of nodes.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.pageRank.write(graphName :: STRING, configuration = {} :: MAP) :: (writeMillis :: INTEGER, nodePropertiesWritten :: INTEGER, ranIterations :: INTEGER, didConverge :: BOOLEAN, centralityDistribution :: MAP, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'ranIterations :: INTEGER', + name: 'ranIterations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'didConverge :: BOOLEAN', + name: 'didConverge', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'centralityDistribution :: MAP', + name: 'centralityDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.pageRank.write.estimate': { + name: 'gds.pageRank.write.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.pageRank.write.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.pipeline.drop': { + name: 'gds.pipeline.drop', + description: 'Drops a pipeline and frees up the resources it occupies.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'pipelineName :: STRING', + name: 'pipelineName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value=true, type=BOOLEAN}', + description: 'failIfMissing = true :: BOOLEAN', + name: 'failIfMissing', + type: 'BOOLEAN', + }, + ], + signature: + 'gds.pipeline.drop(pipelineName :: STRING, failIfMissing = true :: BOOLEAN) :: (pipelineInfo :: MAP, pipelineName :: STRING, pipelineType :: STRING, creationTime :: ZONED DATETIME)', + returnDescription: [ + { + isDeprecated: false, + description: 'pipelineInfo :: MAP', + name: 'pipelineInfo', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'pipelineName :: STRING', + name: 'pipelineName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'pipelineType :: STRING', + name: 'pipelineType', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'creationTime :: ZONED DATETIME', + name: 'creationTime', + type: 'ZONED DATETIME', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.pipeline.exists': { + name: 'gds.pipeline.exists', + description: 'Checks if a given pipeline exists in the pipeline catalog.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'pipelineName :: STRING', + name: 'pipelineName', + type: 'STRING', + }, + ], + signature: + 'gds.pipeline.exists(pipelineName :: STRING) :: (pipelineName :: STRING, pipelineType :: STRING, exists :: BOOLEAN)', + returnDescription: [ + { + isDeprecated: false, + description: 'pipelineName :: STRING', + name: 'pipelineName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'pipelineType :: STRING', + name: 'pipelineType', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'exists :: BOOLEAN', + name: 'exists', + type: 'BOOLEAN', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.pipeline.list': { + name: 'gds.pipeline.list', + description: 'Lists all pipelines contained in the pipeline catalog.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + default: 'DefaultParameterValue{value=__NO_VALUE, type=STRING}', + description: 'pipelineName = __NO_VALUE :: STRING', + name: 'pipelineName', + type: 'STRING', + }, + ], + signature: + 'gds.pipeline.list(pipelineName = __NO_VALUE :: STRING) :: (pipelineInfo :: MAP, pipelineName :: STRING, pipelineType :: STRING, creationTime :: ZONED DATETIME)', + returnDescription: [ + { + isDeprecated: false, + description: 'pipelineInfo :: MAP', + name: 'pipelineInfo', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'pipelineName :: STRING', + name: 'pipelineName', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'pipelineType :: STRING', + name: 'pipelineType', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'creationTime :: ZONED DATETIME', + name: 'creationTime', + type: 'ZONED DATETIME', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.randomWalk.stats': { + name: 'gds.randomWalk.stats', + description: + 'Random Walk is an algorithm that provides random paths in a graph. It’s similar to how a drunk person traverses a city.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.randomWalk.stats(graphName :: STRING, configuration = {} :: MAP) :: (preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.randomWalk.stats.estimate': { + name: 'gds.randomWalk.stats.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.randomWalk.stats.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.randomWalk.stream': { + name: 'gds.randomWalk.stream', + description: + 'Random Walk is an algorithm that provides random paths in a graph. It’s similar to how a drunk person traverses a city.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.randomWalk.stream(graphName :: STRING, configuration = {} :: MAP) :: (nodeIds :: LIST, path :: PATH)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeIds :: LIST', + name: 'nodeIds', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'path :: PATH', + name: 'path', + type: 'PATH', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.randomWalk.stream.estimate': { + name: 'gds.randomWalk.stream.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.randomWalk.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.restore': { + name: 'gds.restore', + description: 'The restore procedure reads graphs and models from disk.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.restore(configuration = {} :: MAP) :: (restoredGraph :: STRING, restoredModel :: STRING, status :: STRING, restoreMillis :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'restoredGraph :: STRING', + name: 'restoredGraph', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'restoredModel :: STRING', + name: 'restoredModel', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'status :: STRING', + name: 'status', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'restoreMillis :: INTEGER', + name: 'restoreMillis', + type: 'INTEGER', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.scaleProperties.mutate': { + name: 'gds.scaleProperties.mutate', + description: 'Scale node properties', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.scaleProperties.mutate(graphName :: STRING, configuration = {} :: MAP) :: (scalerStatistics :: MAP, nodePropertiesWritten :: INTEGER, mutateMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'scalerStatistics :: MAP', + name: 'scalerStatistics', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.scaleProperties.mutate.estimate': { + name: 'gds.scaleProperties.mutate.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.scaleProperties.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.scaleProperties.stats': { + name: 'gds.scaleProperties.stats', + description: 'Scale node properties', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.scaleProperties.stats(graphName :: STRING, configuration = {} :: MAP) :: (scalerStatistics :: MAP, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'scalerStatistics :: MAP', + name: 'scalerStatistics', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.scaleProperties.stats.estimate': { + name: 'gds.scaleProperties.stats.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.scaleProperties.stats.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.scaleProperties.stream': { + name: 'gds.scaleProperties.stream', + description: 'Scale node properties', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.scaleProperties.stream(graphName :: STRING, configuration = {} :: MAP) :: (nodeId :: INTEGER, scaledProperty :: LIST)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeId :: INTEGER', + name: 'nodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'scaledProperty :: LIST', + name: 'scaledProperty', + type: 'LIST', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.scaleProperties.stream.estimate': { + name: 'gds.scaleProperties.stream.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.scaleProperties.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.scaleProperties.write': { + name: 'gds.scaleProperties.write', + description: 'Scale node properties', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.scaleProperties.write(graphName :: STRING, configuration = {} :: MAP) :: (nodePropertiesWritten :: INTEGER, scalerStatistics :: MAP, writeMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'scalerStatistics :: MAP', + name: 'scalerStatistics', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.scaleProperties.write.estimate': { + name: 'gds.scaleProperties.write.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.scaleProperties.write.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.scc.mutate': { + name: 'gds.scc.mutate', + description: + 'The SCC algorithm finds sets of connected nodes in an directed graph, where all nodes in the same set form a connected component.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.scc.mutate(graphName :: STRING, configuration = {} :: MAP) :: (componentCount :: INTEGER, componentDistribution :: MAP, nodePropertiesWritten :: INTEGER, mutateMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'componentCount :: INTEGER', + name: 'componentCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'componentDistribution :: MAP', + name: 'componentDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.scc.mutate.estimate': { + name: 'gds.scc.mutate.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.scc.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.scc.stats': { + name: 'gds.scc.stats', + description: + 'The SCC algorithm finds sets of connected nodes in an directed graph, where all nodes in the same set form a connected component.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.scc.stats(graphName :: STRING, configuration = {} :: MAP) :: (componentCount :: INTEGER, componentDistribution :: MAP, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'componentCount :: INTEGER', + name: 'componentCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'componentDistribution :: MAP', + name: 'componentDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.scc.stats.estimate': { + name: 'gds.scc.stats.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.scc.stats.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.scc.stream': { + name: 'gds.scc.stream', + description: + 'The SCC algorithm finds sets of connected nodes in an directed graph, where all nodes in the same set form a connected component.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.scc.stream(graphName :: STRING, configuration = {} :: MAP) :: (nodeId :: INTEGER, componentId :: INTEGER)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeId :: INTEGER', + name: 'nodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'componentId :: INTEGER', + name: 'componentId', + type: 'INTEGER', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.scc.stream.estimate': { + name: 'gds.scc.stream.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.scc.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.scc.write': { + name: 'gds.scc.write', + description: + 'The SCC algorithm finds sets of connected nodes in an directed graph, where all nodes in the same set form a connected component.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.scc.write(graphName :: STRING, configuration = {} :: MAP) :: (componentCount :: INTEGER, componentDistribution :: MAP, nodePropertiesWritten :: INTEGER, writeMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'componentCount :: INTEGER', + name: 'componentCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'componentDistribution :: MAP', + name: 'componentDistribution', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.scc.write.estimate': { + name: 'gds.scc.write.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.scc.write.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.shortestPath.astar.mutate': { + name: 'gds.shortestPath.astar.mutate', + description: + 'The A* shortest path algorithm computes the shortest path between a pair of nodes. It uses the relationship weight property to compare path lengths. In addition, this implementation uses the haversine distance as a heuristic to converge faster.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.shortestPath.astar.mutate(graphName :: STRING, configuration = {} :: MAP) :: (relationshipsWritten :: INTEGER, mutateMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'relationshipsWritten :: INTEGER', + name: 'relationshipsWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.shortestPath.astar.mutate.estimate': { + name: 'gds.shortestPath.astar.mutate.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.shortestPath.astar.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.shortestPath.astar.stream': { + name: 'gds.shortestPath.astar.stream', + description: + 'The A* shortest path algorithm computes the shortest path between a pair of nodes. It uses the relationship weight property to compare path lengths. In addition, this implementation uses the haversine distance as a heuristic to converge faster.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.shortestPath.astar.stream(graphName :: STRING, configuration = {} :: MAP) :: (index :: INTEGER, sourceNode :: INTEGER, targetNode :: INTEGER, totalCost :: FLOAT, nodeIds :: LIST, costs :: LIST, path :: PATH)', + returnDescription: [ + { + isDeprecated: false, + description: 'index :: INTEGER', + name: 'index', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'sourceNode :: INTEGER', + name: 'sourceNode', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'targetNode :: INTEGER', + name: 'targetNode', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'totalCost :: FLOAT', + name: 'totalCost', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'nodeIds :: LIST', + name: 'nodeIds', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'costs :: LIST', + name: 'costs', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'path :: PATH', + name: 'path', + type: 'PATH', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.shortestPath.astar.stream.estimate': { + name: 'gds.shortestPath.astar.stream.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.shortestPath.astar.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.shortestPath.astar.write': { + name: 'gds.shortestPath.astar.write', + description: + 'The A* shortest path algorithm computes the shortest path between a pair of nodes. It uses the relationship weight property to compare path lengths. In addition, this implementation uses the haversine distance as a heuristic to converge faster.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.shortestPath.astar.write(graphName :: STRING, configuration = {} :: MAP) :: (relationshipsWritten :: INTEGER, writeMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'relationshipsWritten :: INTEGER', + name: 'relationshipsWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.shortestPath.astar.write.estimate': { + name: 'gds.shortestPath.astar.write.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.shortestPath.astar.write.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.shortestPath.dijkstra.mutate': { + name: 'gds.shortestPath.dijkstra.mutate', + description: + 'The Dijkstra shortest path algorithm computes the shortest (weighted) path between a pair of nodes.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.shortestPath.dijkstra.mutate(graphName :: STRING, configuration = {} :: MAP) :: (relationshipsWritten :: INTEGER, mutateMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'relationshipsWritten :: INTEGER', + name: 'relationshipsWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.shortestPath.dijkstra.mutate.estimate': { + name: 'gds.shortestPath.dijkstra.mutate.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.shortestPath.dijkstra.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.shortestPath.dijkstra.stream': { + name: 'gds.shortestPath.dijkstra.stream', + description: + 'The Dijkstra shortest path algorithm computes the shortest (weighted) path between a pair of nodes.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.shortestPath.dijkstra.stream(graphName :: STRING, configuration = {} :: MAP) :: (index :: INTEGER, sourceNode :: INTEGER, targetNode :: INTEGER, totalCost :: FLOAT, nodeIds :: LIST, costs :: LIST, path :: PATH)', + returnDescription: [ + { + isDeprecated: false, + description: 'index :: INTEGER', + name: 'index', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'sourceNode :: INTEGER', + name: 'sourceNode', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'targetNode :: INTEGER', + name: 'targetNode', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'totalCost :: FLOAT', + name: 'totalCost', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'nodeIds :: LIST', + name: 'nodeIds', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'costs :: LIST', + name: 'costs', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'path :: PATH', + name: 'path', + type: 'PATH', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.shortestPath.dijkstra.stream.estimate': { + name: 'gds.shortestPath.dijkstra.stream.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.shortestPath.dijkstra.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.shortestPath.dijkstra.write': { + name: 'gds.shortestPath.dijkstra.write', + description: + 'The Dijkstra shortest path algorithm computes the shortest (weighted) path between a pair of nodes.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.shortestPath.dijkstra.write(graphName :: STRING, configuration = {} :: MAP) :: (relationshipsWritten :: INTEGER, writeMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'relationshipsWritten :: INTEGER', + name: 'relationshipsWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.shortestPath.dijkstra.write.estimate': { + name: 'gds.shortestPath.dijkstra.write.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.shortestPath.dijkstra.write.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.shortestPath.yens.mutate': { + name: 'gds.shortestPath.yens.mutate', + description: + "The Yen's shortest path algorithm computes the k shortest (weighted) paths between a pair of nodes.", + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.shortestPath.yens.mutate(graphName :: STRING, configuration = {} :: MAP) :: (relationshipsWritten :: INTEGER, mutateMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'relationshipsWritten :: INTEGER', + name: 'relationshipsWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.shortestPath.yens.mutate.estimate': { + name: 'gds.shortestPath.yens.mutate.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.shortestPath.yens.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.shortestPath.yens.stream': { + name: 'gds.shortestPath.yens.stream', + description: + "The Yen's shortest path algorithm computes the k shortest (weighted) paths between a pair of nodes.", + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.shortestPath.yens.stream(graphName :: STRING, configuration = {} :: MAP) :: (index :: INTEGER, sourceNode :: INTEGER, targetNode :: INTEGER, totalCost :: FLOAT, nodeIds :: LIST, costs :: LIST, path :: PATH)', + returnDescription: [ + { + isDeprecated: false, + description: 'index :: INTEGER', + name: 'index', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'sourceNode :: INTEGER', + name: 'sourceNode', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'targetNode :: INTEGER', + name: 'targetNode', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'totalCost :: FLOAT', + name: 'totalCost', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'nodeIds :: LIST', + name: 'nodeIds', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'costs :: LIST', + name: 'costs', + type: 'LIST', + }, + { + isDeprecated: false, + description: 'path :: PATH', + name: 'path', + type: 'PATH', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.shortestPath.yens.stream.estimate': { + name: 'gds.shortestPath.yens.stream.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: ANY', + name: 'graphName', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.shortestPath.yens.stream.estimate(graphName :: ANY, configuration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.shortestPath.yens.write': { + name: 'gds.shortestPath.yens.write', + description: + "The Yen's shortest path algorithm computes the k shortest (weighted) paths between a pair of nodes.", + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.shortestPath.yens.write(graphName :: STRING, configuration = {} :: MAP) :: (relationshipsWritten :: INTEGER, writeMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'relationshipsWritten :: INTEGER', + name: 'relationshipsWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.shortestPath.yens.write.estimate': { + name: 'gds.shortestPath.yens.write.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: ANY', + name: 'graphName', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.shortestPath.yens.write.estimate(graphName :: ANY, configuration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.sllpa.mutate': { + name: 'gds.sllpa.mutate', + description: + 'The Speaker Listener Label Propagation algorithm is a fast algorithm for finding overlapping communities in a graph.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.sllpa.mutate(graphName :: STRING, configuration = {} :: MAP) :: (nodePropertiesWritten :: INTEGER, ranIterations :: INTEGER, didConverge :: BOOLEAN, mutateMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'ranIterations :: INTEGER', + name: 'ranIterations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'didConverge :: BOOLEAN', + name: 'didConverge', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.sllpa.mutate.estimate': { + name: 'gds.sllpa.mutate.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.sllpa.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.sllpa.stats': { + name: 'gds.sllpa.stats', + description: + 'The Speaker Listener Label Propagation algorithm is a fast algorithm for finding overlapping communities in a graph.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.sllpa.stats(graphName :: STRING, configuration = {} :: MAP) :: (ranIterations :: INTEGER, didConverge :: BOOLEAN, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'ranIterations :: INTEGER', + name: 'ranIterations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'didConverge :: BOOLEAN', + name: 'didConverge', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.sllpa.stats.estimate': { + name: 'gds.sllpa.stats.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.sllpa.stats.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.sllpa.stream': { + name: 'gds.sllpa.stream', + description: + 'The Speaker Listener Label Propagation algorithm is a fast algorithm for finding overlapping communities in a graph.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.sllpa.stream(graphName :: STRING, configuration = {} :: MAP) :: (nodeId :: INTEGER, values :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeId :: INTEGER', + name: 'nodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'values :: MAP', + name: 'values', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.sllpa.stream.estimate': { + name: 'gds.sllpa.stream.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.sllpa.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.sllpa.write': { + name: 'gds.sllpa.write', + description: + 'The Speaker Listener Label Propagation algorithm is a fast algorithm for finding overlapping communities in a graph.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.sllpa.write(graphName :: STRING, configuration = {} :: MAP) :: (nodePropertiesWritten :: INTEGER, ranIterations :: INTEGER, didConverge :: BOOLEAN, writeMillis :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'ranIterations :: INTEGER', + name: 'ranIterations', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'didConverge :: BOOLEAN', + name: 'didConverge', + type: 'BOOLEAN', + }, + { + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.sllpa.write.estimate': { + name: 'gds.sllpa.write.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.sllpa.write.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.spanningTree.mutate': { + name: 'gds.spanningTree.mutate', + description: + 'The spanning tree algorithm visits all nodes that are in the same connected component as the starting node, and returns a spanning tree of all nodes in the component where the total weight of the relationships is either minimized or maximized.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.spanningTree.mutate(graphName :: STRING, configuration = {} :: MAP) :: (mutateMillis :: INTEGER, relationshipsWritten :: INTEGER, effectiveNodeCount :: INTEGER, totalWeight :: FLOAT, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipsWritten :: INTEGER', + name: 'relationshipsWritten', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'effectiveNodeCount :: INTEGER', + name: 'effectiveNodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'totalWeight :: FLOAT', + name: 'totalWeight', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.spanningTree.mutate.estimate': { + name: 'gds.spanningTree.mutate.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.spanningTree.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.spanningTree.stats': { + name: 'gds.spanningTree.stats', + description: + 'The spanning tree algorithm visits all nodes that are in the same connected component as the starting node, and returns a spanning tree of all nodes in the component where the total weight of the relationships is either minimized or maximized.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.spanningTree.stats(graphName :: STRING, configuration = {} :: MAP) :: (effectiveNodeCount :: INTEGER, totalWeight :: FLOAT, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ + { + isDeprecated: false, + description: 'effectiveNodeCount :: INTEGER', + name: 'effectiveNodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'totalWeight :: FLOAT', + name: 'totalWeight', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.spanningTree.stats.estimate': { + name: 'gds.spanningTree.stats.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.spanningTree.stats.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', + }, + { + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', + }, + { + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', + }, + { + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.spanningTree.stream': { + name: 'gds.spanningTree.stream', + description: + 'The spanning tree algorithm visits all nodes that are in the same connected component as the starting node, and returns a spanning tree of all nodes in the component where the total weight of the relationships is either minimized or maximized.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, + { + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', + }, + ], + signature: + 'gds.spanningTree.stream(graphName :: STRING, configuration = {} :: MAP) :: (nodeId :: INTEGER, parentId :: INTEGER, weight :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'nodeId :: INTEGER', + name: 'nodeId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'parentId :: INTEGER', + name: 'parentId', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'weight :: FLOAT', + name: 'weight', + type: 'FLOAT', + }, + ], + admin: false, + option: { + deprecated: false, + }, + }, + 'gds.spanningTree.stream.estimate': { + name: 'gds.spanningTree.stream.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', + }, + ], + signature: + 'gds.spanningTree.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ + { + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', + }, { - label: 'startNode', - documentation: 'startNode :: NODE', + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', }, { - label: 'relType', - documentation: 'relType :: STRING', + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', }, { - label: 'identProps', - documentation: 'identProps :: MAP', + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', }, { - label: 'onCreateProps', - documentation: 'onCreateProps :: MAP', + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', }, { - label: 'endNode', - documentation: 'endNode :: NODE', + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', }, { - label: 'onMatchProps', - documentation: 'onMatchProps = {} :: MAP', + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', }, - ], - }, - 'apoc.meta.data': { - label: 'apoc.meta.data', - documentation: 'Examines the full graph and returns a table of metadata.', - parameters: [ { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.meta.data.of': { - label: 'apoc.meta.data.of', - documentation: - 'Examines the given sub-graph and returns a table of metadata.', - parameters: [ + 'gds.spanningTree.write': { + name: 'gds.spanningTree.write', + description: + 'The spanning tree algorithm visits all nodes that are in the same connected component as the starting node, and returns a spanning tree of all nodes in the component where the total weight of the relationships is either minimized or maximized.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ { - label: 'graph', - documentation: 'graph :: ANY', + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', }, ], - }, - 'apoc.meta.graph': { - label: 'apoc.meta.graph', - documentation: 'Examines the full graph and returns a meta-graph.', - parameters: [ + signature: + 'gds.spanningTree.write(graphName :: STRING, configuration = {} :: MAP) :: (writeMillis :: INTEGER, relationshipsWritten :: INTEGER, effectiveNodeCount :: INTEGER, totalWeight :: FLOAT, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', }, - ], - }, - 'apoc.meta.graph.of': { - label: 'apoc.meta.graph.of', - documentation: 'Examines the given sub-graph and returns a meta-graph.', - parameters: [ { - label: 'graph', - documentation: 'graph = {} :: ANY', + isDeprecated: false, + description: 'relationshipsWritten :: INTEGER', + name: 'relationshipsWritten', + type: 'INTEGER', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'effectiveNodeCount :: INTEGER', + name: 'effectiveNodeCount', + type: 'INTEGER', }, - ], - }, - 'apoc.meta.graphSample': { - label: 'apoc.meta.graphSample', - documentation: - 'Examines the full graph and returns a meta-graph.\nUnlike `apoc.meta.graph`, this procedure does not filter away non-existing paths.', - parameters: [ { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'totalWeight :: FLOAT', + name: 'totalWeight', + type: 'FLOAT', }, - ], - }, - 'apoc.meta.nodeTypeProperties': { - label: 'apoc.meta.nodeTypeProperties', - documentation: - 'Examines the full graph and returns a table of metadata with information about the `NODE` values therein.', - parameters: [ { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', }, - ], - }, - 'apoc.meta.relTypeProperties': { - label: 'apoc.meta.relTypeProperties', - documentation: - 'Examines the full graph and returns a table of metadata with information about the `RELATIONSHIP` values therein.', - parameters: [ { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', }, - ], - }, - 'apoc.meta.schema': { - label: 'apoc.meta.schema', - documentation: - 'Examines the given sub-graph and returns metadata as a `MAP`.', - parameters: [ { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.meta.stats': { - label: 'apoc.meta.stats', - documentation: - 'Returns the metadata stored in the transactional database statistics.', - parameters: [], - }, - 'apoc.meta.subGraph': { - label: 'apoc.meta.subGraph', - documentation: 'Examines the given sub-graph and returns a meta-graph.', - parameters: [ + 'gds.spanningTree.write.estimate': { + name: 'gds.spanningTree.write.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ { - label: 'config', - documentation: 'config :: MAP', + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', + }, + { + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', }, ], - }, - 'apoc.neighbors.athop': { - label: 'apoc.neighbors.athop', - documentation: - 'Returns all `NODE` values connected by the given `RELATIONSHIP` types at the specified distance.', - parameters: [ + signature: + 'gds.spanningTree.write.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ { - label: 'node', - documentation: 'node :: NODE', + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', }, { - label: 'relTypes', - documentation: 'relTypes = :: STRING', + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', }, { - label: 'distance', - documentation: 'distance = 1 :: INTEGER', + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', }, - ], - }, - 'apoc.neighbors.athop.count': { - label: 'apoc.neighbors.athop.count', - documentation: - 'Returns the count of all `NODE` values connected by the given `RELATIONSHIP` types at the specified distance.', - parameters: [ { - label: 'node', - documentation: 'node :: NODE', + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', }, { - label: 'relTypes', - documentation: 'relTypes = :: STRING', + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', }, { - label: 'distance', - documentation: 'distance = 1 :: INTEGER', + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', }, - ], - }, - 'apoc.neighbors.byhop': { - label: 'apoc.neighbors.byhop', - documentation: - 'Returns all `NODE` values connected by the given `RELATIONSHIP` types within the specified distance. Returns `LIST` values, where each `PATH` of `NODE` values represents one row of the `LIST` values.', - parameters: [ { - label: 'node', - documentation: 'node :: NODE', + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', }, { - label: 'relTypes', - documentation: 'relTypes = :: STRING', + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', }, { - label: 'distance', - documentation: 'distance = 1 :: INTEGER', + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.neighbors.byhop.count': { - label: 'apoc.neighbors.byhop.count', - documentation: - 'Returns the count of all `NODE` values connected by the given `RELATIONSHIP` types within the specified distance.', - parameters: [ + 'gds.steinerTree.mutate': { + name: 'gds.steinerTree.mutate', + description: + 'The steiner tree algorithm accepts a source node, as well as a list of target nodes. It then attempts to find a spanning tree where there is a path from the source node to each target node, such that the total weight of the relationships is as low as possible.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, { - label: 'node', - documentation: 'node :: NODE', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', }, + ], + signature: + 'gds.steinerTree.mutate(graphName :: STRING, configuration = {} :: MAP) :: (mutateMillis :: INTEGER, relationshipsWritten :: INTEGER, effectiveNodeCount :: INTEGER, effectiveTargetNodesCount :: INTEGER, totalWeight :: FLOAT, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ { - label: 'relTypes', - documentation: 'relTypes = :: STRING', + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', }, { - label: 'distance', - documentation: 'distance = 1 :: INTEGER', + isDeprecated: false, + description: 'relationshipsWritten :: INTEGER', + name: 'relationshipsWritten', + type: 'INTEGER', }, - ], - }, - 'apoc.neighbors.tohop': { - label: 'apoc.neighbors.tohop', - documentation: - 'Returns all `NODE` values connected by the given `RELATIONSHIP` types within the specified distance.\n`NODE` values are returned individually for each row.', - parameters: [ { - label: 'node', - documentation: 'node :: NODE', + isDeprecated: false, + description: 'effectiveNodeCount :: INTEGER', + name: 'effectiveNodeCount', + type: 'INTEGER', }, { - label: 'relTypes', - documentation: 'relTypes = :: STRING', + isDeprecated: false, + description: 'effectiveTargetNodesCount :: INTEGER', + name: 'effectiveTargetNodesCount', + type: 'INTEGER', }, { - label: 'distance', - documentation: 'distance = 1 :: INTEGER', + isDeprecated: false, + description: 'totalWeight :: FLOAT', + name: 'totalWeight', + type: 'FLOAT', }, - ], - }, - 'apoc.neighbors.tohop.count': { - label: 'apoc.neighbors.tohop.count', - documentation: - 'Returns the count of all `NODE` values connected by the given `RELATIONSHIP` values in the pattern within the specified distance.', - parameters: [ { - label: 'node', - documentation: 'node :: NODE', + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', }, { - label: 'relTypes', - documentation: 'relTypes = :: STRING', + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', }, { - label: 'distance', - documentation: 'distance = 1 :: INTEGER', + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.nodes.collapse': { - label: 'apoc.nodes.collapse', - documentation: - 'Merges `NODE` values together in the given `LIST`.\nThe `NODE` values are then combined to become one `NODE`, with all labels of the previous `NODE` values attached to it, and all `RELATIONSHIP` values pointing to it.', - parameters: [ + 'gds.steinerTree.mutate.estimate': { + name: 'gds.steinerTree.mutate.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ { - label: 'nodes', - documentation: 'nodes :: LIST', + isDeprecated: false, + description: 'graphName :: ANY', + name: 'graphName', + type: 'ANY', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', }, ], - }, - 'apoc.nodes.cycles': { - label: 'apoc.nodes.cycles', - documentation: - 'Detects all `PATH` cycles in the given `LIST`.\nThis procedure can be limited on `RELATIONSHIP` values as well.', - parameters: [ + signature: + 'gds.steinerTree.mutate.estimate(graphName :: ANY, configuration = {} :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ { - label: 'nodes', - documentation: 'nodes :: LIST', + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', }, - ], - }, - 'apoc.nodes.delete': { - label: 'apoc.nodes.delete', - documentation: 'Deletes all `NODE` values with the given ids.', - parameters: [ { - label: 'nodes', - documentation: 'nodes :: ANY', + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', }, { - label: 'batchSize', - documentation: 'batchSize :: INTEGER', + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', }, - ], - }, - 'apoc.nodes.get': { - label: 'apoc.nodes.get', - documentation: 'Returns all `NODE` values with the given ids.', - parameters: [ { - label: 'nodes', - documentation: 'nodes :: ANY', + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', }, - ], - }, - 'apoc.nodes.group': { - label: 'apoc.nodes.group', - documentation: - 'Allows for the aggregation of `NODE` values based on the given properties.\nThis procedure returns virtual `NODE` values.', - parameters: [ { - label: 'labels', - documentation: 'labels :: LIST', + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', }, { - label: 'groupByProperties', - documentation: 'groupByProperties :: LIST', + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', }, { - label: 'aggregations', - documentation: 'aggregations = [{*=count}, {*=count}] :: LIST', + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.nodes.link': { - label: 'apoc.nodes.link', - documentation: - 'Creates a linked list of the given `NODE` values connected by the given `RELATIONSHIP` type.', - parameters: [ - { - label: 'nodes', - documentation: 'nodes :: LIST', - }, + 'gds.steinerTree.stats': { + name: 'gds.steinerTree.stats', + description: + 'The steiner tree algorithm accepts a source node, as well as a list of target nodes. It then attempts to find a spanning tree where there is a path from the source node to each target node, such that the total weight of the relationships is as low as possible.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ { - label: 'type', - documentation: 'type :: STRING', + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', }, ], - }, - 'apoc.nodes.rels': { - label: 'apoc.nodes.rels', - documentation: 'Returns all `RELATIONSHIP` values with the given ids.', - parameters: [ + signature: + 'gds.steinerTree.stats(graphName :: STRING, configuration = {} :: MAP) :: (effectiveNodeCount :: INTEGER, effectiveTargetNodesCount :: INTEGER, totalWeight :: FLOAT, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ { - label: 'rels', - documentation: 'rels :: ANY', + isDeprecated: false, + description: 'effectiveNodeCount :: INTEGER', + name: 'effectiveNodeCount', + type: 'INTEGER', }, - ], - }, - 'apoc.path.expand': { - label: 'apoc.path.expand', - documentation: - 'Returns `PATH` values expanded from the start `NODE` following the given `RELATIONSHIP` types from min-depth to max-depth.', - parameters: [ { - label: 'startNode', - documentation: 'startNode :: ANY', + isDeprecated: false, + description: 'effectiveTargetNodesCount :: INTEGER', + name: 'effectiveTargetNodesCount', + type: 'INTEGER', }, { - label: 'relFilter', - documentation: 'relFilter :: STRING', + isDeprecated: false, + description: 'totalWeight :: FLOAT', + name: 'totalWeight', + type: 'FLOAT', }, { - label: 'labelFilter', - documentation: 'labelFilter :: STRING', + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', }, { - label: 'minDepth', - documentation: 'minDepth :: INTEGER', + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', }, { - label: 'maxDepth', - documentation: 'maxDepth :: INTEGER', + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.path.expandConfig': { - label: 'apoc.path.expandConfig', - documentation: - 'Returns `PATH` values expanded from the start `NODE` with the given `RELATIONSHIP` types from min-depth to max-depth.', - parameters: [ + 'gds.steinerTree.stats.estimate': { + name: 'gds.steinerTree.stats.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ { - label: 'startNode', - documentation: 'startNode :: ANY', + isDeprecated: false, + description: 'graphName :: ANY', + name: 'graphName', + type: 'ANY', }, { - label: 'config', - documentation: 'config :: MAP', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', }, ], - }, - 'apoc.path.spanningTree': { - label: 'apoc.path.spanningTree', - documentation: - 'Returns spanning tree `PATH` values expanded from the start `NODE` following the given `RELATIONSHIP` types to max-depth.', - parameters: [ + signature: + 'gds.steinerTree.stats.estimate(graphName :: ANY, configuration = {} :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ { - label: 'startNode', - documentation: 'startNode :: ANY', + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', }, { - label: 'config', - documentation: 'config :: MAP', + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', }, - ], - }, - 'apoc.path.subgraphAll': { - label: 'apoc.path.subgraphAll', - documentation: - 'Returns the sub-graph reachable from the start `NODE` following the given `RELATIONSHIP` types to max-depth.', - parameters: [ { - label: 'startNode', - documentation: 'startNode :: ANY', + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', }, { - label: 'config', - documentation: 'config :: MAP', + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', }, - ], - }, - 'apoc.path.subgraphNodes': { - label: 'apoc.path.subgraphNodes', - documentation: - 'Returns the `NODE` values in the sub-graph reachable from the start `NODE` following the given `RELATIONSHIP` types to max-depth.', - parameters: [ { - label: 'startNode', - documentation: 'startNode :: ANY', + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', }, { - label: 'config', - documentation: 'config :: MAP', + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', }, - ], - }, - 'apoc.periodic.cancel': { - label: 'apoc.periodic.cancel', - documentation: 'Cancels the given background job.', - parameters: [ { - label: 'name', - documentation: 'name :: STRING', + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.periodic.commit': { - label: 'apoc.periodic.commit', - documentation: - 'Runs the given statement in separate batched transactions.', - parameters: [ + 'gds.steinerTree.stream': { + name: 'gds.steinerTree.stream', + description: + 'The steiner tree algorithm accepts a source node, as well as a list of target nodes. It then attempts to find a spanning tree where there is a path from the source node to each target node, such that the total weight of the relationships is as low as possible.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ { - label: 'statement', - documentation: 'statement :: STRING', + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', }, { - label: 'params', - documentation: 'params = {} :: MAP', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', }, ], - }, - 'apoc.periodic.countdown': { - label: 'apoc.periodic.countdown', - documentation: - 'Runs a repeatedly called background statement until it returns 0.', - parameters: [ + signature: + 'gds.steinerTree.stream(graphName :: STRING, configuration = {} :: MAP) :: (nodeId :: INTEGER, parentId :: INTEGER, weight :: FLOAT)', + returnDescription: [ { - label: 'name', - documentation: 'name :: STRING', + isDeprecated: false, + description: 'nodeId :: INTEGER', + name: 'nodeId', + type: 'INTEGER', }, { - label: 'statement', - documentation: 'statement :: STRING', + isDeprecated: false, + description: 'parentId :: INTEGER', + name: 'parentId', + type: 'INTEGER', }, { - label: 'delay', - documentation: 'delay :: INTEGER', + isDeprecated: false, + description: 'weight :: FLOAT', + name: 'weight', + type: 'FLOAT', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.periodic.iterate': { - label: 'apoc.periodic.iterate', - documentation: - 'Runs the second statement for each item returned by the first statement.\nThis procedure returns the number of batches and the total number of processed rows.', - parameters: [ + 'gds.steinerTree.stream.estimate': { + name: 'gds.steinerTree.stream.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ { - label: 'cypherIterate', - documentation: 'cypherIterate :: STRING', + isDeprecated: false, + description: 'graphName :: ANY', + name: 'graphName', + type: 'ANY', }, { - label: 'cypherAction', - documentation: 'cypherAction :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', }, + ], + signature: + 'gds.steinerTree.stream.estimate(graphName :: ANY, configuration = {} :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ { - label: 'config', - documentation: 'config :: MAP', + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', }, - ], - }, - 'apoc.periodic.list': { - label: 'apoc.periodic.list', - documentation: 'Returns a `LIST` of all background jobs.', - parameters: [], - }, - 'apoc.periodic.repeat': { - label: 'apoc.periodic.repeat', - documentation: - 'Runs a repeatedly called background job.\nTo stop this procedure, use `apoc.periodic.cancel`.', - parameters: [ { - label: 'name', - documentation: 'name :: STRING', + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', }, { - label: 'statement', - documentation: 'statement :: STRING', + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', }, { - label: 'rate', - documentation: 'rate :: INTEGER', + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', }, - ], - }, - 'apoc.periodic.submit': { - label: 'apoc.periodic.submit', - documentation: - 'Creates a background job which runs the given Cypher statement once.', - parameters: [ { - label: 'name', - documentation: 'name :: STRING', + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', }, { - label: 'statement', - documentation: 'statement :: STRING', + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', }, { - label: 'params', - documentation: 'params = {} :: MAP', + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', }, - ], - }, - 'apoc.periodic.truncate': { - label: 'apoc.periodic.truncate', - documentation: - 'Removes all entities (and optionally indexes and constraints) from the database using the `apoc.periodic.iterate` procedure.', - parameters: [ { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.refactor.categorize': { - label: 'apoc.refactor.categorize', - documentation: - 'Creates new category `NODE` values from `NODE` values in the graph with the specified `sourceKey` as one of its property keys.\nThe new category `NODE` values are then connected to the original `NODE` values with a `RELATIONSHIP` of the given type.', - parameters: [ + 'gds.steinerTree.write': { + name: 'gds.steinerTree.write', + description: + 'The steiner tree algorithm accepts a source node, as well as a list of target nodes. It then attempts to find a spanning tree where there is a path from the source node to each target node, such that the total weight of the relationships is as low as possible.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ { - label: 'sourceKey', - documentation: 'sourceKey :: STRING', + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', }, { - label: 'type', - documentation: 'type :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', }, + ], + signature: + 'gds.steinerTree.write(graphName :: STRING, configuration = {} :: MAP) :: (writeMillis :: INTEGER, relationshipsWritten :: INTEGER, effectiveNodeCount :: INTEGER, effectiveTargetNodesCount :: INTEGER, totalWeight :: FLOAT, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ { - label: 'outgoing', - documentation: 'outgoing :: BOOLEAN', + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', }, { - label: 'label', - documentation: 'label :: STRING', + isDeprecated: false, + description: 'relationshipsWritten :: INTEGER', + name: 'relationshipsWritten', + type: 'INTEGER', }, { - label: 'targetKey', - documentation: 'targetKey :: STRING', + isDeprecated: false, + description: 'effectiveNodeCount :: INTEGER', + name: 'effectiveNodeCount', + type: 'INTEGER', }, { - label: 'copiedKeys', - documentation: 'copiedKeys :: LIST', + isDeprecated: false, + description: 'effectiveTargetNodesCount :: INTEGER', + name: 'effectiveTargetNodesCount', + type: 'INTEGER', }, { - label: 'batchSize', - documentation: 'batchSize :: INTEGER', + isDeprecated: false, + description: 'totalWeight :: FLOAT', + name: 'totalWeight', + type: 'FLOAT', }, - ], - }, - 'apoc.refactor.cloneNodes': { - label: 'apoc.refactor.cloneNodes', - documentation: - 'Clones the given `NODE` values with their labels and properties.\nIt is possible to skip any `NODE` properties using skipProperties (note: this only skips properties on `NODE` values and not their `RELATIONSHIP` values).', - parameters: [ { - label: 'nodes', - documentation: 'nodes :: LIST', + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', }, { - label: 'withRelationships', - documentation: 'withRelationships = false :: BOOLEAN', + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', }, { - label: 'skipProperties', - documentation: 'skipProperties = [] :: LIST', + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.refactor.cloneSubgraph': { - label: 'apoc.refactor.cloneSubgraph', - documentation: - 'Clones the given `NODE` values with their labels and properties (optionally skipping any properties in the `skipProperties` `LIST` via the config `MAP`), and clones the given `RELATIONSHIP` values.\nIf no `RELATIONSHIP` values are provided, all existing `RELATIONSHIP` values between the given `NODE` values will be cloned.', - parameters: [ + 'gds.steinerTree.write.estimate': { + name: 'gds.steinerTree.write.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ { - label: 'nodes', - documentation: 'nodes :: LIST', + isDeprecated: false, + description: 'graphName :: ANY', + name: 'graphName', + type: 'ANY', }, { - label: 'rels', - documentation: 'rels = [] :: LIST', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', }, + ], + signature: + 'gds.steinerTree.write.estimate(graphName :: ANY, configuration = {} :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', }, - ], - }, - 'apoc.refactor.cloneSubgraphFromPaths': { - label: 'apoc.refactor.cloneSubgraphFromPaths', - documentation: - 'Clones a sub-graph defined by the given `LIST` values.\nIt is possible to skip any `NODE` properties using the `skipProperties` `LIST` via the config `MAP`.', - parameters: [ { - label: 'paths', - documentation: 'paths :: LIST', + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', }, - ], - }, - 'apoc.refactor.collapseNode': { - label: 'apoc.refactor.collapseNode', - documentation: - 'Collapses the given `NODE` and replaces it with a `RELATIONSHIP` of the given type.', - parameters: [ { - label: 'nodes', - documentation: 'nodes :: ANY', + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', }, { - label: 'relType', - documentation: 'relType :: STRING', + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', }, - ], - }, - 'apoc.refactor.deleteAndReconnect': { - label: 'apoc.refactor.deleteAndReconnect', - documentation: - 'Removes the given `NODE` values from the `PATH` and reconnects the remaining `NODE` values.', - parameters: [ { - label: 'path', - documentation: 'path :: PATH', + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', }, { - label: 'nodes', - documentation: 'nodes :: LIST', + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.refactor.extractNode': { - label: 'apoc.refactor.extractNode', - documentation: - 'Expands the given `RELATIONSHIP` VALUES into intermediate `NODE` VALUES.\nThe intermediate `NODE` values are connected by the given `outType` and `inType`.', - parameters: [ + 'gds.systemMonitor': { + name: 'gds.systemMonitor', + description: + "Get an overview of the system's workload and available resources", + mode: 'READ', + worksOnSystem: false, + argumentDescription: [], + signature: + 'gds.systemMonitor() :: (freeHeap :: INTEGER, totalHeap :: INTEGER, maxHeap :: INTEGER, jvmAvailableCpuCores :: INTEGER, availableCpuCoresNotRequested :: INTEGER, jvmHeapStatus :: MAP, ongoingGdsProcedures :: LIST)', + returnDescription: [ { - label: 'rels', - documentation: 'rels :: ANY', + isDeprecated: false, + description: 'freeHeap :: INTEGER', + name: 'freeHeap', + type: 'INTEGER', }, { - label: 'labels', - documentation: 'labels :: LIST', + isDeprecated: false, + description: 'totalHeap :: INTEGER', + name: 'totalHeap', + type: 'INTEGER', }, { - label: 'outType', - documentation: 'outType :: STRING', + isDeprecated: false, + description: 'maxHeap :: INTEGER', + name: 'maxHeap', + type: 'INTEGER', }, { - label: 'inType', - documentation: 'inType :: STRING', + isDeprecated: false, + description: 'jvmAvailableCpuCores :: INTEGER', + name: 'jvmAvailableCpuCores', + type: 'INTEGER', }, - ], - }, - 'apoc.refactor.from': { - label: 'apoc.refactor.from', - documentation: - 'Redirects the given `RELATIONSHIP` to the given start `NODE`.', - parameters: [ { - label: 'rel', - documentation: 'rel :: RELATIONSHIP', + isDeprecated: false, + description: 'availableCpuCoresNotRequested :: INTEGER', + name: 'availableCpuCoresNotRequested', + type: 'INTEGER', }, { - label: 'newNode', - documentation: 'newNode :: NODE', + isDeprecated: false, + description: 'jvmHeapStatus :: MAP', + name: 'jvmHeapStatus', + type: 'MAP', }, - ], - }, - 'apoc.refactor.invert': { - label: 'apoc.refactor.invert', - documentation: 'Inverts the direction of the given `RELATIONSHIP`.', - parameters: [ { - label: 'rel', - documentation: 'rel :: RELATIONSHIP', + isDeprecated: false, + description: 'ongoingGdsProcedures :: LIST', + name: 'ongoingGdsProcedures', + type: 'LIST', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.refactor.mergeNodes': { - label: 'apoc.refactor.mergeNodes', - documentation: - 'Merges the given `LIST` onto the first `NODE` in the `LIST`.\nAll `RELATIONSHIP` values are merged onto that `NODE` as well.', - parameters: [ + 'gds.triangleCount.mutate': { + name: 'gds.triangleCount.mutate', + description: + 'Triangle counting is a community detection graph algorithm that is used to determine the number of triangles passing through each node in the graph.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ { - label: 'nodes', - documentation: 'nodes :: LIST', + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', }, ], - }, - 'apoc.refactor.mergeRelationships': { - label: 'apoc.refactor.mergeRelationships', - documentation: - 'Merges the given `LIST` onto the first `RELATIONSHIP` in the `LIST`.', - parameters: [ - { - label: 'rels', - documentation: 'rels :: LIST', - }, + signature: + 'gds.triangleCount.mutate(graphName :: STRING, configuration = {} :: MAP) :: (mutateMillis :: INTEGER, nodePropertiesWritten :: INTEGER, globalTriangleCount :: INTEGER, nodeCount :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', }, - ], - }, - 'apoc.refactor.normalizeAsBoolean': { - label: 'apoc.refactor.normalizeAsBoolean', - documentation: 'Refactors the given property to a `BOOLEAN`.', - parameters: [ { - label: 'entity', - documentation: 'entity :: ANY', + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', }, { - label: 'propertyKey', - documentation: 'propertyKey :: STRING', + isDeprecated: false, + description: 'globalTriangleCount :: INTEGER', + name: 'globalTriangleCount', + type: 'INTEGER', }, { - label: 'trueValues', - documentation: 'trueValues :: LIST', + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', }, { - label: 'falseValues', - documentation: 'falseValues :: LIST', + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', }, - ], - }, - 'apoc.refactor.rename.label': { - label: 'apoc.refactor.rename.label', - documentation: - 'Renames the given label from `oldLabel` to `newLabel` for all `NODE` values.\nIf a `LIST` is provided, the renaming is applied to the `NODE` values within this `LIST` only.', - parameters: [ { - label: 'oldLabel', - documentation: 'oldLabel :: STRING', + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', }, { - label: 'newLabel', - documentation: 'newLabel :: STRING', + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', }, { - label: 'nodes', - documentation: 'nodes = [] :: LIST', + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.refactor.rename.nodeProperty': { - label: 'apoc.refactor.rename.nodeProperty', - documentation: - 'Renames the given property from `oldName` to `newName` for all `NODE` values.\nIf a `LIST` is provided, the renaming is applied to the `NODE` values within this `LIST` only.', - parameters: [ - { - label: 'oldName', - documentation: 'oldName :: STRING', - }, + 'gds.triangleCount.mutate.estimate': { + name: 'gds.triangleCount.mutate.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ { - label: 'newName', - documentation: 'newName :: STRING', + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', }, { - label: 'nodes', - documentation: 'nodes = [] :: LIST', + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', }, + ], + signature: + 'gds.triangleCount.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', }, - ], - }, - 'apoc.refactor.rename.type': { - label: 'apoc.refactor.rename.type', - documentation: - 'Renames all `RELATIONSHIP` values with type `oldType` to `newType`.\nIf a `LIST` is provided, the renaming is applied to the `RELATIONSHIP` values within this `LIST` only.', - parameters: [ { - label: 'oldType', - documentation: 'oldType :: STRING', + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', }, { - label: 'newType', - documentation: 'newType :: STRING', + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', }, { - label: 'rels', - documentation: 'rels = [] :: LIST', + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', }, - ], - }, - 'apoc.refactor.rename.typeProperty': { - label: 'apoc.refactor.rename.typeProperty', - documentation: - 'Renames the given property from `oldName` to `newName` for all `RELATIONSHIP` values.\nIf a `LIST` is provided, the renaming is applied to the `RELATIONSHIP` values within this `LIST` only.', - parameters: [ { - label: 'oldName', - documentation: 'oldName :: STRING', + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', }, { - label: 'newName', - documentation: 'newName :: STRING', + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', }, { - label: 'rels', - documentation: 'rels = [] :: LIST', + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.refactor.setType': { - label: 'apoc.refactor.setType', - documentation: 'Changes the type of the given `RELATIONSHIP`.', - parameters: [ + 'gds.triangleCount.stats': { + name: 'gds.triangleCount.stats', + description: + 'Triangle counting is a community detection graph algorithm that is used to determine the number of triangles passing through each node in the graph.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ { - label: 'rel', - documentation: 'rel :: RELATIONSHIP', + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', }, { - label: 'newType', - documentation: 'newType :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', }, ], - }, - 'apoc.refactor.to': { - label: 'apoc.refactor.to', - documentation: - 'Redirects the given `RELATIONSHIP` to the given end `NODE`.', - parameters: [ + signature: + 'gds.triangleCount.stats(graphName :: STRING, configuration = {} :: MAP) :: (globalTriangleCount :: INTEGER, nodeCount :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ { - label: 'rel', - documentation: 'rel :: RELATIONSHIP', + isDeprecated: false, + description: 'globalTriangleCount :: INTEGER', + name: 'globalTriangleCount', + type: 'INTEGER', }, { - label: 'endNode', - documentation: 'endNode :: NODE', + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', }, - ], - }, - 'apoc.schema.assert': { - label: 'apoc.schema.assert', - documentation: - 'Drops all other existing indexes and constraints when `dropExisting` is `true` (default is `true`).\nAsserts at the end of the operation that the given indexes and unique constraints are there.', - parameters: [ { - label: 'indexes', - documentation: 'indexes :: MAP', + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', }, { - label: 'constraints', - documentation: 'constraints :: MAP', + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', }, { - label: 'dropExisting', - documentation: 'dropExisting = true :: BOOLEAN', + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', }, - ], - }, - 'apoc.schema.nodes': { - label: 'apoc.schema.nodes', - documentation: - 'Returns all indexes and constraints information for all `NODE` labels in the database.\nIt is possible to define a set of labels to include or exclude in the config parameters.', - parameters: [ { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.schema.properties.distinct': { - label: 'apoc.schema.properties.distinct', - documentation: - 'Returns all distinct `NODE` property values for the given key.', - parameters: [ + 'gds.triangleCount.stats.estimate': { + name: 'gds.triangleCount.stats.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ { - label: 'label', - documentation: 'label :: STRING', + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', }, { - label: 'key', - documentation: 'key :: STRING', + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', }, ], - }, - 'apoc.schema.properties.distinctCount': { - label: 'apoc.schema.properties.distinctCount', - documentation: - 'Returns all distinct property values and counts for the given key.', - parameters: [ + signature: + 'gds.triangleCount.stats.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ { - label: 'label', - documentation: 'label = :: STRING', + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', }, { - label: 'key', - documentation: 'key = :: STRING', + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', }, - ], - }, - 'apoc.schema.relationships': { - label: 'apoc.schema.relationships', - documentation: - 'Returns the indexes and constraints information for all the relationship types in the database.\nIt is possible to define a set of relationship types to include or exclude in the config parameters.', - parameters: [ { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', }, - ], - }, - 'apoc.search.multiSearchReduced': { - label: 'apoc.search.multiSearchReduced', - documentation: - 'Returns a reduced representation of the `NODE` values found after a parallel search over multiple indexes.\nThe reduced `NODE` values representation includes: node id, node labels, and the searched properties.', - parameters: [ { - label: 'labelPropertyMap', - documentation: 'labelPropertyMap :: ANY', + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', }, { - label: 'operator', - documentation: 'operator :: STRING', + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', }, { - label: 'value', - documentation: 'value :: STRING', + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', }, - ], - }, - 'apoc.search.node': { - label: 'apoc.search.node', - documentation: - 'Returns all the distinct `NODE` values found after a parallel search over multiple indexes.', - parameters: [ { - label: 'labelPropertyMap', - documentation: 'labelPropertyMap :: ANY', + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', }, { - label: 'operator', - documentation: 'operator :: STRING', + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', }, { - label: 'value', - documentation: 'value :: STRING', + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.search.nodeAll': { - label: 'apoc.search.nodeAll', - documentation: - 'Returns all the `NODE` values found after a parallel search over multiple indexes.', - parameters: [ + 'gds.triangleCount.stream': { + name: 'gds.triangleCount.stream', + description: + 'Triangle counting is a community detection graph algorithm that is used to determine the number of triangles passing through each node in the graph.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ + { + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', + }, { - label: 'labelPropertyMap', - documentation: 'labelPropertyMap :: ANY', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', }, + ], + signature: + 'gds.triangleCount.stream(graphName :: STRING, configuration = {} :: MAP) :: (nodeId :: INTEGER, triangleCount :: INTEGER)', + returnDescription: [ { - label: 'operator', - documentation: 'operator :: STRING', + isDeprecated: false, + description: 'nodeId :: INTEGER', + name: 'nodeId', + type: 'INTEGER', }, { - label: 'value', - documentation: 'value :: STRING', + isDeprecated: false, + description: 'triangleCount :: INTEGER', + name: 'triangleCount', + type: 'INTEGER', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.search.nodeAllReduced': { - label: 'apoc.search.nodeAllReduced', - documentation: - 'Returns a reduced representation of the `NODE` values found after a parallel search over multiple indexes.\nThe reduced `NODE` values representation includes: node id, node labels, and the searched properties.', - parameters: [ + 'gds.triangleCount.stream.estimate': { + name: 'gds.triangleCount.stream.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ { - label: 'labelPropertyMap', - documentation: 'labelPropertyMap :: ANY', + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', }, { - label: 'operator', - documentation: 'operator :: STRING', + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', }, + ], + signature: + 'gds.triangleCount.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ { - label: 'value', - documentation: 'value :: ANY', + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', }, - ], - }, - 'apoc.search.nodeReduced': { - label: 'apoc.search.nodeReduced', - documentation: - 'Returns a reduced representation of the distinct `NODE` values found after a parallel search over multiple indexes.\nThe reduced `NODE` values representation includes: node id, node labels, and the searched properties.', - parameters: [ { - label: 'labelPropertyMap', - documentation: 'labelPropertyMap :: ANY', + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', }, { - label: 'operator', - documentation: 'operator :: STRING', + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', }, { - label: 'value', - documentation: 'value :: STRING', + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', }, - ], - }, - 'apoc.spatial.geocode': { - label: 'apoc.spatial.geocode', - documentation: - 'Returns the geographic location (latitude, longitude, and description) of the given address using a geocoding service (default: OpenStreetMap).', - parameters: [ { - label: 'location', - documentation: 'location :: STRING', + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', }, { - label: 'maxResults', - documentation: 'maxResults = 100 :: INTEGER', + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', }, { - label: 'quotaException', - documentation: 'quotaException = false :: BOOLEAN', + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.spatial.geocodeOnce': { - label: 'apoc.spatial.geocodeOnce', - documentation: - 'Returns the geographic location (latitude, longitude, and description) of the given address using a geocoding service (default: OpenStreetMap).\nThis procedure returns at most one result.', - parameters: [ + 'gds.triangleCount.write': { + name: 'gds.triangleCount.write', + description: + 'Triangle counting is a community detection graph algorithm that is used to determine the number of triangles passing through each node in the graph.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ { - label: 'location', - documentation: 'location :: STRING', + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', }, ], - }, - 'apoc.spatial.reverseGeocode': { - label: 'apoc.spatial.reverseGeocode', - documentation: - 'Returns a textual address from the given geographic location (latitude, longitude) using a geocoding service (default: OpenStreetMap).\nThis procedure returns at most one result.', - parameters: [ + signature: + 'gds.triangleCount.write(graphName :: STRING, configuration = {} :: MAP) :: (writeMillis :: INTEGER, nodePropertiesWritten :: INTEGER, globalTriangleCount :: INTEGER, nodeCount :: INTEGER, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ { - label: 'latitude', - documentation: 'latitude :: FLOAT', + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', }, { - label: 'longitude', - documentation: 'longitude :: FLOAT', + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', }, { - label: 'quotaException', - documentation: 'quotaException = false :: BOOLEAN', + isDeprecated: false, + description: 'globalTriangleCount :: INTEGER', + name: 'globalTriangleCount', + type: 'INTEGER', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', }, - ], - }, - 'apoc.spatial.sortByDistance': { - label: 'apoc.spatial.sortByDistance', - documentation: - 'Sorts the given collection of `PATH` values by the sum of their distance based on the latitude/longitude values in the `NODE` values.', - parameters: [ { - label: 'paths', - documentation: 'paths :: LIST', + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', }, - ], - }, - 'apoc.stats.degrees': { - label: 'apoc.stats.degrees', - documentation: - 'Returns the percentile groupings of the degrees on the `NODE` values connected by the given `RELATIONSHIP` types.', - parameters: [ { - label: 'relTypes', - documentation: 'relTypes = :: STRING', + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', }, - ], - }, - 'apoc.text.phoneticDelta': { - label: 'apoc.text.phoneticDelta', - documentation: - 'Returns the US_ENGLISH soundex character difference between the two given `STRING` values.', - parameters: [ { - label: 'text1', - documentation: 'text1 :: STRING', + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', }, { - label: 'text2', - documentation: 'text2 :: STRING', + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.trigger.add': { - label: 'apoc.trigger.add', - documentation: - "Adds a trigger to the given Cypher statement.\nThe selector for this procedure is {phase:'before/after/rollback/afterAsync'}.", - parameters: [ - { - label: 'name', - documentation: 'name :: STRING', - }, + 'gds.triangleCount.write.estimate': { + name: 'gds.triangleCount.write.estimate', + description: + 'Triangle counting is a community detection graph algorithm that is used to determine the number of triangles passing through each node in the graph.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ { - label: 'statement', - documentation: 'statement :: STRING', + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', }, { - label: 'selector', - documentation: 'selector :: MAP', + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', }, + ], + signature: + 'gds.triangleCount.write.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', }, - ], - }, - 'apoc.trigger.drop': { - label: 'apoc.trigger.drop', - documentation: 'Eventually removes the given trigger.', - parameters: [ { - label: 'databaseName', - documentation: 'databaseName :: STRING', + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', }, { - label: 'name', - documentation: 'name :: STRING', + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', }, - ], - }, - 'apoc.trigger.dropAll': { - label: 'apoc.trigger.dropAll', - documentation: 'Eventually removes all triggers from the given database.', - parameters: [ { - label: 'databaseName', - documentation: 'databaseName :: STRING', + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', }, - ], - }, - 'apoc.trigger.install': { - label: 'apoc.trigger.install', - documentation: - 'Eventually adds a trigger for a given database which is invoked when a successful transaction occurs.', - parameters: [ { - label: 'databaseName', - documentation: 'databaseName :: STRING', + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', }, { - label: 'name', - documentation: 'name :: STRING', + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', }, { - label: 'statement', - documentation: 'statement :: STRING', + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', }, { - label: 'selector', - documentation: 'selector :: MAP', + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.trigger.list': { - label: 'apoc.trigger.list', - documentation: - 'Lists all currently installed triggers for the session database.', - parameters: [], - }, - 'apoc.trigger.pause': { - label: 'apoc.trigger.pause', - documentation: 'Pauses the given trigger.', - parameters: [ + 'gds.triangles': { + name: 'gds.triangles', + description: + 'Triangles streams the nodeIds of each triangle in the graph.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ { - label: 'name', - documentation: 'name :: STRING', + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', }, - ], - }, - 'apoc.trigger.remove': { - label: 'apoc.trigger.remove', - documentation: 'Removes the given trigger.', - parameters: [ { - label: 'name', - documentation: 'name :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', }, ], - }, - 'apoc.trigger.removeAll': { - label: 'apoc.trigger.removeAll', - documentation: 'Removes all previously added triggers.', - parameters: [], - }, - 'apoc.trigger.resume': { - label: 'apoc.trigger.resume', - documentation: 'Resumes the given paused trigger.', - parameters: [ + signature: + 'gds.triangles(graphName :: STRING, configuration = {} :: MAP) :: (nodeA :: INTEGER, nodeB :: INTEGER, nodeC :: INTEGER)', + returnDescription: [ { - label: 'name', - documentation: 'name :: STRING', + isDeprecated: false, + description: 'nodeA :: INTEGER', + name: 'nodeA', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'nodeB :: INTEGER', + name: 'nodeB', + type: 'INTEGER', }, - ], - }, - 'apoc.trigger.show': { - label: 'apoc.trigger.show', - documentation: 'Lists all eventually installed triggers for a database.', - parameters: [ { - label: 'databaseName', - documentation: 'databaseName :: STRING', + isDeprecated: false, + description: 'nodeC :: INTEGER', + name: 'nodeC', + type: 'INTEGER', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.trigger.start': { - label: 'apoc.trigger.start', - documentation: 'Eventually restarts the given paused trigger.', - parameters: [ + 'gds.userLog': { + name: 'gds.userLog', + description: 'Log warnings and hints for currently running tasks.', + mode: 'DEFAULT', + worksOnSystem: false, + argumentDescription: [ { - label: 'databaseName', - documentation: 'databaseName :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value=, type=STRING}', + description: 'jobId = :: STRING', + name: 'jobId', + type: 'STRING', }, + ], + signature: + 'gds.userLog(jobId = :: STRING) :: (taskName :: STRING, message :: STRING, timeStarted :: LOCAL TIME)', + returnDescription: [ { - label: 'name', - documentation: 'name :: STRING', + isDeprecated: false, + description: 'taskName :: STRING', + name: 'taskName', + type: 'STRING', }, - ], - }, - 'apoc.trigger.stop': { - label: 'apoc.trigger.stop', - documentation: 'Eventually stops the given trigger.', - parameters: [ { - label: 'databaseName', - documentation: 'databaseName :: STRING', + isDeprecated: false, + description: 'message :: STRING', + name: 'message', + type: 'STRING', }, { - label: 'name', - documentation: 'name :: STRING', + isDeprecated: false, + description: 'timeStarted :: LOCAL TIME', + name: 'timeStarted', + type: 'LOCAL TIME', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.util.sleep': { - label: 'apoc.util.sleep', - documentation: - 'Causes the currently running Cypher to sleep for the given duration of milliseconds (the transaction termination is honored).', - parameters: [ + 'gds.version': { + name: 'gds.version', + description: + 'CALL gds.version() | Return the installed graph data science library version.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [], + signature: 'gds.version() :: (gdsVersion :: STRING)', + returnDescription: [ { - label: 'duration', - documentation: 'duration :: INTEGER', + isDeprecated: false, + description: 'gdsVersion :: STRING', + name: 'gdsVersion', + type: 'STRING', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'apoc.util.validate': { - label: 'apoc.util.validate', - documentation: 'If the given predicate is true an exception is thrown.', - parameters: [ + 'gds.wcc.mutate': { + name: 'gds.wcc.mutate', + description: + 'The WCC algorithm finds sets of connected nodes in an undirected graph, where all nodes in the same set form a connected component.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ { - label: 'predicate', - documentation: 'predicate :: BOOLEAN', + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', }, { - label: 'message', - documentation: 'message :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', }, + ], + signature: + 'gds.wcc.mutate(graphName :: STRING, configuration = {} :: MAP) :: (mutateMillis :: INTEGER, nodePropertiesWritten :: INTEGER, componentCount :: INTEGER, componentDistribution :: MAP, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ { - label: 'params', - documentation: 'params :: LIST', + isDeprecated: false, + description: 'mutateMillis :: INTEGER', + name: 'mutateMillis', + type: 'INTEGER', }, - ], - }, - 'apoc.warmup.run': { - label: 'apoc.warmup.run', - documentation: - 'Loads all `NODE` and `RELATIONSHIP` values in the database into memory.', - parameters: [ { - label: 'loadProperties', - documentation: 'loadProperties = false :: BOOLEAN', + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', }, { - label: 'loadDynamicProperties', - documentation: 'loadDynamicProperties = false :: BOOLEAN', + isDeprecated: false, + description: 'componentCount :: INTEGER', + name: 'componentCount', + type: 'INTEGER', }, { - label: 'loadIndexes', - documentation: 'loadIndexes = false :: BOOLEAN', + isDeprecated: false, + description: 'componentDistribution :: MAP', + name: 'componentDistribution', + type: 'MAP', }, - ], - }, - 'apoc.when': { - label: 'apoc.when', - documentation: - 'This procedure will run the read-only `ifQuery` if the conditional has evaluated to true, otherwise the `elseQuery` will run.', - parameters: [ { - label: 'condition', - documentation: 'condition :: BOOLEAN', + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', }, { - label: 'ifQuery', - documentation: 'ifQuery :: STRING', + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', }, { - label: 'elseQuery', - documentation: 'elseQuery = :: STRING', + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', }, { - label: 'params', - documentation: 'params = {} :: MAP', + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'cdc.current': { - label: 'cdc.current', - documentation: - 'Returns the current change identifier that can be used to stream changes from.', - parameters: [], - }, - 'cdc.earliest': { - label: 'cdc.earliest', - documentation: - 'Returns the earliest change identifier that can be used to stream changes from.', - parameters: [], - }, - 'cdc.query': { - label: 'cdc.query', - documentation: - 'Query changes happened from the provided change identifier.', - parameters: [ + 'gds.wcc.mutate.estimate': { + name: 'gds.wcc.mutate.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ { - label: 'from', - documentation: 'from = :: STRING', + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', }, { - label: 'selectors', - documentation: 'selectors = [] :: LIST', + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', }, ], - }, - 'db.awaitIndex': { - label: 'db.awaitIndex', - documentation: - 'Wait for an index to come online (for example: CALL db.awaitIndex("MyIndex", 300)).', - parameters: [ - { - label: 'indexName', - documentation: 'indexName :: STRING', - }, + signature: + 'gds.wcc.mutate.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ { - label: 'timeOutSeconds', - documentation: 'timeOutSeconds = 300 :: INTEGER', + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', }, - ], - }, - 'db.awaitIndexes': { - label: 'db.awaitIndexes', - documentation: - 'Wait for all indexes to come online (for example: CALL db.awaitIndexes(300)).', - parameters: [ { - label: 'timeOutSeconds', - documentation: 'timeOutSeconds = 300 :: INTEGER', + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', }, - ], - }, - 'db.checkpoint': { - label: 'db.checkpoint', - documentation: - 'Initiate and wait for a new check point, or wait any already on-going check point to complete. Note that this temporarily disables the `db.checkpoint.iops.limit` setting in order to make the check point complete faster. This might cause transaction throughput to degrade slightly, due to increased IO load.', - parameters: [], - }, - 'db.clearQueryCaches': { - label: 'db.clearQueryCaches', - documentation: 'Clears all query caches.', - parameters: [], - }, - 'db.create.setNodeVectorProperty': { - label: 'db.create.setNodeVectorProperty', - documentation: - "Set a vector property on a given node in a more space efficient representation than Cypher's SET.", - parameters: [ { - label: 'node', - documentation: 'node :: NODE', + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', }, { - label: 'key', - documentation: 'key :: STRING', + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', }, { - label: 'vector', - documentation: 'vector :: LIST', + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', }, - ], - }, - 'db.create.setVectorProperty': { - label: 'db.create.setVectorProperty', - documentation: - "Set a vector property on a given node in a more space efficient representation than Cypher's SET.", - parameters: [ { - label: 'node', - documentation: 'node :: NODE', + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', }, { - label: 'key', - documentation: 'key :: STRING', + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', }, { - label: 'vector', - documentation: 'vector :: LIST', + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', }, - ], - }, - 'db.createLabel': { - label: 'db.createLabel', - documentation: 'Create a label', - parameters: [ { - label: 'newLabel', - documentation: 'newLabel :: STRING', + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'db.createProperty': { - label: 'db.createProperty', - documentation: 'Create a Property', - parameters: [ + 'gds.wcc.stats': { + name: 'gds.wcc.stats', + description: + 'The WCC algorithm finds sets of connected nodes in an undirected graph, where all nodes in the same set form a connected component.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ { - label: 'newProperty', - documentation: 'newProperty :: STRING', + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', }, - ], - }, - 'db.createRelationshipType': { - label: 'db.createRelationshipType', - documentation: 'Create a RelationshipType', - parameters: [ { - label: 'newRelationshipType', - documentation: 'newRelationshipType :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', }, ], - }, - 'db.index.fulltext.awaitEventuallyConsistentIndexRefresh': { - label: 'db.index.fulltext.awaitEventuallyConsistentIndexRefresh', - documentation: - 'Wait for the updates from recently committed transactions to be applied to any eventually-consistent full-text indexes.', - parameters: [], - }, - 'db.index.fulltext.listAvailableAnalyzers': { - label: 'db.index.fulltext.listAvailableAnalyzers', - documentation: - 'List the available analyzers that the full-text indexes can be configured with.', - parameters: [], - }, - 'db.index.fulltext.queryNodes': { - label: 'db.index.fulltext.queryNodes', - documentation: - "Query the given full-text index. Returns the matching nodes, and their Lucene query score, ordered by score. Valid keys for the options map are: 'skip' to skip the top N results; 'limit' to limit the number of results returned; 'analyzer' to use the specified analyzer as a search analyzer for this query.", - parameters: [ + signature: + 'gds.wcc.stats(graphName :: STRING, configuration = {} :: MAP) :: (componentCount :: INTEGER, componentDistribution :: MAP, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ { - label: 'indexName', - documentation: 'indexName :: STRING', + isDeprecated: false, + description: 'componentCount :: INTEGER', + name: 'componentCount', + type: 'INTEGER', }, { - label: 'queryString', - documentation: 'queryString :: STRING', + isDeprecated: false, + description: 'componentDistribution :: MAP', + name: 'componentDistribution', + type: 'MAP', }, { - label: 'options', - documentation: 'options = {} :: MAP', + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', }, - ], - }, - 'db.index.fulltext.queryRelationships': { - label: 'db.index.fulltext.queryRelationships', - documentation: - "Query the given full-text index. Returns the matching relationships, and their Lucene query score, ordered by score. Valid keys for the options map are: 'skip' to skip the top N results; 'limit' to limit the number of results returned; 'analyzer' to use the specified analyzer as search analyzer for this query.", - parameters: [ { - label: 'indexName', - documentation: 'indexName :: STRING', + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', }, { - label: 'queryString', - documentation: 'queryString :: STRING', + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', }, { - label: 'options', - documentation: 'options = {} :: MAP', + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'db.index.vector.createNodeIndex': { - label: 'db.index.vector.createNodeIndex', - documentation: - "Create a named node vector index for the given label and property for a specified vector dimensionality.\nValid similarity functions are 'EUCLIDEAN' and 'COSINE', and are case-insensitive.\nUse the `db.index.vector.queryNodes` procedure to query the named index.\n", - parameters: [ + 'gds.wcc.stats.estimate': { + name: 'gds.wcc.stats.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ { - label: 'indexName', - documentation: 'indexName :: STRING', + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', }, { - label: 'label', - documentation: 'label :: STRING', + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', }, + ], + signature: + 'gds.wcc.stats.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ { - label: 'propertyKey', - documentation: 'propertyKey :: STRING', + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', }, { - label: 'vectorDimension', - documentation: 'vectorDimension :: INTEGER', + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', }, { - label: 'vectorSimilarityFunction', - documentation: 'vectorSimilarityFunction :: STRING', + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', }, - ], - }, - 'db.index.vector.queryNodes': { - label: 'db.index.vector.queryNodes', - documentation: - 'Query the given vector index.\nReturns requested number of nearest neighbors to the provided query vector,\nand their similarity score to that query vector, based on the configured similarity function for the index.\nThe similarity score is a value between [0, 1]; where 0 indicates least similar, 1 most similar.\n', - parameters: [ { - label: 'indexName', - documentation: 'indexName :: STRING', + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', }, { - label: 'numberOfNearestNeighbours', - documentation: 'numberOfNearestNeighbours :: INTEGER', + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', }, { - label: 'query', - documentation: 'query :: LIST', + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', }, - ], - }, - 'db.info': { - label: 'db.info', - documentation: 'Provides information regarding the database.', - parameters: [], - }, - 'db.labels': { - label: 'db.labels', - documentation: - "List all labels attached to nodes within a database according to the user's access rights. The procedure returns empty results if the user is not authorized to view those labels.", - parameters: [], - }, - 'db.listLocks': { - label: 'db.listLocks', - documentation: 'List all locks at this database.', - parameters: [], - }, - 'db.ping': { - label: 'db.ping', - documentation: - 'This procedure can be used by client side tooling to test whether they are correctly connected to a database. The procedure is available in all databases and always returns true. A faulty connection can be detected by not being able to call this procedure.', - parameters: [], - }, - 'db.prepareForReplanning': { - label: 'db.prepareForReplanning', - documentation: - 'Triggers an index resample and waits for it to complete, and after that clears query caches. After this procedure has finished queries will be planned using the latest database statistics.', - parameters: [ { - label: 'timeOutSeconds', - documentation: 'timeOutSeconds = 300 :: INTEGER', + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', }, - ], - }, - 'db.propertyKeys': { - label: 'db.propertyKeys', - documentation: 'List all property keys in the database.', - parameters: [], - }, - 'db.relationshipTypes': { - label: 'db.relationshipTypes', - documentation: - "List all types attached to relationships within a database according to the user's access rights. The procedure returns empty results if the user is not authorized to view those relationship types.", - parameters: [], - }, - 'db.resampleIndex': { - label: 'db.resampleIndex', - documentation: - 'Schedule resampling of an index (for example: CALL db.resampleIndex("MyIndex")).', - parameters: [ { - label: 'indexName', - documentation: 'indexName :: STRING', + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', }, - ], - }, - 'db.resampleOutdatedIndexes': { - label: 'db.resampleOutdatedIndexes', - documentation: 'Schedule resampling of all outdated indexes.', - parameters: [], - }, - 'db.schema.nodeTypeProperties': { - label: 'db.schema.nodeTypeProperties', - documentation: - 'Show the derived property schema of the nodes in tabular form.', - parameters: [], - }, - 'db.schema.relTypeProperties': { - label: 'db.schema.relTypeProperties', - documentation: - 'Show the derived property schema of the relationships in tabular form.', - parameters: [], - }, - 'db.schema.visualization': { - label: 'db.schema.visualization', - documentation: - 'Visualizes the schema of the data based on available statistics. A new node is returned for each label. The properties represented on the node include: `name` (label name), `indexes` (list of indexes), and `constraints` (list of constraints). A relationship of a given type is returned for all possible combinations of start and end nodes. The properties represented on the relationship include: `name` (type name). Note that this may include additional relationships that do not exist in the data due to the information available in the count store. ', - parameters: [], - }, - 'db.stats.clear': { - label: 'db.stats.clear', - documentation: - "Clear collected data of a given data section. Valid sections are 'QUERIES'", - parameters: [ { - label: 'section', - documentation: 'section :: STRING', + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'db.stats.collect': { - label: 'db.stats.collect', - documentation: - "Start data collection of a given data section. Valid sections are 'QUERIES'", - parameters: [ + 'gds.wcc.stream': { + name: 'gds.wcc.stream', + description: + 'The WCC algorithm finds sets of connected nodes in an undirected graph, where all nodes in the same set form a connected component.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ { - label: 'section', - documentation: 'section :: STRING', + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', }, ], - }, - 'db.stats.retrieve': { - label: 'db.stats.retrieve', - documentation: - "Retrieve statistical data about the current database. Valid sections are 'GRAPH COUNTS', 'TOKENS', 'QUERIES', 'META'", - parameters: [ + signature: + 'gds.wcc.stream(graphName :: STRING, configuration = {} :: MAP) :: (nodeId :: INTEGER, componentId :: INTEGER)', + returnDescription: [ { - label: 'section', - documentation: 'section :: STRING', + isDeprecated: false, + description: 'nodeId :: INTEGER', + name: 'nodeId', + type: 'INTEGER', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'componentId :: INTEGER', + name: 'componentId', + type: 'INTEGER', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'db.stats.retrieveAllAnonymized': { - label: 'db.stats.retrieveAllAnonymized', - documentation: - 'Retrieve all available statistical data about the current database, in an anonymized form.', - parameters: [ + 'gds.wcc.stream.estimate': { + name: 'gds.wcc.stream.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ { - label: 'graphToken', - documentation: 'graphToken :: STRING', + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', }, { - label: 'config', - documentation: 'config = {} :: MAP', + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', }, ], - }, - 'db.stats.status': { - label: 'db.stats.status', - documentation: - 'Retrieve the status of all available collector daemons, for this database.', - parameters: [], - }, - 'db.stats.stop': { - label: 'db.stats.stop', - documentation: - "Stop data collection of a given data section. Valid sections are 'QUERIES'", - parameters: [ + signature: + 'gds.wcc.stream.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ { - label: 'section', - documentation: 'section :: STRING', + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', }, - ], - }, - 'dbms.checkConfigValue': { - label: 'dbms.checkConfigValue', - documentation: 'Check if a potential config setting value is valid.', - parameters: [ { - label: 'setting', - documentation: 'setting :: STRING', + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', }, { - label: 'value', - documentation: 'value :: STRING', + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', }, - ], - }, - 'dbms.cluster.checkConnectivity': { - label: 'dbms.cluster.checkConnectivity', - documentation: - "Check the connectivity of this instance to other cluster members. Not all ports are relevant to all members. Valid values for 'port-name' are: [CLUSTER, RAFT]", - parameters: [ { - label: 'port-name', - documentation: 'port-name = null :: STRING', + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', }, { - label: 'server', - documentation: 'server = null :: STRING', + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', }, - ], - }, - 'dbms.cluster.cordonServer': { - label: 'dbms.cluster.cordonServer', - documentation: - 'Mark a server in the topology as not suitable for new allocations. It will not force current allocations off the server. This is useful when deallocating databases when you have multiple unavailable servers.', - parameters: [ { - label: 'server', - documentation: 'server :: STRING', + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', + }, + { + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', }, - ], - }, - 'dbms.cluster.protocols': { - label: 'dbms.cluster.protocols', - documentation: 'Overview of installed protocols', - parameters: [], - }, - 'dbms.cluster.readReplicaToggle': { - label: 'dbms.cluster.readReplicaToggle', - documentation: - 'The toggle can pause or resume read replica (deprecated in favor of dbms.cluster.secondaryReplicationDisable)', - parameters: [ { - label: 'databaseName', - documentation: 'databaseName :: STRING', + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', }, { - label: 'pause', - documentation: 'pause :: BOOLEAN', + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'dbms.cluster.routing.getRoutingTable': { - label: 'dbms.cluster.routing.getRoutingTable', - documentation: - "Returns the advertised bolt capable endpoints for a given database, divided by each endpoint's capabilities. For example, an endpoint may serve read queries, write queries, and/or future `getRoutingTable` requests.", - parameters: [ + 'gds.wcc.write': { + name: 'gds.wcc.write', + description: + 'The WCC algorithm finds sets of connected nodes in an undirected graph, where all nodes in the same set form a connected component.', + mode: 'WRITE', + worksOnSystem: false, + argumentDescription: [ { - label: 'context', - documentation: 'context :: MAP', + isDeprecated: false, + description: 'graphName :: STRING', + name: 'graphName', + type: 'STRING', }, { - label: 'database', - documentation: 'database = null :: STRING', + isDeprecated: false, + default: 'DefaultParameterValue{value={}, type=MAP}', + description: 'configuration = {} :: MAP', + name: 'configuration', + type: 'MAP', }, ], - }, - 'dbms.cluster.secondaryReplicationDisable': { - label: 'dbms.cluster.secondaryReplicationDisable', - documentation: - 'The toggle can pause or resume the secondary replication process.', - parameters: [ + signature: + 'gds.wcc.write(graphName :: STRING, configuration = {} :: MAP) :: (writeMillis :: INTEGER, nodePropertiesWritten :: INTEGER, componentCount :: INTEGER, componentDistribution :: MAP, postProcessingMillis :: INTEGER, preProcessingMillis :: INTEGER, computeMillis :: INTEGER, configuration :: MAP)', + returnDescription: [ { - label: 'databaseName', - documentation: 'databaseName :: STRING', + isDeprecated: false, + description: 'writeMillis :: INTEGER', + name: 'writeMillis', + type: 'INTEGER', }, { - label: 'pause', - documentation: 'pause :: BOOLEAN', + isDeprecated: false, + description: 'nodePropertiesWritten :: INTEGER', + name: 'nodePropertiesWritten', + type: 'INTEGER', }, - ], - }, - 'dbms.cluster.setAutomaticallyEnableFreeServers': { - label: 'dbms.cluster.setAutomaticallyEnableFreeServers', - documentation: - 'With this method you can set whether free servers are automatically enabled.', - parameters: [ { - label: 'autoEnable', - documentation: 'autoEnable :: BOOLEAN', + isDeprecated: false, + description: 'componentCount :: INTEGER', + name: 'componentCount', + type: 'INTEGER', }, - ], - }, - 'dbms.cluster.uncordonServer': { - label: 'dbms.cluster.uncordonServer', - documentation: - "Remove the cordon on a server, returning it to 'enabled'.", - parameters: [ { - label: 'server', - documentation: 'server :: STRING', + isDeprecated: false, + description: 'componentDistribution :: MAP', + name: 'componentDistribution', + type: 'MAP', }, - ], - }, - 'dbms.components': { - label: 'dbms.components', - documentation: 'List DBMS components and their versions.', - parameters: [], - }, - 'dbms.info': { - label: 'dbms.info', - documentation: 'Provides information regarding the DBMS.', - parameters: [], - }, - 'dbms.killConnection': { - label: 'dbms.killConnection', - documentation: 'Kill network connection with the given connection id.', - parameters: [ { - label: 'id', - documentation: 'id :: STRING', + isDeprecated: false, + description: 'postProcessingMillis :: INTEGER', + name: 'postProcessingMillis', + type: 'INTEGER', }, - ], - }, - 'dbms.killConnections': { - label: 'dbms.killConnections', - documentation: - 'Kill all network connections with the given connection ids.', - parameters: [ { - label: 'ids', - documentation: 'ids :: LIST', + isDeprecated: false, + description: 'preProcessingMillis :: INTEGER', + name: 'preProcessingMillis', + type: 'INTEGER', }, - ], - }, - 'dbms.listActiveLocks': { - label: 'dbms.listActiveLocks', - documentation: - 'List the active lock requests granted for the transaction executing the query with the given query id.', - parameters: [ { - label: 'queryId', - documentation: 'queryId :: STRING', + isDeprecated: false, + description: 'computeMillis :: INTEGER', + name: 'computeMillis', + type: 'INTEGER', }, - ], - }, - 'dbms.listCapabilities': { - label: 'dbms.listCapabilities', - documentation: 'List capabilities.', - parameters: [], - }, - 'dbms.listConfig': { - label: 'dbms.listConfig', - documentation: - 'List the currently active configuration settings of Neo4j.', - parameters: [ { - label: 'searchString', - documentation: 'searchString = :: STRING', + isDeprecated: false, + description: 'configuration :: MAP', + name: 'configuration', + type: 'MAP', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'dbms.listConnections': { - label: 'dbms.listConnections', - documentation: - 'List all accepted network connections at this instance that are visible to the user.', - parameters: [], - }, - 'dbms.listPools': { - label: 'dbms.listPools', - documentation: - 'List all memory pools, including sub pools, currently registered at this instance that are visible to the user.', - parameters: [], - }, - 'dbms.quarantineDatabase': { - label: 'dbms.quarantineDatabase', - documentation: 'Place a database into quarantine or remove it from it.', - parameters: [ + 'gds.wcc.write.estimate': { + name: 'gds.wcc.write.estimate', + description: + 'Returns an estimation of the memory consumption for that procedure.', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [ { - label: 'databaseName', - documentation: 'databaseName :: STRING', + isDeprecated: false, + description: 'graphNameOrConfiguration :: ANY', + name: 'graphNameOrConfiguration', + type: 'ANY', }, { - label: 'setStatus', - documentation: 'setStatus :: BOOLEAN', + isDeprecated: false, + description: 'algoConfiguration :: MAP', + name: 'algoConfiguration', + type: 'MAP', }, + ], + signature: + 'gds.wcc.write.estimate(graphNameOrConfiguration :: ANY, algoConfiguration :: MAP) :: (requiredMemory :: STRING, treeView :: STRING, mapView :: MAP, bytesMin :: INTEGER, bytesMax :: INTEGER, nodeCount :: INTEGER, relationshipCount :: INTEGER, heapPercentageMin :: FLOAT, heapPercentageMax :: FLOAT)', + returnDescription: [ { - label: 'reason', - documentation: 'reason = No reason given :: STRING', + isDeprecated: false, + description: 'requiredMemory :: STRING', + name: 'requiredMemory', + type: 'STRING', }, - ], - }, - 'dbms.queryJmx': { - label: 'dbms.queryJmx', - documentation: - 'Query JMX management data by domain and name. For instance, use `*:*` to find all JMX beans.', - parameters: [ { - label: 'query', - documentation: 'query :: STRING', + isDeprecated: false, + description: 'treeView :: STRING', + name: 'treeView', + type: 'STRING', }, - ], - }, - 'dbms.routing.getRoutingTable': { - label: 'dbms.routing.getRoutingTable', - documentation: - "Returns the advertised bolt capable endpoints for a given database, divided by each endpoint's capabilities. For example, an endpoint may serve read queries, write queries, and/or future `getRoutingTable` requests.", - parameters: [ { - label: 'context', - documentation: 'context :: MAP', + isDeprecated: false, + description: 'mapView :: MAP', + name: 'mapView', + type: 'MAP', }, { - label: 'database', - documentation: 'database = null :: STRING', + isDeprecated: false, + description: 'bytesMin :: INTEGER', + name: 'bytesMin', + type: 'INTEGER', }, - ], - }, - 'dbms.scheduler.failedJobs': { - label: 'dbms.scheduler.failedJobs', - documentation: - 'List failed job runs. There is a limit for amount of historical data.', - parameters: [], - }, - 'dbms.scheduler.groups': { - label: 'dbms.scheduler.groups', - documentation: - 'List the job groups that are active in the database internal job scheduler.', - parameters: [], - }, - 'dbms.scheduler.jobs': { - label: 'dbms.scheduler.jobs', - documentation: - 'List all jobs that are active in the database internal job scheduler.', - parameters: [], - }, - 'dbms.security.clearAuthCache': { - label: 'dbms.security.clearAuthCache', - documentation: 'Clears authentication and authorization cache.', - parameters: [], - }, - 'dbms.setConfigValue': { - label: 'dbms.setConfigValue', - documentation: - 'Update a given setting value. Passing an empty value results in removing the configured value and falling back to the default value. Changes do not persist and are lost if the server is restarted. In a clustered environment, `dbms.setConfigValue` affects only the cluster member it is run against.', - parameters: [ { - label: 'setting', - documentation: 'setting :: STRING', + isDeprecated: false, + description: 'bytesMax :: INTEGER', + name: 'bytesMax', + type: 'INTEGER', }, { - label: 'value', - documentation: 'value :: STRING', + isDeprecated: false, + description: 'nodeCount :: INTEGER', + name: 'nodeCount', + type: 'INTEGER', }, - ], - }, - 'dbms.setDatabaseAllocator': { - label: 'dbms.setDatabaseAllocator', - documentation: - 'With this method you can set the allocator that is responsible for selecting servers for hosting databases.', - parameters: [ { - label: 'allocator', - documentation: 'allocator :: STRING', + isDeprecated: false, + description: 'relationshipCount :: INTEGER', + name: 'relationshipCount', + type: 'INTEGER', }, - ], - }, - 'dbms.setDefaultAllocationNumbers': { - label: 'dbms.setDefaultAllocationNumbers', - documentation: - 'With this method you can set the default number of primaries and secondaries.', - parameters: [ { - label: 'primaries', - documentation: 'primaries :: INTEGER', + isDeprecated: false, + description: 'heapPercentageMin :: FLOAT', + name: 'heapPercentageMin', + type: 'FLOAT', }, { - label: 'secondaries', - documentation: 'secondaries :: INTEGER', + isDeprecated: false, + description: 'heapPercentageMax :: FLOAT', + name: 'heapPercentageMax', + type: 'FLOAT', }, ], + admin: false, + option: { + deprecated: false, + }, }, - 'dbms.setDefaultDatabase': { - label: 'dbms.setDefaultDatabase', - documentation: - 'Change the default database to the provided value. The database must exist and the old default database must be stopped.', - parameters: [ + 'tx.getMetaData': { + name: 'tx.getMetaData', + description: 'Provides attached transaction metadata.', + mode: 'DBMS', + worksOnSystem: true, + argumentDescription: [], + signature: 'tx.getMetaData() :: (metadata :: MAP)', + returnDescription: [ { - label: 'databaseName', - documentation: 'databaseName :: STRING', + isDeprecated: false, + description: 'metadata :: MAP', + name: 'metadata', + type: 'MAP', }, ], - }, - 'dbms.showCurrentUser': { - label: 'dbms.showCurrentUser', - documentation: 'Show the current user.', - parameters: [], - }, - 'dbms.showTopologyGraphConfig': { - label: 'dbms.showTopologyGraphConfig', - documentation: - 'With this method the configuration of the Topology Graph can be displayed.', - parameters: [], - }, - 'dbms.upgrade': { - label: 'dbms.upgrade', - documentation: - 'Upgrade the system database schema if it is not the current schema.', - parameters: [], - }, - 'dbms.upgradeStatus': { - label: 'dbms.upgradeStatus', - documentation: - 'Report the current status of the system database sub-graph schema.', - parameters: [], - }, - 'tx.getMetaData': { - label: 'tx.getMetaData', - documentation: 'Provides attached transaction metadata.', - parameters: [], + admin: false, + option: { + deprecated: false, + }, }, 'tx.setMetaData': { - label: 'tx.setMetaData', - documentation: + name: 'tx.setMetaData', + description: 'Attaches a map of data to the transaction. The data will be printed when listing queries, and inserted into the query log.', - parameters: [ + mode: 'DBMS', + worksOnSystem: false, + argumentDescription: [ { - label: 'data', - documentation: 'data :: MAP', + isDeprecated: false, + description: 'data :: MAP', + name: 'data', + type: 'MAP', }, ], + signature: 'tx.setMetaData(data :: MAP)', + returnDescription: [], + admin: false, + option: { + deprecated: false, + }, }, }, labels: [ @@ -9685,7 +53237,33 @@ CREATE WITH TomH as a MATCH (a)-[:ACTED_IN]->(m)<-[:DIRECTED]-(d) RETURN a,m,d LIMIT 10;`; -export const testData = { +export const testData: { + mockSchema: DbSchema; + largeQuery: string; + emptyFunction: Neo4jFunction; + emptyProcedure: Neo4jProcedure; +} = { mockSchema, largeQuery, + emptyFunction: { + name: '', + category: '', + description: '', + isBuiltIn: false, + argumentDescription: [], + returnDescription: '', + signature: '', + aggregating: false, + }, + emptyProcedure: { + name: '', + description: '', + mode: 'READ', + worksOnSystem: false, + argumentDescription: [], + returnDescription: [], + signature: '', + admin: false, + option: { deprecated: false }, + }, }; diff --git a/packages/language-support/src/types.ts b/packages/language-support/src/types.ts new file mode 100644 index 00000000..f4bb49ba --- /dev/null +++ b/packages/language-support/src/types.ts @@ -0,0 +1,37 @@ +export type ReturnDescription = { + name: string; + description: string; + type: Neo4jStringType; + isDeprecated: boolean; +}; + +// we could parse this string for better types in the future +export type Neo4jStringType = string; +export type ArgumentDescription = ReturnDescription & { default?: string }; + +type ProcedureMode = 'READ' | 'DBMS' | 'SCHEMA' | 'WRITE' | 'DEFAULT'; + +export type Neo4jProcedure = { + name: string; + description: string; + mode: ProcedureMode; + // If it can run on the system database + worksOnSystem: boolean; + argumentDescription: ArgumentDescription[]; + returnDescription: ReturnDescription[]; + signature: string; + admin: boolean; + // Flexbible field, most hold if procedure is deprecated or not + option: { deprecated: boolean } & Record; +}; + +export type Neo4jFunction = { + name: string; + category: string; + description: string; + isBuiltIn: boolean; + argumentDescription: ArgumentDescription[]; + returnDescription: string; + signature: string; + aggregating: boolean; +}; diff --git a/packages/react-codemirror/src/e2e_tests/autoCompletion.spec.tsx b/packages/react-codemirror/src/e2e_tests/autoCompletion.spec.tsx index 47c8778d..cd53f74c 100644 --- a/packages/react-codemirror/src/e2e_tests/autoCompletion.spec.tsx +++ b/packages/react-codemirror/src/e2e_tests/autoCompletion.spec.tsx @@ -1,3 +1,4 @@ +import { testData } from '@neo4j-cypher/language-support'; import { expect, test } from '@playwright/experimental-ct-react'; import { CypherEditor } from '../CypherEditor'; @@ -144,8 +145,11 @@ test('can complete functions', async ({ page, mount }) => { const component = await mount( , @@ -169,8 +173,8 @@ test('can complete procedures', async ({ page, mount }) => { const component = await mount( , diff --git a/packages/react-codemirror/src/lang-cypher/syntaxValidation.ts b/packages/react-codemirror/src/lang-cypher/syntaxValidation.ts index b2b61f7e..386aa9e5 100644 --- a/packages/react-codemirror/src/lang-cypher/syntaxValidation.ts +++ b/packages/react-codemirror/src/lang-cypher/syntaxValidation.ts @@ -71,7 +71,10 @@ export const semanticAnalysisLinter: (config: CypherConfig) => Extension = ( } const proxyWorker = (await pool.proxy()) as unknown as LintWorker; - lastSemanticJob = proxyWorker.validateSemantics(query); + lastSemanticJob = proxyWorker.validateSemantics( + query, + config.schema ?? {}, + ); const result = await lastSemanticJob; return result.map((diag) => { diff --git a/packages/schema-poller/src/metadataPoller.ts b/packages/schema-poller/src/metadataPoller.ts index dabff7fb..4d3af984 100644 --- a/packages/schema-poller/src/metadataPoller.ts +++ b/packages/schema-poller/src/metadataPoller.ts @@ -1,10 +1,13 @@ -import { DbSchema } from '@neo4j-cypher/language-support'; -import { SignatureInformation } from 'vscode-languageserver/node'; +import { + DbSchema, + Neo4jFunction, + Neo4jProcedure, +} from '@neo4j-cypher/language-support'; import { Neo4jConnection } from './neo4jConnection.js'; import { Database, listDatabases } from './queries/databases.js'; import { DataSummary, getDataSummary } from './queries/dataSummary.js'; -import { listFunctions, Neo4jFunction } from './queries/functions.js'; -import { listProcedures, Procedure } from './queries/procedures.js'; +import { listFunctions } from './queries/functions.js'; +import { listProcedures } from './queries/procedures.js'; import { ExecuteQueryArgs } from './types/sdkTypes.js'; type PollingStatus = 'not-started' | 'fetching' | 'fetched' | 'error'; @@ -75,7 +78,7 @@ export class MetadataPoller { private databases: QueryPoller<{ databases: Database[] }>; private dataSummary: QueryPoller; private functions: QueryPoller<{ functions: Neo4jFunction[] }>; - private procedures: QueryPoller<{ procedures: Procedure[] }>; + private procedures: QueryPoller<{ procedures: Neo4jProcedure[] }>; private dbPollingInterval: NodeJS.Timer | undefined; @@ -116,23 +119,14 @@ export class MetadataPoller { queryArgs: listFunctions({ executableByMe: true }), onRefetchDone: (result) => { if (result.success) { - const signatures = result.data.functions.reduce< - Record + const functions = result.data.functions.reduce< + Record >((acc, curr) => { - const { name, argumentDescription, description } = curr; - - acc[name] = SignatureInformation.create( - name, - description, - ...argumentDescription.map((arg) => ({ - label: arg.name, - documentation: arg.description, - })), - ); - + const { name } = curr; + acc[name] = curr; return acc; }, {}); - this.dbSchema.functionSignatures = signatures; + this.dbSchema.functions = functions; } }, }); @@ -142,22 +136,14 @@ export class MetadataPoller { queryArgs: listProcedures({ executableByMe: true }), onRefetchDone: (result) => { if (result.success) { - const signatures = result.data.procedures.reduce< - Record + const procedures = result.data.procedures.reduce< + Record >((acc, curr) => { - const { name, argumentDescription, description } = curr; - - acc[name] = SignatureInformation.create( - name, - description, - ...argumentDescription.map((arg) => ({ - label: arg.name, - documentation: arg.description, - })), - ); + const { name } = curr; + acc[name] = curr; return acc; }, {}); - this.dbSchema.procedureSignatures = signatures; + this.dbSchema.procedures = procedures; } }, }); diff --git a/packages/schema-poller/src/queries/functions.ts b/packages/schema-poller/src/queries/functions.ts index 31c31f1f..e66a4306 100644 --- a/packages/schema-poller/src/queries/functions.ts +++ b/packages/schema-poller/src/queries/functions.ts @@ -1,19 +1,6 @@ +import { Neo4jFunction } from '@neo4j-cypher/language-support'; import { resultTransformers } from 'neo4j-driver'; -import type { - ArgumentDescription, - ExecuteQueryArgs, -} from '../types/sdkTypes.js'; - -export type Neo4jFunction = { - name: string; - category: string; - description: string; - isBuiltIn: boolean; - argumentDescription: ArgumentDescription[]; - returnDescription: string; - signature: string; - aggregating: boolean; -}; +import type { ExecuteQueryArgs } from '../types/sdkTypes.js'; type ListFunctionArgs = { executableByMe: boolean }; /** diff --git a/packages/schema-poller/src/queries/procedures.ts b/packages/schema-poller/src/queries/procedures.ts index 1ef589c7..b13fbdf3 100644 --- a/packages/schema-poller/src/queries/procedures.ts +++ b/packages/schema-poller/src/queries/procedures.ts @@ -1,25 +1,6 @@ +import { Neo4jProcedure } from '@neo4j-cypher/language-support'; import { resultTransformers } from 'neo4j-driver'; -import type { - ArgumentDescription, - ExecuteQueryArgs, - ReturnDescription, -} from '../types/sdkTypes.js'; - -type ProcedureMode = 'READ' | 'DBMS' | 'SCHEMA' | 'WRITE'; - -export type Procedure = { - name: string; - description: string; - mode: ProcedureMode; - // If it can run on the system database - worksOnSystem: boolean; - argumentDescription: ArgumentDescription[]; - returnDescription: ReturnDescription[]; - signature: string; - admin: boolean; - // Flexbible field, most hold if procedure is deprecated or not - option: { deprecated: boolean } & Record; -}; +import type { ExecuteQueryArgs } from '../types/sdkTypes'; type ListFunctionArgs = { executableByMe: boolean }; /** @@ -29,7 +10,7 @@ type ListFunctionArgs = { executableByMe: boolean }; export function listProcedures( { executableByMe }: ListFunctionArgs = { executableByMe: false }, ): ExecuteQueryArgs<{ - procedures: Procedure[]; + procedures: Neo4jProcedure[]; }> { const query = `SHOW PROCEDURES ${ executableByMe ? 'EXECUTABLE BY CURRENT USER' : '' @@ -38,7 +19,7 @@ YIELD name, description, mode, worksOnSystem, argumentDescription, signature, re const resultTransformer = resultTransformers.mappedResultTransformer({ map(record) { - return record.toObject() as Procedure; + return record.toObject() as Neo4jProcedure; }, collect(procedures, summary) { return { procedures, summary }; diff --git a/packages/schema-poller/src/types/sdkTypes.ts b/packages/schema-poller/src/types/sdkTypes.ts index c9316f3b..53ff823b 100644 --- a/packages/schema-poller/src/types/sdkTypes.ts +++ b/packages/schema-poller/src/types/sdkTypes.ts @@ -1,15 +1,5 @@ import type { QueryConfig, ResultSummary } from 'neo4j-driver'; -export type ReturnDescription = { - name: string; - description: string; - type: Neo4jStringType; -}; - -// we could parse this string for better types in the future -export type Neo4jStringType = string; -export type ArgumentDescription = ReturnDescription & { default?: string }; - export type DbType = 'system' | 'standard' | 'composite'; export type QueryType = diff --git a/packages/vscode-extension/e2e_tests/tests/signatureHelp.spec.ts b/packages/vscode-extension/e2e_tests/tests/signatureHelp.spec.ts index 3ffb87ee..5fa7729c 100644 --- a/packages/vscode-extension/e2e_tests/tests/signatureHelp.spec.ts +++ b/packages/vscode-extension/e2e_tests/tests/signatureHelp.spec.ts @@ -1,4 +1,7 @@ -import { testData } from '@neo4j-cypher/language-support'; +import { + testData, + toSignatureInformation, +} from '@neo4j-cypher/language-support'; import * as assert from 'assert'; import * as vscode from 'vscode'; import { eventually, getDocumentUri, openDocument } from '../helpers'; @@ -61,7 +64,11 @@ suite('Signature help spec', () => { // We don't test the active signature, otherwise we would have to modify // these tests every time a new function is added to the database activeSignature: undefined, - signatures: [testData.mockSchema.functionSignatures.abs], + signatures: [ + toSignatureInformation( + testData.mockSchema.functions.abs, + ) as vscode.SignatureInformation, + ], }; await testSignatureHelp({ @@ -77,7 +84,11 @@ suite('Signature help spec', () => { const expected: vscode.SignatureHelp = { activeParameter: 0, activeSignature: undefined, - signatures: [testData.mockSchema.procedureSignatures['apoc.import.csv']], + signatures: [ + toSignatureInformation( + testData.mockSchema.procedures['apoc.import.csv'], + ) as vscode.SignatureInformation, + ], }; await testSignatureHelp({ @@ -93,7 +104,11 @@ suite('Signature help spec', () => { const expected: vscode.SignatureHelp = { activeParameter: 1, activeSignature: undefined, - signatures: [testData.mockSchema.procedureSignatures['apoc.import.csv']], + signatures: [ + toSignatureInformation( + testData.mockSchema.procedures['apoc.import.csv'], + ) as vscode.SignatureInformation, + ], }; await testSignatureHelp({ @@ -109,7 +124,11 @@ suite('Signature help spec', () => { const expected: vscode.SignatureHelp = { activeParameter: 1, activeSignature: undefined, - signatures: [testData.mockSchema.procedureSignatures['apoc.import.csv']], + signatures: [ + toSignatureInformation( + testData.mockSchema.procedures['apoc.import.csv'], + ) as vscode.SignatureInformation, + ], }; await testSignatureHelp({ @@ -127,7 +146,11 @@ suite('Signature help spec', () => { // since there are only 3 arguments in the signature and the last index is 2 activeParameter: 3, activeSignature: undefined, - signatures: [testData.mockSchema.procedureSignatures['apoc.import.csv']], + signatures: [ + toSignatureInformation( + testData.mockSchema.procedures['apoc.import.csv'], + ) as vscode.SignatureInformation, + ], }; await testSignatureHelp({ diff --git a/packages/vscode-extension/package.json b/packages/vscode-extension/package.json index 642f21f2..55061658 100644 --- a/packages/vscode-extension/package.json +++ b/packages/vscode-extension/package.json @@ -107,7 +107,7 @@ "@testcontainers/neo4j": "^10.4.0", "@types/mocha": "^10.0.1", "@types/node": "^16.11.7", - "@types/vscode": "^1.75.0", + "@types/vscode": "^1.87.0", "@vscode/test-electron": "^2.3.8", "@vscode/vsce": "^2.21.1", "mocha": "^10.2.0",