+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| name                                                | signature                                                                                                                                                    | description                                                                                                      |
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| "date"                                              | "date(input = DEFAULT_TEMPORAL_ARGUMENT :: ANY?) :: (DATE?)"                                                                                                 | "Create a Date instant."                                                                                         |
| "date.realtime"                                     | "date.realtime(timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY?) :: (DATE?)"                                                                                     | "Get the current Date instant using the realtime clock."                                                         |
| "date.statement"                                    | "date.statement(timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY?) :: (DATE?)"                                                                                    | "Get the current Date instant using the statement clock."                                                        |
| "date.transaction"                                  | "date.transaction(timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY?) :: (DATE?)"                                                                                  | "Get the current Date instant using the transaction clock."                                                      |
| "date.truncate"                                     | "date.truncate(unit :: STRING?, input :: ANY?, fields = null :: MAP?) :: (DATE?)"                                                                            | "Truncate the input temporal value to a Date instant using the specified unit."                                  |
| "datetime"                                          | "datetime(input = DEFAULT_TEMPORAL_ARGUMENT :: ANY?) :: (DATETIME?)"                                                                                         | "Create a DateTime instant."                                                                                     |
| "datetime.fromepoch"                                | "datetime.fromepoch(seconds :: NUMBER?, nanoseconds :: NUMBER?) :: (DATETIME?)"                                                                              | "Create a DateTime given the seconds and nanoseconds since the start of the epoch."                              |
| "datetime.fromepochmillis"                          | "datetime.fromepochmillis(milliseconds :: NUMBER?) :: (DATETIME?)"                                                                                           | "Create a DateTime given the milliseconds since the start of the epoch."                                         |
| "datetime.realtime"                                 | "datetime.realtime(timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY?) :: (DATETIME?)"                                                                             | "Get the current DateTime instant using the realtime clock."                                                     |
| "datetime.statement"                                | "datetime.statement(timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY?) :: (DATETIME?)"                                                                            | "Get the current DateTime instant using the statement clock."                                                    |
| "datetime.transaction"                              | "datetime.transaction(timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY?) :: (DATETIME?)"                                                                          | "Get the current DateTime instant using the transaction clock."                                                  |
| "datetime.truncate"                                 | "datetime.truncate(unit :: STRING?, input :: ANY?, fields = null :: MAP?) :: (DATETIME?)"                                                                    | "Truncate the input temporal value to a DateTime instant using the specified unit."                              |
| "duration"                                          | "duration(input :: ANY?) :: (DURATION?)"                                                                                                                     | "Construct a Duration value."                                                                                    |
| "duration.between"                                  | "duration.between(from :: ANY?, to :: ANY?) :: (DURATION?)"                                                                                                  | "Compute the duration between the 'from' instant (inclusive) and the 'to' instant (exclusive) in logical units." |
| "duration.inDays"                                   | "duration.inDays(from :: ANY?, to :: ANY?) :: (DURATION?)"                                                                                                   | "Compute the duration between the 'from' instant (inclusive) and the 'to' instant (exclusive) in days."          |
| "duration.inMonths"                                 | "duration.inMonths(from :: ANY?, to :: ANY?) :: (DURATION?)"                                                                                                 | "Compute the duration between the 'from' instant (inclusive) and the 'to' instant (exclusive) in months."        |
| "duration.inSeconds"                                | "duration.inSeconds(from :: ANY?, to :: ANY?) :: (DURATION?)"                                                                                                | "Compute the duration between the 'from' instant (inclusive) and the 'to' instant (exclusive) in seconds."       |
| "localdatetime"                                     | "localdatetime(input = DEFAULT_TEMPORAL_ARGUMENT :: ANY?) :: (LOCALDATETIME?)"                                                                               | "Create a LocalDateTime instant."                                                                                |
| "localdatetime.realtime"                            | "localdatetime.realtime(timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY?) :: (LOCALDATETIME?)"                                                                   | "Get the current LocalDateTime instant using the realtime clock."                                                |
| "localdatetime.statement"                           | "localdatetime.statement(timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY?) :: (LOCALDATETIME?)"                                                                  | "Get the current LocalDateTime instant using the statement clock."                                               |
| "localdatetime.transaction"                         | "localdatetime.transaction(timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY?) :: (LOCALDATETIME?)"                                                                | "Get the current LocalDateTime instant using the transaction clock."                                             |
| "localdatetime.truncate"                            | "localdatetime.truncate(unit :: STRING?, input :: ANY?, fields = null :: MAP?) :: (LOCALDATETIME?)"                                                          | "Truncate the input temporal value to a LocalDateTime instant using the specified unit."                         |
| "localtime"                                         | "localtime(input = DEFAULT_TEMPORAL_ARGUMENT :: ANY?) :: (LOCALTIME?)"                                                                                       | "Create a LocalTime instant."                                                                                    |
| "localtime.realtime"                                | "localtime.realtime(timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY?) :: (LOCALTIME?)"                                                                           | "Get the current LocalTime instant using the realtime clock."                                                    |
| "localtime.statement"                               | "localtime.statement(timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY?) :: (LOCALTIME?)"                                                                          | "Get the current LocalTime instant using the statement clock."                                                   |
| "localtime.transaction"                             | "localtime.transaction(timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY?) :: (LOCALTIME?)"                                                                        | "Get the current LocalTime instant using the transaction clock."                                                 |
| "localtime.truncate"                                | "localtime.truncate(unit :: STRING?, input :: ANY?, fields = null :: MAP?) :: (LOCALTIME?)"                                                                  | "Truncate the input temporal value to a LocalTime instant using the specified unit."                             |
| "org.neo4j.procedure.avgDoubleList"                 | "org.neo4j.procedure.avgDoubleList(someValue :: LIST? OF FLOAT?) :: (FLOAT?)"                                                                                | ""                                                                                                               |
| "org.neo4j.procedure.avgNumberList"                 | "org.neo4j.procedure.avgNumberList(someValue :: LIST? OF NUMBER?) :: (FLOAT?)"                                                                               | ""                                                                                                               |
| "org.neo4j.procedure.defaultValues"                 | "org.neo4j.procedure.defaultValues(string = a string :: STRING?, integer = 42 :: INTEGER?, float = 3.14 :: FLOAT?, boolean = true :: BOOLEAN?) :: (STRING?)" | ""                                                                                                               |
| "org.neo4j.procedure.delegatingFunction"            | "org.neo4j.procedure.delegatingFunction(someValue :: INTEGER?) :: (INTEGER?)"                                                                                | ""                                                                                                               |
| "org.neo4j.procedure.genericArguments"              | "org.neo4j.procedure.genericArguments(strings :: LIST? OF LIST? OF STRING?, longs :: LIST? OF LIST? OF LIST? OF INTEGER?) :: (INTEGER?)"                     | ""                                                                                                               |
| "org.neo4j.procedure.indexOutOfBounds"              | "org.neo4j.procedure.indexOutOfBounds() :: (INTEGER?)"                                                                                                       | ""                                                                                                               |
| "org.neo4j.procedure.integrationTestMe"             | "org.neo4j.procedure.integrationTestMe() :: (INTEGER?)"                                                                                                      | ""                                                                                                               |
| "org.neo4j.procedure.listCoolPeopleInDatabase"      | "org.neo4j.procedure.listCoolPeopleInDatabase() :: (LIST? OF ANY?)"                                                                                          | ""                                                                                                               |
| "org.neo4j.procedure.logAround"                     | "org.neo4j.procedure.logAround() :: (INTEGER?)"                                                                                                              | ""                                                                                                               |
| "org.neo4j.procedure.mapArgument"                   | "org.neo4j.procedure.mapArgument(map :: MAP?) :: (INTEGER?)"                                                                                                 | ""                                                                                                               |
| "org.neo4j.procedure.node"                          | "org.neo4j.procedure.node(id :: INTEGER?) :: (NODE?)"                                                                                                        | ""                                                                                                               |
| "org.neo4j.procedure.nodeListArgument"              | "org.neo4j.procedure.nodeListArgument(nodes :: LIST? OF NODE?) :: (INTEGER?)"                                                                                | ""                                                                                                               |
| "org.neo4j.procedure.nodePaths"                     | "org.neo4j.procedure.nodePaths(someValue :: NODE?) :: (PATH?)"                                                                                               | ""                                                                                                               |
| "org.neo4j.procedure.nodeWithDescription"           | "org.neo4j.procedure.nodeWithDescription(someValue :: NODE?) :: (NODE?)"                                                                                     | "This is a description"                                                                                          |
| "org.neo4j.procedure.readOnlyCallingWriteFunction"  | "org.neo4j.procedure.readOnlyCallingWriteFunction() :: (NODE?)"                                                                                              | ""                                                                                                               |
| "org.neo4j.procedure.readOnlyCallingWriteProcedure" | "org.neo4j.procedure.readOnlyCallingWriteProcedure() :: (INTEGER?)"                                                                                          | ""                                                                                                               |
| "org.neo4j.procedure.readOnlyTryingToWrite"         | "org.neo4j.procedure.readOnlyTryingToWrite() :: (NODE?)"                                                                                                     | ""                                                                                                               |
| "org.neo4j.procedure.readOnlyTryingToWriteSchema"   | "org.neo4j.procedure.readOnlyTryingToWriteSchema() :: (STRING?)"                                                                                             | ""                                                                                                               |
| "org.neo4j.procedure.recursiveSum"                  | "org.neo4j.procedure.recursiveSum(someValue :: INTEGER?) :: (INTEGER?)"                                                                                      | ""                                                                                                               |
| "org.neo4j.procedure.shutdown"                      | "org.neo4j.procedure.shutdown() :: (STRING?)"                                                                                                                | ""                                                                                                               |
| "org.neo4j.procedure.simpleArgument"                | "org.neo4j.procedure.simpleArgument(someValue :: INTEGER?) :: (INTEGER?)"                                                                                    | ""                                                                                                               |
| "org.neo4j.procedure.squareDouble"                  | "org.neo4j.procedure.squareDouble(someValue :: FLOAT?) :: (FLOAT?)"                                                                                          | ""                                                                                                               |
| "org.neo4j.procedure.squareLong"                    | "org.neo4j.procedure.squareLong(someValue :: INTEGER?) :: (INTEGER?)"                                                                                        | ""                                                                                                               |
| "org.neo4j.procedure.throwsExceptionInStream"       | "org.neo4j.procedure.throwsExceptionInStream() :: (INTEGER?)"                                                                                                | ""                                                                                                               |
| "org.neo4j.procedure.unsupportedFunction"           | "org.neo4j.procedure.unsupportedFunction() :: (STRING?)"                                                                                                     | ""                                                                                                               |
| "randomUUID"                                        | "randomUUID() :: (STRING?)"                                                                                                                                  | "Generates a random UUID."                                                                                       |
| "this.is.test.only.sum"                             | "this.is.test.only.sum(numbers :: LIST? OF NUMBER?) :: (NUMBER?)"                                                                                            | ""                                                                                                               |
| "time"                                              | "time(input = DEFAULT_TEMPORAL_ARGUMENT :: ANY?) :: (TIME?)"                                                                                                 | "Create a Time instant."                                                                                         |
| "time.realtime"                                     | "time.realtime(timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY?) :: (TIME?)"                                                                                     | "Get the current Time instant using the realtime clock."                                                         |
| "time.statement"                                    | "time.statement(timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY?) :: (TIME?)"                                                                                    | "Get the current Time instant using the statement clock."                                                        |
| "time.transaction"                                  | "time.transaction(timezone = DEFAULT_TEMPORAL_ARGUMENT :: ANY?) :: (TIME?)"                                                                                  | "Get the current Time instant using the transaction clock."                                                      |
| "time.truncate"                                     | "time.truncate(unit :: STRING?, input :: ANY?, fields = null :: MAP?) :: (TIME?)"                                                                            | "Truncate the input temporal value to a Time instant using the specified unit."                                  |
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
59 rows

