declare let SQL_DEFAULT : number; declare let SQL_CHAR : number; declare let SQL_NUMERIC : number; declare let SQL_DECIMAL : number; declare let SQL_INTEGER : number; declare let SQL_SMALLINT : number; declare let SQL_FLOAT : number; declare let SQL_REAL : number; declare let SQL_DOUBLE : number; declare let SQL_DATETIME : number; declare let SQL_VARCHAR : number; declare let SQL_BLOB : number; declare let SQL_CLOB : number; declare let SQL_DBCLOB : number; declare let SQL_DATALINK : number; declare let SQL_WCHAR : number; declare let SQL_WVARCHAR : number; declare let SQL_BIGINT : number; declare let SQL_BLOB_LOCATOR : number; declare let SQL_CLOB_LOCATOR : number; declare let SQL_DBCLOB_LOCATOR : number; declare let SQL_UTF8_CHAR : number; declare let SQL_WLONGVARCHAR : number; declare let SQL_LONGVARCHAR : number; declare let SQL_GRAPHIC : number; declare let SQL_VARGRAPHIC : number; declare let SQL_LONGVARGRAPHIC : number; declare let SQL_BINARY : number; declare let SQL_VARBINARY : number; declare let SQL_LONGVARBINARY : number; declare let SQL_DATE : number; declare let SQL_TYPE_DATE : number; declare let SQL_TIME : number; declare let SQL_TYPE_TIME : number; declare let SQL_TIMESTAMP : number; declare let SQL_TYPE_TIMESTAMP : number; declare let SQL_CODE_DATE : number; declare let SQL_CODE_TIME : number; declare let SQL_CODE_TIMESTAMP : number; declare let SQL_ALL_TYPES : number; declare let SQL_DECFLOAT : number; declare let SQL_XML : number; declare let SQL_FETCH_NEXT : number; declare let SQL_FETCH_FIRST : number; declare let SQL_FETCH_LAST : number; declare let SQL_FETCH_PRIOR : number; declare let SQL_FETCH_ABSOLUTE : number; declare let SQL_FETCH_RELATIVE : number; declare let SQL_PARAM_INPUT : number; declare let SQL_PARAM_OUTPUT : number; declare let SQL_PARAM_INPUT_OUTPUT : number; // Valid environment attributes declare let SQL_ATTR_OUTPUT_NTS : number; declare let SQL_ATTR_SYS_NAMING : number; declare let SQL_ATTR_DEFAULT_LIB : number; declare let SQL_ATTR_SERVER_MODE : number; declare let SQL_ATTR_JOB_SORT_SEQUENCE : number; declare let SQL_ATTR_ENVHNDL_COUNTER : number; declare let SQL_ATTR_ESCAPE_CHAR : number; declare let SQL_ATTR_INCLUDE_NULL_IN_LEN : number; declare let SQL_ATTR_UTF8 : number; declare let SQL_ATTR_SYSCAP : number; declare let SQL_ATTR_REQUIRE_PROFILE : number; declare let SQL_ATTR_UCS2 : number; declare let SQL_ATTR_TRUNCATION_RTNC : number; declare let SQL_ATTR_DATE_FMT : number; declare let SQL_ATTR_DATE_SEP : number; declare let SQL_ATTR_TIME_FMT : number; declare let SQL_ATTR_TIME_SEP : number; declare let SQL_ATTR_DECIMAL_SEP : number; declare let SQL_ATTR_TXN_INFO : number; declare let SQL_ATTR_TXN_EXTERNAL : number; declare let SQL_ATTR_2ND_LEVEL_TEXT : number; declare let SQL_ATTR_SAVEPOINT_NAME : number; declare let SQL_ATTR_TRACE : number; declare let SQL_ATTR_MAX_PRECISION : number; declare let SQL_ATTR_MAX_SCALE : number; declare let SQL_ATTR_MIN_DIVIDE_SCALE : number; declare let SQL_ATTR_HEX_LITERALS : number; declare let SQL_ATTR_CORRELATOR : number; declare let SQL_ATTR_QUERY_OPTIMIZE_GOAL : number; declare let SQL_ATTR_CONN_SORT_SEQUENCE : number; declare let SQL_ATTR_PREFETCH : number; declare let SQL_ATTR_CLOSEONEOF : number; declare let SQL_ATTR_ANSI_APP : number; declare let SQL_ATTR_INFO_USERID : number; declare let SQL_ATTR_INFO_WRKSTNNAME : number; declare let SQL_ATTR_INFO_APPLNAME : number; declare let SQL_ATTR_INFO_ACCTSTR : number; declare let SQL_ATTR_INFO_PROGRAMID : number; declare let SQL_ATTR_DECFLOAT_ROUNDING_MODE : number; declare let SQL_ATTR_OLD_MTADTA_BEHAVIOR : number; declare let SQL_ATTR_NULL_REQUIRED : number; declare let SQL_ATTR_FREE_LOCATORS : number; declare let SQL_ATTR_EXTENDED_INDICATORS : number; declare let SQL_ATTR_NULLT_ARRAY_RESULTS : number; declare let SQL_ATTR_NULLT_OUTPUT_PARMS : number; declare let SQL_ATTR_TIMESTAMP_PREC : number; declare let SQL_ATTR_CONCURRENT_ACCESS_RESOLUTION : number; declare let SQL_ATTR_APP_ROW_DESC : number; declare let SQL_ATTR_APP_PARAM_DESC : number; declare let SQL_ATTR_IMP_ROW_DESC : number; declare let SQL_ATTR_IMP_PARAM_DESC : number; declare let SQL_ATTR_FOR_FETCH_ONLY : number; declare let SQL_ATTR_CONCURRENCY : number; declare let SQL_ATTR_CURSOR_SCROLLABLE : number; declare let SQL_ATTR_ROWSET_SIZE : number; declare let SQL_ATTR_ROW_ARRAY_SIZE : number; declare let SQL_ATTR_CURSOR_HOLD : number; declare let SQL_ATTR_FULL_OPEN : number; declare let SQL_ATTR_EXTENDED_COL_INFO : number; declare let SQL_ATTR_BIND_TYPE : number; declare let SQL_ATTR_CURSOR_TYPE : number; declare let SQL_ATTR_CURSOR_SENSITIVITY : number; declare let SQL_ATTR_ROW_STATUS_PTR : number; declare let SQL_ATTR_ROWS_FETCHED_PTR : number; declare let SQL_ATTR_ROW_BIND_TYPE : number; declare let SQL_ATTR_PARAMSET_SIZE : number; declare let SQL_ATTR_PARAM_STATUS_PTR : number; declare let SQL_ATTR_PARAMS_PROCESSED_PTR : number; declare let SQL_ATTR_NUMBER_RESULTSET_ROWS_PTR : number; declare let SQL_ATTR_AUTO_IPD : number; declare let SQL_ATTR_ACCESS_MODE : number; declare let SQL_ATTR_AUTOCOMMIT : number; declare let SQL_ATTR_DBC_SYS_NAMING : number; declare let SQL_ATTR_DBC_DEFAULT_LIB : number; declare let SQL_ATTR_ADOPT_OWNER_AUTH : number; declare let SQL_ATTR_SYSBAS_CMT : number; declare let SQL_ATTR_SET_SSA : number; declare let SQL_ATTR_COMMIT : number; declare let SQL_ATTR_TXN_ISOLATION : number; declare let SQL_TXN_ISOLATION : number; declare let SQL_TXN_NO_COMMIT : number; declare let SQL_HEX_SORT_SEQUENCE : number; declare let SQL_JOB_SORT_SEQUENCE : number; declare let SQL_JOBRUN_SORT_SEQUENCE : number; declare let SQL_FALSE : number; declare let SQL_TRUE : number; declare let SQL_NTS : number; declare let SQL_BIND_BY_ROW : number; declare let SQL_BIND_BY_COLUMN : number; declare let SQL_CURSOR_FORWARD_ONLY : number; declare let SQL_CURSOR_STATIC : number; declare let SQL_CURSOR_DYNAMIC : number; declare let SQL_CURSOR_KEYSET_DRIVEN : number; declare let SQL_UNSPECIFIED : number; declare let SQL_INSENSITIVE : number; declare let SQL_SENSITIVE : number; declare let SQL_FMT_ISO : number; declare let SQL_FMT_USA : number; declare let SQL_FMT_EUR : number; declare let SQL_FMT_JIS : number; declare let SQL_FMT_MDY : number; declare let SQL_FMT_DMY : number; declare let SQL_FMT_YMD : number; declare let SQL_FMT_JUL : number; declare let SQL_FMT_HMS : number; declare let SQL_FMT_JOB : number; declare let SQL_SEP_SLASH : number; declare let SQL_SEP_DASH : number; declare let SQL_SEP_PERIOD : number; declare let SQL_SEP_COMMA : number; declare let SQL_SEP_BLANK : number; declare let SQL_SEP_COLON : number; declare let SQL_SEP_JOB : number; declare let SQL_NULL_DATA : number; declare let SQL_MAX_ROWSET_SIZE : number; declare let SQL_FETCH_ALL : number; declare let sqlcode : number; declare let sqlstate : string; declare namespace display { //MISSING SCREEN APIS because they are object methods //MISSING GRID APIs because they are object methods export function close(): void; /** * This method returns a specific display's end of file state indicating * whether the last call to `display.grid.readChanged()` found more changed records. */ export function endOfData(): boolean; /** * True indicates a subfile grid record was found and retrieved. * False indicates the record was not found. */ export function found(): boolean; export function isOpen(): boolean; /** * opens a display file that was previously defined with the userOpen configuration * property set to true in the `pjs.defineDisplay()` call. */ export function open(): void; /** * Returns the current status code of the display object */ export function status(): number; } declare namespace pjs { export let ProfoundJSVar: any; export let DataStucture: any; /** * Allocate a new buffer. */ export function alloc(size: number): Buffer; export function assign(fieldName: string, value: any, halfAdjust?: boolean): any; export function assignCorresponding(into: DataStructure, from: DataStructure): void; export function bitAnd(...values: string): string; export function bitChange(field: ProfoundJSVar, bits: string, resultBit: number): void; export function bitNot(value: string): void; export function bitOr(...values: string): string; export function bitXor(...values: string): string; export function call(program: string, ...parameters: ProfoundJSVar[]): any; export function callProcedure(callInfo: object): any; export function clear(ProfoundJSVar: ProfoundJSVar, options?: Object): void; export function closeDataAreas(): void; export function connect(Database: string, Username?: string, Password?: string): void; export function currencySymbol(): string; /** * Displays a message on the user's screen, waits for user input, then returns which button the user clicked. * @param parm String message or configuration Object. */ export function messageBox(parm): string; /** * Retrieve the content of a dataarea into Profound.js Variable. * * @param into Profound.js Variable with 'dataarea' config. * @param lock Boolean to determine whether to lock after dataarea has been retrieved. */ export function retrieveDataArea(into: ProfoundJSVar, lock?: boolean): void; /** * Set the content of the variable into associated dataarea. * * @param from Profound.js Variable with 'dataarea' config. * @param remainLocked Boolean to determine whether to unlock after dataarea has been set. */ export function setDataArea(from: ProfoundJSVar, remainLocked?: boolean): void; /** * Retrieves data areas using `pjs.retrieveDataArea()` for all fields in the module defined with the 'dataArea' config. */ export function retrieveAllAreas(): void; /** * Sets data areas using `pjs.setDataArea()` for all fields in the module defined with the 'dataArea' configuration option. */ export function setAllAreas(): void; /** * Create a dataarea on IBM i. * @param info Object containing children about the dataarea: `name`, `type` and `length`. Optional: `decimals`, `initValue` and `replace`. */ export function createDataArea(info: object): void; /** * Get the content of a dataarea. * @param name Name of dataarea: `OBJ` / `LIB/OBJ` * @param length Length of data area. * @param lock Lock data area when read. False by default. */ export function getDataArea(name: string, length: number, lock?: boolean): any; /** * Set the content of a dataarea. * @param name Name of dataarea: `OBJ` / `LIB/OBJ` * @param data Data which will be placed into the dataarea. Can also be a Buffer. * @param unlock Unlock data area when written to. False by default. */ export function getDataArea(name: string, data: any | Buffer, unlock?: boolean): void; /** * Deallocate a Profound.js Pointer. * @param ProfoundJSVar Profound.js Pointer. */ export function dealloc(ProfoundJSVar: ProfoundJSVar): void; /** * Returns the number of decimals within a declared field or constant. * @param value Primitive or Profound.js Variable. */ export function decimalPositions(value: number | ProfoundJSVar): number; /** * Declare a stronly typed variable (Profound.js Variable) * Read more here: http://www.profoundlogic.com/docs/pages/viewpage.action?pageId=29524321 * @param name Name if Profound.js variable. * @param config Object containing information about the variable. */ export function define(name: string, config: object): void; /** * Creates a rich display file object that can be used by the program * @param name The object name you will reference throughout your program that represents the Rich Display File * @param file The name of the JSON file containing your Rich Display definition. * The file is searched for in the modules directory of the Profound.js installation. * The name can be qualified with a specific modules subdirectory (e.g. "subdir/mydisplay.json"). * If the name is not qualified, the pathlist is used to search for the Rich Display File. * @param config Configuration options for the Rich Display File. * See more here: http://www.profoundlogic.com/docs/pages/viewpage.action?pageId=31752760 */ export function defineDisplay(name: string, file: string, config: object): void; /** * * @param name A variable of this name will be defined in the calling script and * will be populated with a record file instance. * @param file A String specifying the external name of the file object. The name can optionally be qualified with a library. If the library is not specified, then the library list is used to resolve the file. * If the external name is not specified, then the internal name is used instead * @param config Read more here: http://www.profoundlogic.com/docs/pages/viewpage.action?pageId=31031470 */ export function defineTable(name: string, file: string, config: object): void; export function definePrinter(internalName: string, fileConfig: object): void; export function definePrinter(internalName: string, externalName: string, fileConfig: object): void; /** * This API sets field values using the properties of a JavaScript object. * Each object property that has a matching declared field is used to set the field value. * @param object primitive JavaScript object */ export function setFields(object: object): void; /** * This API assigns JavaScript object property values based on declared field values. * Each property that has a matching declared field name is assigned the value of that field. * @param object primitive JavaScript object * @return The modified object is returned by the API. */ export function getFields(object: object): void | Object; /** * Displays HTML content and waits for the user to respond. * @param file An object containing either `html` or `file` which will be displayed in the session. * @param data This parameter is the data object to pass to the template. If omitted, all strongly * typed fields declared within the global scope are passed to the template. * @param EJSoptions An object specifying EJS options as documented on www.ejs.co. */ export function display(file: object, data?: object, EJSoptions?: object): object; export function editCode(value: number, code: string, currencySymbol: string): string; /** * Find a specific file in a list of directories. * @param name Name of the file. * @param directoryList Array of directories. * @return First directory which contains file. */ export function findIFSFile(name: string, directoryList: string[]): string; export function found(): boolean; /** * @param ProfoundJSVar A Profound.js Variable. * @param data Value of `*data` if variable is varying in length. */ export function getBuffer(ProfoundJSVar: ProfoundJSVar, data?: string): Buffer; export function getDSValue(structure: DataStructure): string; export function toObject(structure: DataStructure): object; export function copyToDS(toDS: DataStructure, fromObj: object): void; export function readIFSFile(path: string, ccsid?: number): Buffer; export function writeIFSFile(path: string, data: Buffer, localCCSID: number, remoteCCSID?: number): void; //export function import(path: string, functions?: string[]): void; export function isShuttingDown(): boolean; /** * Returns the maximum value out of all parameters, where parameters can be any data * type, including numbers, strings, or dates. */ export function max(...values: any): any; /** * Returns the minimum value out of all parameters, where parameters can be any data * type, including numbers, strings, or dates. */ export function min(...values: any): any; /** * **USE WITH CAUTION**. * Move values from one field to another, left or right adjusted, without any type checking. * Right adjusted. * @param source Source Profound.js Variable * @param target Target Profound.js Variable * @param format Time / Date format. Can be null if not required. * @param pad if true, the target variable is first cleared. */ export function move(source: any, target: ProfoundJSVar, format?: string, pad?: boolean): void; /** * **USE WITH CAUTION**. * Move values from one field to another, left or right adjusted, without any type checking. * Left adjusted. * @param source Source Profound.js Variable * @param target Target Profound.js Variable * @param format Time / Date format. Can be null if not required. * @param pad if true, the target variable is first cleared. */ export function moveLeft(source: any, target: ProfoundJSVar, format?: string, pad?: boolean): void; /** * **USE WITH CAUTION**. * moves elements from and/or to an array. If padding is specified, it will clear * out the remaining characters and elements in the target after the move is complete. * @param source Source array. * @param sourceIndex 1 or higher, start from this index when working with the source * @param targetArray Target array * @param targetIndex 1 or higher, start from this index when working with the target * @param padding if passed in as true, the target will be padded. */ export function moveArray(source: ProfoundJSVar, sourceIndex: number, targetArray: ProfoundJSVar, targetIndex: number, padding?: boolean): void; //ALL MOVE X TO X ZONE functions /** * * @param ProfoundJSVar Profound.js Variable which is null-capable. * @param isNull If provided, will set the fields null indicator to provided value. * @return Returns whether the variable is null or not. */ export function nullInd(ProfoundJSVar: ProfoundJSVar, isNull?: boolean): boolean; export function getOccur(structure: DataStructure): number; export function setOccur(structure: DataStructure, occurance: number): void; /** * Used for passing parameters by value with pjs.call(). * @param value Primitive value. * @param config A configuration object of the format used by pjs.define(). */ export function parm(value: any, config: object): object; /** * Used for passing parameters by value with pjs.call(). * @param varname A string containing the name of a Profound.js field. */ export function parm(varname: string): object; export function parseFloat(value: string): number; export function parseInt(value: string): number; //export function pointerString //export function procAddr /** * A shortcut for executing an SQL statement and automatically fetching the results. * There are more variables of the API. See here: http://www.profoundlogic.com/docs/pages/viewpage.action?pageId=37028376 * @param query An SQL statement. * @param parameters If parameter markers are used, pass them in as following parameters. */ export function query(query: string, ...parameters?: any): object; /** * Reallocate storage. * @param pointer The name of a Profound.js pointer Variable that points to a buffer * allocated with pjs.alloc(). * @param newSize The desired size of the buffer. */ export function realloc(pointer: ProfoundJSVar, newSize: number): void; /** * Returns a reference to a Profound.js Variable. */ export function refParm(ProfoundJSVar: ProfoundJSVar): object; /** * `var myModule = pjs.require("mydir/myModule");` * @param modulePath A string containing the module file name to load. * @param options An object with the following properties: * 'hotReload' boolean, 'isProgram' boolean (will then return a single function), * 'isServiceProgram' boolean (will return an object of functions). */ export function require(modulePath: string, options?: object): Function | object; /** * `var myModule = pjs.require("mydir/myModule");` * @param modulePath A string containing the module file name to load. * @param options An object with the following properties: 'hotReload' boolean * @return An object of functions defined in the provided module. */ export function requireModule(modulePath: string, options?: object): object; export function requireServiceProgram(ProfoundJSVar: ProfoundJSVar, options?: Object): object; /** * Run a command on IBM i. * @param command IBM i command. */ export function runCommand(command: string): void; /** * Used to send a request to a JSON API. * @param method HTTP method to use. E.g. `post`, `get`, etc * @param endpoint URL to the web service. * @param options If an object is passed the request will be a JSON request, * otherwise it will be a plain text request. * @return Will return JSON if a JSON message is passed in. */ export function sendRequest(method: string, endpoint: string, message: object | string): any; /** * @param options The 'options' object passed into the request API. * https://github.com/request/request#requestoptions-callback */ export function sendRequest(options: object): any; export function set(ProfoundJSVar: string, value: any): void; /** * Set a Profound.js to the current time. */ export function setCurrentTime(ProfoundJSVar: ProfoundJSVar): void; //export function setFields //export function getSQLOption export function sortArray(array: any[], descending: boolean, startElement?: number, numberOfElements?: number): void; export let START: any; export let END: any; export let HIGH_VALUE: any; export let LOW_VALUE: any; //export function status //export function tableLookup //export function testBit export function testNumeric(number: string): boolean; //export function testTimestamp export function testZone(value: string): object; export function toDate(date: any): Date; export function unsignedInt(value: number, halfAdjust?: boolean): boolean; /** * Commits pending changes to all files that are open under commitment control. */ export function commit(boundary?: boolean): void; /** * Returns the end of file status set by the most recent file operation. */ export function endOfData(): boolean; //export function equal(): boolean; /** * The value returned by this method can be passed to file.update() to * control which fields are updated in the record. * @param fields One or more Profound.js Variables */ export function fields(...fields: ProfoundJSVar): any; /** * This method indicates whether or not a record was found by a prior call * to file.getRecord(), file.positionTo(), file.positionAfter(), * or file.delete(searchArgument). */ export function found(): boolean; /** * This method returns a data structure's sub-field values in an array, * which is suitable for use as the search argument for the file.positionTo(), * file.positionAfter(), file.getRecord(), file.fetchNextEqual(), * file.fetchPreviousEqual(), and file.delete() APIs. * @param structure Profound.js Data Structure */ export function kds(structure: DataStructure): any; /** * Rolls back pending changes to all files that are open under commitment control. */ export function rollBack(): void; //BELOW IS ALL SQL FUNCTIONS AND CLASSES /** * Retrieves the current database connection established by Profound.js. * Each database driver may have its own unique properties and * methods attached to the connection object. */ export function getConnection(): object; /** * Allocates a statement handle. */ export function allocStmt(): SQLStatement; /** * Prepares a statement to execute. You only need to prepare a statement * if you have parameter markers, identified by ? (question mark) symbols, * in the SQL. You may use executeDirect() otherwise. */ export function prepare(query: string): SQLStatement; /** * Returns the IBM i or Profound.js Spaces user name, if signed in. */ export function getUser(): string; /** * Spawns a child processs. * @param cmd The command to run. * @param args Array of arguments to pass to the command. * @param options Options object. See child_process.spawn() for details. * @param input Input to write to stdin of the spawned process. * @return An object containing data from the process's stdout and stderr, if any, along with the exit code or singal that ended the process. */ export function spawn(cmd: string, args?: string[], options?: object, input?: string): object; export class SQLStatement { /** * Close the statement handle. */ public close(): void; /** * Bind variables to parameter markers in a prepared statement. * `[[searchQuery.trim(), SQL_PARAM_INPUT], [searchQuery.trim(), SQL_PARAM_INPUT]]` * @param parameters Must be an array of arrays. For example: */ public bindParameters(parameters: any[]): void; /** * Executes a prepared statement. It should be be called after parameter binding. */ public execute(): void; /** * Execute a non-prepared statement on IBM i, * which can be used if there are no parameter markers in your SQL. */ public executeDirect(query: string): void; /** * Fetch the next row(s) from the cursor associated with the statement handle. * **Used for returning primitive data only.** * @param rows Amount of rows to return. Can pass SQL_FETCH_ALL for all rows. * @return An array of rows. */ public fetch(rows?: number): object[]; //FETCH AND FETCHNEXT ARE THE SAME /** * Fetch the next row(s) from the cursor associated with the statement handle. * **Used for returning primitive data only.** * @param rows Amount of rows to return. Can pass SQL_FETCH_ALL for all rows. * @return An array of rows. */ public fetchNext(rows?: number): object[]; /** * Fetch the prior row(s) from the cursor associated with the statement handle. * **Used for returning primitive data only.** * @param rows Amount of rows to return. Can pass SQL_FETCH_ALL for all rows. * @return An array of rows. */ public fetchPrior(rows?: number): object[]; public fetchFirst(rows?: number): object[]; public fetchLast(rows?: number): object[]; /** * Fetches a row from the cursor associated with the current statement handle, * relative to the cursor's current row. * @param offset Number that specifies the offset of the row to fetch, relative to the current cursor position. * @param rows Amount of rows to return. Can pass SQL_FETCH_ALL for all rows. * @return An array of rows. */ public fetchRelative(offset: number, rows?: number): object[]; /** * Fetches a specific row from the cursor associated with the statement handle. * @param row The row number to fetch. The first row is considered row number 1. * @param rows Amount of rows to return. Can pass SQL_FETCH_ALL for all rows. * @return An array of rows. */ public fetchAbsolute(row: number, rows?: number): object[]; /** * Sets an attribute of the statement handle. */ public setStmtAttr(attribute: any, value: any): void; /** * returns the number of database rows returned from the most recent * fetch from the passed SELECT statement handle. */ public rowCount(): number; /** * Indicates whether or not the last row of the result set was returned * from the most recent fetch on the passed statement handle. */ public hasMoreRows(): boolean; /** * Indicates whether the end of data has been reached for the most recent fetch * of a statement handle. It is the opposite of pjs.hasMoreRows(). */ public endOfData(): boolean; } /** * Profound.js API for accessing data from a database. */ export let data: { /** * A shortcut for adding record(s) to a database. * There are more variables of the API. See here: https://docs.profoundlogic.com/x/gQDrAw * @param dbObject A database table or view. * @param data An object containing same named properties and values, which will to be added into the database. */ add(dbObject: string, data: any): object; /** * A shortcut for creating filter conditions that work across all databases. * There are more variables of the API. See here: https://docs.profoundlogic.com/x/hgDrAw * @param columnName A column name of a database table or view. * @param operator The SQL operator such as: =, >=, is not null, is null... * @param value The value to use for this condition (optional) */ createCondition(columnName: string, operator: string, value?: any): object; /** * A shortcut for deleting record(s) from a database. * There are more variables of the API. See here: https://docs.profoundlogic.com/x/gwDrAw * @param dbObject A database table or view. * @param filter A filter to be applied to narrow which records are deleted; Default is null = Any record */ delete(dbObject: string, filter?: any): object; /** * A shortcut for retrieving record(s) from a database. * There are more variables of the API. See here: https://docs.profoundlogic.com/x/jwDrAw * @param dbObject A database table or view. * @param filter A filter to be applied to narrow which records are retrieved; Default is null = Any record * @param limit Maximum number of records to retrieve; Default is null = No limit * @param skip Number of records to skip; Default is null = 0 * @param orderby The column(s) used to order the records; Default is null = none * @param select The column(s) to be retrieved; Default = * = All columns */ get(dbObject: string, filter?: any, limit?: number, skip?: number, orderby?: any, select?: any): Array | object; /** * A shortcut for retrieving record(s) from a database. * There are more variables of the API. See here: https://docs.profoundlogic.com/x/lgDrAw * @param dbObject A database table or view. * @param filter A filter to be applied to narrow which records are counted; Default is null = Any record */ getCount(dbObject: string, filter?: any): number; /** * A shortcut for updating record(s) from a database. * There are more variables of the API. See here: https://docs.profoundlogic.com/x/mADrAw * @param dbObject A database table or view. * @param filter A filter to be applied to narrow which records are deleted; null = All records * @param data An object containing same named properties and values, which will to be applied/updated to each record. */ update(dbObject: string, filter: any, data: any): object; } /** * Profound.js API helper for creating database agnostic SQL statements. */ export let sqlHelper: { /** * Format a table/view name * See here: https://docs.profoundlogic.com/x/_gAyAw for additional information. * @param targetDB The target database type: IBMi, mysql, mssql, oracledb... * @param dbObject A database table or view. * @returns dbOjectName with appropiate escape characters */ formatTableName(targetDB: string, dbObject: string): string; /** * Format a column name * See here: https://docs.profoundlogic.com/x/_gAyAw for additional information. * @param targetDB The target database type: IBMi, mysql, mssql, oracledb... * @param columnName A database column name. * @returns columnName with appropiate escape characters */ formatColumnName(targetDB: string, columnName: string): string; /** * Get parameter token based on type of database * See here: https://docs.profoundlogic.com/x/_gAyAw for additional information. * @param targetDB The target database type: IBMi, mysql, mssql, oracledb... * @param value The value of the parameter * @param columnType The data type of this parameter * @returns parameter token */ getParameterToken(targetDB: string, value: any, columnType: string): string; /** * Inject limits into a SQL Statement * See here: https://docs.profoundlogic.com/x/_gAyAw for additional information. * @param targetDB The target database type: IBMi, mysql, mssql, oracledb... * @param sqlString An sql string. * @param limit Maximum number of rows to return, null = no max * @param skip Number of rows to skip, null = do not skip any * @returns sqlString with limits injected into it */ injectLimits(targetDB: string, sqlString: string, limit: number, skip: number): string; /** * Finalize a SQL statement so that it can be passed into the pjs.query() API * See here: https://docs.profoundlogic.com/x/_gAyAw for additional information. * @param targetDB The target database type: IBMi, mysql, mssql, oracledb... * @param sqlString An sql string. * @param parameters The parameters values. * @returns Database specific SQL statement */ finalizeSQL(targetDB: string, sqlString: string, parameters: any[]): string; /** * Log an SQL statement with parameter values * See here: https://docs.profoundlogic.com/x/_gAyAw for additional information. * @param sqlString An sql string. * @param parameters The parameters values. */ dumpSQLStatement(sqlString: string, parameters: any[]): void; } }