stimulsoft-reports-js
Version:
Stimulsoft Reports.JS is a reporting tool for Node.js
1,298 lines • 3.08 MB
TypeScript
/*
Stimulsoft.Reports.JS
Version: 2025.4.1
Build date: 2025.10.06
License: https://www.stimulsoft.com/en/licensing/reports
*/
export namespace Stimulsoft.System {
class Activator {
static createInstance(type: Type): any;
}
}
export namespace Stimulsoft.System {
class Attribute {
}
}
export namespace Stimulsoft.ExternalLibrary.Blockly {
let blocklyToolbox: string;
let blocklyToolboxCurrentValue: string;
let blocklyWorkspace: string;
let blocklyBlocks: string;
}
export namespace Stimulsoft.System.Globalization {
enum UnicodeCategory {
UppercaseLetter = 0,
LowercaseLetter = 1,
TitlecaseLetter = 2,
ModifierLetter = 3,
OtherLetter = 4,
NonSpacingMark = 5,
SpacingCombiningMark = 6,
EnclosingMark = 7,
DecimalDigitNumber = 8,
LetterNumber = 9,
OtherNumber = 10,
SpaceSeparator = 11,
LineSeparator = 12,
ParagraphSeparator = 13,
Control = 14,
Format = 15,
Surrogate = 16,
PrivateUse = 17,
ConnectorPunctuation = 18,
DashPunctuation = 19,
OpenPunctuation = 20,
ClosePunctuation = 21,
InitialQuotePunctuation = 22,
FinalQuotePunctuation = 23,
OtherPunctuation = 24,
MathSymbol = 25,
CurrencySymbol = 26,
ModifierSymbol = 27,
OtherSymbol = 28,
OtherNotAssigned = 29
}
}
export namespace Stimulsoft.System {
class Char {
static isUpper(char: string, index?: number): boolean;
static isLower(char: string, index?: number): boolean;
static isLetter(char: string, index?: number): boolean;
static isDigit(char: string | number, index?: number): boolean;
static isLetterOrDigit(char: string, index?: number): boolean;
static toLower(char: string): string;
static toUpper(char: string): string;
static isWhitespace(char: string, index?: number, allowNbsp?: boolean): boolean;
private static checkLetter;
static getUnicodeCategory(char: string, index?: number): number;
static isControl(char: string, index?: number): boolean;
}
}
export namespace Stimulsoft.System {
class Chars {
static getUnicodeCategory(char: number): number;
private static _table_0;
private static _table_9fc0;
private static _table_d780;
private static _table_fa40;
}
}
export namespace Stimulsoft.System {
class Convert {
static changeType(value: any, type: Type): any;
static changeType2(value: any, typeCode: TypeCode): any;
static toDateTime(value: any): DateTime;
static toString(value: any, format?: string): string;
static toFont(value: string): Stimulsoft.System.Drawing.Font;
static toBoolean(value: any): boolean;
static toNumber(value: any): number;
static toDouble(value: any): number;
static toInt32(value: any, radix?: number): number;
static toInt64(value: any): number;
static toUInt64(value: any): number;
static toUInt32(value: any): number;
private static bytesToBase64String;
static toBase64String(input: string | number[] | Uint8Array): string;
private static base64StringToBytes;
static fromBase64String(input: string): number[];
static fromBase64StringText(input: string): string;
static fromUTF16LE<T extends string | number[] | Uint8Array>(input: T): T;
static isUTF16LE(input: string | number[] | Uint8Array): boolean;
static stripBom<T extends string | number[]>(data: T): T;
}
}
export namespace Stimulsoft.System {
class NodeJs {
private static isInitialize;
static initialize(onResult?: Function): void;
static get fs(): {
readdirSync: (path: string) => string[];
existsSync: (path: string) => boolean;
exists: (path: string, cb: (exists: boolean) => void) => void;
mkdirSync: (path: string, options: {
recursive: boolean;
}) => void;
rmSync: (path: string, options: {
recursive: boolean;
force: boolean;
}) => void;
readFileSync: (path: string, code?: string) => string;
writeFileSync: (parh: string, data: string) => void;
writeFile: (path: string, data: any, cb: (error: string) => void) => void;
promises: {
mkdtemp: (path: string) => Promise<string>;
writeFile: (path: string, data: string) => Promise<void>;
rm: (path: string, options: {
recursive: boolean;
force: boolean;
}) => Promise<void>;
};
createReadStream: (path: string) => {
setEncoding: (code: string) => void;
read: (count: number) => string;
on: (event: string, cb: () => void) => void;
removeListener: (event: string, cb: () => void) => void;
};
};
static get path(): {
extname: (path: string) => string;
basename: (path: string, suffix?: string) => string;
join: (...args: string[]) => string;
sep: string;
};
static get os(): {
hostname: () => string;
networkInterfaces: () => {
Ethernet: {
mac: string;
}[];
Wireless80211: {
mac: string;
}[];
};
userInfo: () => {
username: string;
};
tmpdir: () => string;
platform: () => string;
type: () => string;
release: () => string;
};
static get http(): {
request: (options: {}, cb: (response: {
setEncoding: (code: string) => void;
on: (event: string, cb: (data: any) => void) => void;
statusCode: number;
statusMessage: string;
}) => void) => {
on: (event: string, cb: (data: any) => void) => void;
write: (data: string) => void;
end: () => void;
};
};
static get https(): {
request: (options: {}, cb: (response: {
setEncoding: (code: string) => void;
on: (event: string, cb: (data: any) => void) => void;
statusCode: number;
statusMessage: string;
}) => void) => {
on: (event: string, cb: (data: any) => void) => void;
write: (data: string) => void;
end: () => void;
};
};
static get url(): {
parse: (url: string) => {
protocol: string;
hostname: string;
path: string;
port: number;
};
};
static require(module: string): any;
private static convertInternal;
private static getEmbeddedFonts;
private static convertSvgToPng;
static sendAsync(method: string, url: string, body?: string, headers?: Header[], timeout?: number): StiPromise<{
status: number;
responseText: string;
statusText: string;
}>;
static callRemoteApi(command: any, timeout: number): StiPromise<string>;
static getFile(filePath: string, binary: boolean, contentType: string, headers: Header[], disableCache?: boolean, withCredentials?: boolean, allowException?: boolean): any;
static getFileHttp(filePath: string, binary: boolean, contentType: string, headers: Header[], disableCache?: boolean, withCredentials?: boolean, allowException?: boolean): any;
static send(method: string, url: string, body: string, headers?: Header[]): {
status: number;
responseText: string;
statusText: string;
};
static saveAs(data: any, fileName: string, type?: string): any;
static saveFile(filePath: string, fileData: string | number[]): void;
static getFilesNames(filesPath: string): string[];
static getSep(): string;
private static fromBase64String;
private static fromBase64StringText;
private static toBase64String;
private static fromUnicodeString;
private static _isNodeJs;
static isNodeJs(): boolean;
static isBuffer(data: any): boolean;
static isStandaloneVersion: boolean;
static useWebKit: boolean;
get consoleLog(): boolean;
set consoleLog(value: boolean);
private static fillInfo;
static localizationPath: string;
private static getLocalizationInfo;
private static syncRequest;
}
}
export namespace Stimulsoft.System.Globalization {
class TextInfo {
listSeparator: string;
toTitleCase(str: string): string;
constructor(listSeparator?: string);
}
}
export namespace Stimulsoft.System.Globalization {
import IFormatProvider = Stimulsoft.System.IFormatProvider;
import Type = Stimulsoft.System.Type;
class NumberFormatInfo implements IFormatProvider {
numberDecimalSeparator: string;
numberDecimalDigits: number;
numberGroupSeparator: string;
numberGroupSizes: number[];
numberNegativePattern: number;
currencyDecimalDigits: number;
currencyDecimalSeparator: string;
currencyGroupSeparator: string;
currencyGroupSizes: number[];
currencyNegativePattern: number;
currencyPositivePattern: number;
currencySymbol: string;
percentDecimalDigits: number;
percentDecimalSeparator: string;
percentGroupSeparator: string;
percentGroupSizes: number[];
percentNegativePattern: number;
percentPositivePattern: number;
percentSymbol: string;
perMilleSymbol: string;
positiveInfinitySymbol: string;
positiveSign: string;
NaNSymbol: string;
negativeInfinitySymbol: string;
negativeSign: string;
getFormat(formatType: Type): any;
constructor(numberDecimalSeparator?: string, numberDecimalDigits?: number, numberGroupSeparator?: string, numberGroupSizes?: number[], numberNegativePattern?: number, currencyDecimalDigits?: number, currencyDecimalSeparator?: string, currencyGroupSeparator?: string, currencyGroupSizes?: number[], currencyNegativePattern?: number, currencyPositivePattern?: number, currencySymbol?: string, percentDecimalDigits?: number, percentDecimalSeparator?: string, percentGroupSeparator?: string, percentGroupSizes?: number[], percentNegativePattern?: number, percentPositivePattern?: number, percentSymbol?: string, perMilleSymbol?: string, positiveInfinitySymbol?: string, positiveSign?: string, NaNSymbol?: string, negativeInfinitySymbol?: string, negativeSign?: string);
}
}
export namespace Stimulsoft.System.Globalization {
class DateTimeFormatInfo {
shortDatePattern: string;
dateSeparator: string;
longDatePattern: string;
dayNames: string[];
monthNames: string[];
shortestDayNames: string[];
abbreviatedMonthNames: string[];
monthGenitiveNames: string[];
timeSeparator: string;
AMDesignator: string;
PMDesignator: string;
fullDateTimePattern: string;
shortTimePattern: string;
longTimePattern: string;
yearMonthPattern: string;
calendarWeekRule: Stimulsoft.System.Globalization.CalendarWeekRule;
firstDayOfWeek: Stimulsoft.System.DayOfWeek;
constructor(shortDatePattern: string, dateSeparator: string, longDatePattern: string, dayNames: string[], monthNames: string[], shortestDayNames: string[], abbreviatedMonthNames: string[], monthGenitiveNames: string[], timeSeparator: string, AMDesignator: string, PMDesignator: string, fullDateTimePattern: string, shortTimePattern: string, longTimePattern: string, yearMonthPattern: string, calendarWeekRule: Stimulsoft.System.Globalization.CalendarWeekRule, firstDayOfWeek: Stimulsoft.System.DayOfWeek);
}
}
export namespace Stimulsoft.System.Globalization {
class CultureInfo {
numberFormat: NumberFormatInfo;
dateTimeFormat: DateTimeFormatInfo;
name: string;
readonly displayName: string;
textInfo: TextInfo;
regionInfo: RegionInfo;
private static _cultures;
private static _currentCulture;
static get currentCulture(): CultureInfo;
static set currentCulture(val: CultureInfo);
static get cultures(): {
[key: string]: CultureInfo;
};
static get ivariantCulture(): CultureInfo;
static getCultureInfo(name: string): CultureInfo;
constructor(name: string, numberFormat?: NumberFormatInfo, dateTimeFormat?: DateTimeFormatInfo, textInfo?: TextInfo, displayName?: string);
}
}
export namespace Stimulsoft.System {
class DateTime {
private static ticksPerMillisecond;
private static ticksPerSecond;
private static ticksPerMinute;
private static ticksPerHour;
private static ticksPerDay;
private static daysPerYear;
private static daysPer4Years;
private static daysPer100Years;
private static daysPer400Years;
private static daysTo10000;
private static minTicks;
private static maxTicks;
private static daysToMonth365;
private static daysToMonth366;
static minValue: DateTime;
static maxValue: DateTime;
static getFullTypeName(): string;
dateTimeOffset: string;
private innerDate;
get year(): number;
get month(): number;
get monthName(): string;
get monthGenitiveName(): string;
get monthShortName(): string;
get day(): number;
get dayOfWeek(): DayOfWeek;
get dayName(): string;
get dayShortName(): string;
get hour(): number;
get minute(): number;
get second(): number;
get millisecond(): number;
get ticks(): number;
get dayOfYear(): number;
firstDayOfWeek(): DateTime;
lastDayOfWeek(): DateTime;
firstDayOfMonth(): DateTime;
lastDayOfMonth(): DateTime;
firstDayOfQuarter(): DateTime;
lastDayOfQuarter(): DateTime;
lastDateTimeOfDay(): DateTime;
firstDayOfFirthQuarter(): DateTime;
lastDayOfFirthQuarter(): DateTime;
firstDayOfSecondQuarter(): DateTime;
lastDayOfSecondQuarter(): DateTime;
firstDayOfThirdQuarter(): DateTime;
lastDayOfThirdQuarter(): DateTime;
firstDayOfFourthQuarter(): DateTime;
lastDayOfFourthQuarter(): DateTime;
firstDayOfYear(): DateTime;
lastDayOfYear(): DateTime;
toShortDateString(): string;
toShortTimeString(): string;
static get now(): DateTime;
static get today(): DateTime;
static isLeapYear(year: number): boolean;
static daysInMonth(year: number, month: number): number;
static compare(t1: DateTime, t2: DateTime): number;
static ticksNetToTicksJs(ticks: number): number;
static dateToNetTicks(date: Date): number;
negate(): DateTime;
addYears(value: number): DateTime;
addMonths(value: number): DateTime;
addDays(value: number): DateTime;
addHours(value: number): DateTime;
addMinutes(value: number): DateTime;
addSeconds(value: number): DateTime;
addMilliseconds(value: number): DateTime;
addTicks(value: number): DateTime;
compareTo(value: DateTime): number;
subtract(value: DateTime): TimeSpan;
get date(): DateTime;
get jsDate(): Date;
toString(format?: string): string;
static oaDateToTicks0(oaDate: number): number;
static ticksToOADate0(ticks: number): number;
toOADate(): number;
toOADate2(round: boolean): number;
toNetJsonString(): string;
getHashCode(): number;
static parse(value: string): DateTime;
static tryParse(d?: string): {
result: DateTime;
successfully: boolean;
};
static tryParseExact(d: string, format: string[]): {
result: DateTime;
successfully: boolean;
};
static fromNetJsonString(jsonDate: string): DateTime;
static fromOADate(oadate: number): DateTime;
private static dayjsFormatsSlash;
private static dayjsFormats;
private static dayjsFormatsMilliseconds;
private static lastDayjsFormat;
static fromString(d?: string, logError?: boolean): DateTime;
static fromString2(format: string, value: string, logError?: boolean): DateTime;
private static dayjsIsoDateFormats;
static isISO8601String(d: string): boolean;
get timeOfDay(): TimeSpan;
equals(date: DateTime): boolean;
constructor(param1: Date | number, month?: number, day?: number, hour?: number, minute?: number, second?: number, millisecond?: number);
}
}
export namespace Stimulsoft.System {
import DateTime = Stimulsoft.System.DateTime;
class DateOnly implements IComparable<DateOnly> {
implements(): any[];
private internalValue;
static get now(): DateOnly;
static get minValue(): DateOnly;
static get maxValue(): DateOnly;
get year(): number;
get month(): number;
get day(): number;
toString(format?: string): string;
subtract(date: DateOnly): TimeSpan;
toDateTime(): DateTime;
toODate(): number;
static fromDateTime(dateTime: DateTime): DateOnly;
static parse(s: string): DateOnly;
static tryParse(s: string, refResult: {
ref: DateOnly;
}): boolean;
compareTo(other: DateOnly): number;
equals(date: any): boolean;
getHashCode(): number;
constructor(dateTime: DateTime);
}
}
export namespace Stimulsoft.System {
class DateTimeOffset extends DateTime {
static getFullTypeName(): string;
static fromString(d?: string, logError?: boolean): DateTimeOffset;
static parse(value: string): DateTimeOffset;
static get now(): DateTimeOffset;
get dateTime(): DateTime;
constructor(param1: Date | number, month?: number, day?: number, hour?: number, minute?: number, second?: number, millisecond?: number);
}
}
export namespace Stimulsoft.System {
enum DayOfWeek {
Sunday = 0,
Monday = 1,
Tuesday = 2,
Wednesday = 3,
Thursday = 4,
Friday = 5,
Saturday = 6
}
}
export namespace Stimulsoft.ExternalLibrary {
type Input = Stimulsoft.ExternalLibrary.dayjs.ConfigType;
type Dayjs = Stimulsoft.ExternalLibrary.dayjs.Dayjs;
type OptionType = Stimulsoft.ExternalLibrary.dayjs.OptionType;
function dayjs(date?: Input): Dayjs;
function dayjs(date?: Input, format?: OptionType, strict?: boolean): Dayjs;
function dayjs(date?: Input, format?: OptionType, locale?: string, strict?: boolean): Dayjs;
}
export namespace Stimulsoft.ExternalLibrary.dayjs {
interface ConfigTypeMap {
default: string | number | Date | Dayjs | null | undefined;
}
type ConfigType = ConfigTypeMap[keyof ConfigTypeMap];
interface FormatObject {
locale?: string;
format?: string;
utc?: boolean;
}
type OptionType = FormatObject | string | string[];
type UnitTypeShort = 'd' | 'M' | 'y' | 'h' | 'm' | 's' | 'ms';
type UnitTypeLong = 'millisecond' | 'second' | 'minute' | 'hour' | 'day' | 'month' | 'year' | 'date';
type UnitTypeLongPlural = 'milliseconds' | 'seconds' | 'minutes' | 'hours' | 'days' | 'months' | 'years' | 'dates';
type UnitType = UnitTypeLong | UnitTypeLongPlural | UnitTypeShort;
type OpUnitType = UnitType | "week" | "weeks" | 'w';
type QUnitType = UnitType | "quarter" | "quarters" | 'Q';
type ManipulateType = Omit<OpUnitType, 'date' | 'dates'>;
interface ILocale {
name: string;
weekdays?: string[];
months?: string[];
weekStart?: number;
weekdaysShort?: string[];
monthsShort?: string[];
weekdaysMin?: string[];
ordinal?: (n: number) => number | string;
formats: Partial<{
LT: string;
LTS: string;
L: string;
LL: string;
LLL: string;
LLLL: string;
}>;
relativeTime?: Partial<{
future: string;
past: string;
s: string;
m: string;
mm: string;
h: string;
hh: string;
d: string;
dd: string;
M: string;
MM: string;
y: string;
yy: string;
}>;
meridiem: {
AM: string;
PM: string;
};
}
class Dayjs {
constructor(config?: ConfigType);
clone(): Dayjs;
isValid(): boolean;
year(): number;
year(value: number): Dayjs;
month(): number;
month(value: number): Dayjs;
date(): number;
date(value: number): Dayjs;
day(): number;
day(value: number): Dayjs;
hour(): number;
hour(value: number): Dayjs;
minute(): number;
minute(value: number): Dayjs;
second(): number;
second(value: number): Dayjs;
millisecond(): number;
millisecond(value: number): Dayjs;
set(unit: UnitType, value: number): Dayjs;
get(unit: UnitType): number;
add(value: number, unit?: ManipulateType): Dayjs;
subtract(value: number, unit?: ManipulateType): Dayjs;
startOf(unit: OpUnitType): Dayjs;
endOf(unit: OpUnitType): Dayjs;
format(template?: string): string;
diff(date?: ConfigType, unit?: QUnitType | OpUnitType, float?: boolean): number;
valueOf(): number;
unix(): number;
daysInMonth(): number;
toDate(): Date;
toJSON(): string;
toISOString(): string;
toString(): string;
utcOffset(): number;
isBefore(date: ConfigType, unit?: OpUnitType): boolean;
isSame(date: ConfigType, unit?: OpUnitType): boolean;
isAfter(date: ConfigType, unit?: OpUnitType): boolean;
locale(): string;
locale(preset: string | ILocale, object?: Partial<ILocale>): Dayjs;
}
interface Dayjs {
quarter(): number;
quarter(quarter: number): Dayjs;
add(value: number, unit: QUnitType): Dayjs;
subtract(value: number, unit: QUnitType): Dayjs;
startOf(unit: QUnitType): Dayjs;
endOf(unit: QUnitType): Dayjs;
isSame(date: ConfigType, unit?: QUnitType): boolean;
isBefore(date: ConfigType, unit?: QUnitType): boolean;
isAfter(date: ConfigType, unit?: QUnitType): boolean;
}
type PluginFunc<T = unknown> = (option: T, c: typeof Dayjs, d: typeof dayjs) => void;
function extend<T = unknown>(plugin: PluginFunc<T>, option?: T): Dayjs;
function locale(preset?: string | ILocale, object?: Partial<ILocale>, isLocal?: boolean): string;
function isDayjs(d: any): d is Dayjs;
function unix(t: number): Dayjs;
const Ls: {
[key: string]: ILocale;
};
}
export namespace Stimulsoft.System {
class Enum {
static getName(enumType: any, value: number): string;
static parse(enumType: any, value: string | number, upperFirstChar?: boolean): number;
private static upperFirstChar;
static getNames(enumType: any): string[];
static getValues(enumType: any): number[];
static isEnum(enumType: any): boolean;
name: string;
value: number;
toString(): string;
compareTo(value: Enum): number;
constructor(name: string, value?: number);
}
}
export namespace Stimulsoft.System {
class Environment {
static get newLine(): string;
}
}
export namespace Stimulsoft.System {
class Event {
private eventList;
get isNull(): boolean;
get isNotNull(): boolean;
add(funct: Function, _this: any): void;
call(...args: any[]): void;
}
}
export namespace Stimulsoft.System {
class EventArgs {
static empty: EventArgs;
}
}
export namespace Stimulsoft.System {
class LogStatus {
get isImportant(): boolean;
get isAll(): boolean;
}
class Exception extends Error {
innerException?: Exception;
static log(exception: Exception | string, obj: any, message?: string): LogStatus;
static logEvent(exception: Exception | string, compObject: any, eventName: string): LogStatus;
static logExpression(exception: Exception | string, compObject: any, propertyName: string): LogStatus;
static logSeriesExpression(exception: Exception | string, compObject: any, series: string, propertyName: string): LogStatus;
static getMessage(exception: Exception | string): string;
constructor(message?: string, innerException?: Exception);
}
}
export namespace Stimulsoft.ExternalLibrary.Fontkit {
type FontKitType = {
familyName: string;
head: {
macStyle: {
bold: boolean;
italic: boolean;
underline: boolean;
};
};
fonts: [];
};
function create(buffer: number[] | ArrayBuffer | Uint8Array): FontKitType;
}
export namespace Stimulsoft.System {
class Guid {
private id;
static newGuid(): Guid;
static newGuidString(): string;
private static s4;
toString(): string;
toByteArray(): number[];
static get empty(): Guid;
static compareTo(value: Guid): number;
constructor(id: string);
}
}
export namespace Stimulsoft.System {
class Header {
key: string;
value: string;
static concatArray(headers1: Header[], headers2: Header[]): Header[];
}
}
export namespace Stimulsoft.System {
class Interface<T> {
typeName: string;
type: T;
constructor(typeName: string);
}
}
export namespace Stimulsoft.System {
let IAsIs: Interface<IAsIs>;
interface IAsIs {
is<T>(type: (new (...args: any[]) => T) | Interface<T>): this is T;
is2<T>(type: (new (...args: any[]) => T) | Interface<T>): boolean;
as<T>(type: (new (...args: any[]) => T) | Interface<T>): T;
}
}
export namespace Stimulsoft.System {
let ICloneable: Interface<ICloneable>;
interface ICloneable {
clone(): any;
}
}
export namespace Stimulsoft.System {
let IComparable: Interface<IComparable<any>>;
interface IComparable<T> {
compareTo(obj: T): number;
}
}
export namespace Stimulsoft.System {
let IDisposable: Interface<IDisposable>;
interface IDisposable {
dispose(): any;
}
}
export namespace Stimulsoft.System {
let IFormatProvider: Interface<IFormatProvider>;
interface IFormatProvider {
getFormat(formatType: Type): any;
}
}
export namespace Stimulsoft.System {
interface IRefOut<T> {
arg: T;
}
}
export namespace Stimulsoft.System {
class JSON2 {
static decode(text: string): any;
static encode(value: any): string;
static stiPopulateObject(json: any, object: any): void;
}
}
export namespace Stimulsoft.System.Reflection {
enum BindingFlags {
Default = 0,
IgnoreCase = 1,
DeclaredOnly = 2,
Instance = 4,
Static = 8,
Public = 16,
NonPublic = 32,
FlattenHierarchy = 64,
InvokeMethod = 256,
CreateInstance = 512,
GetField = 1024,
SetField = 2048,
GetProperty = 4096,
SetProperty = 8192
}
}
export namespace Stimulsoft.System {
import IAsIs = Stimulsoft.System.IAsIs;
import BindingFlags = Stimulsoft.System.Reflection.BindingFlags;
const compactBase64: (value: string) => string;
const decompressLiteral: (value: any) => any;
function applyMixins(dest: any, mixins: any[]): any;
function enumerable(value: boolean): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
function enumType(type: any): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
function promiseCancellable(target: any, name: string, descriptor: PropertyDescriptor): any;
class StiObject implements IAsIs {
value: any;
is<T>(type: (new (...args: any[]) => T) | Interface<T>): this is T;
is2<T>(type: (new (...args: any[]) => T) | Interface<T>): boolean;
as<T>(type: (new (...args: any[]) => T) | Interface<T>): T;
memberwiseClone(isBase?: boolean): any;
equals(...args: any[]): boolean;
getHashCode(...args: any[]): number;
static compareTo(a: any, b: any): number;
compareTo(object: any): number;
toBoolean(): boolean;
toNumber(float?: boolean): number;
toString(): string;
getType(): Stimulsoft.System.Type;
getTypeName(): string;
getNamespace(): string;
getFullTypeName(): string;
static referenceEquals(objA: any, objB: any): boolean;
static addEvent(element: any, eventName: string, fn: Function): void;
static equals(objA: any, objB: any): boolean;
static isNullOrUndefined: (obj: any) => boolean;
static disableAllEnumerable(prototype: any, obj: any): void;
static keys(obj: any): string[];
static getOwnPropertyNames(obj: any): string[];
static getOwnPropertyNamesWithInherited(obj: any, excludeGetSet?: boolean): string[];
getMethods(bindingAttr: BindingFlags): string[];
static saveAs(data: any, fileName: string, type?: string): void;
static mergeDeep(target: any, ...sources: any[]): any;
static stimulsoft: symbol;
static init(): void;
constructor(value: any);
}
class StiNumber extends StiObject implements IAsIs {
value: number;
getHashCode(...args: any[]): number;
is<T>(type: any): this is T;
as(type: any): any;
memberwiseClone(isBase?: boolean): any;
compareTo(value: number): number;
toShort(): number;
toStringFormat(formatString: string): string;
getType(): Stimulsoft.System.Type;
getNetType(): Stimulsoft.System.Type;
getTypeName(): string;
private static _numberRegexp;
static tryParse(value: string, float?: boolean): {
result: number;
successfully: boolean;
};
static getValueOrDefault(value: number): number;
}
class StiString extends StiObject implements IAsIs {
value: string;
is<T>(type: any): this is T;
as(type: any): any;
memberwiseClone(isBase?: boolean): any;
replaceAll(searchValue: string, replaceValue: string, startIndex?: number, count?: number): string;
contains(str: string): boolean;
compareTo(strB: string): number;
isBase64String(): boolean;
remove(startIndex: number, count?: number): string;
insert(startIndex: number, value: string, removeLength?: number): string;
padLeft(totalWidth: number, paddingChar?: string): string;
padRight(totalWidth: number, paddingChar?: string): string;
trimStart(char?: string): string;
trimEnd(char?: string): string;
getHashCode(...args: any[]): number;
toBytesArray(): number[];
toUnicodeString(): string;
fromUnicodeString(): string;
indexOfAny(values: string[]): number;
regexIndexOf(regex: RegExp, startpos: number): number;
regexLastIndexOf(regex: RegExp, startpos: number): number;
split(...separators: string[]): string[];
toLowerFirst(): string;
getType(): Stimulsoft.System.Type;
getTypeName(): string;
getFullTypeName(): string;
toString(): string;
toUpper(): string;
toLower(): string;
static isNullOrEmpty(value: string): boolean;
static isNullOrWhiteSpace(value: string): boolean;
static repeat(value: string, n: number): string;
static fill(value: string, count: number): string;
static format(str: string, ...values: any[]): string;
private static _formatRegexp;
static format1(str: string, values: any[]): string;
static parseFormatString(formatString: string, values: any[]): string;
static customFormat(arg: any, format: string): string;
static indexOfAny(str: string, searchChars: string[]): number;
static join(separator: string, value: string[]): string;
static fromBytesArray(bytes: number[]): string;
}
class StiBoolean extends StiObject implements IAsIs {
is<T>(type: any): this is T;
as(type: any): any;
memberwiseClone(isBase?: boolean): any;
getHashCode(...args: any[]): number;
getType(): Stimulsoft.System.Type;
getTypeName(): string;
getFullTypeName(): string;
compareTo(object: boolean): number;
toNumber(float?: boolean): number;
toString(): string;
static parse(value: string): boolean;
}
class StiArray extends StiObject {
getHashCode(): number;
getType(): Stimulsoft.System.Type;
getTypeName(): string;
getNamespace(): string;
contains(item: any): boolean;
remove<T>(item: T): void;
removeAt(index: number): void;
insert(index: number, item: any): void;
clear(): void;
clone(): any;
addRange(items: any[]): void;
removeRange(index: number, count: number): void;
copyTo(array: any[], index?: number): void;
getKeys(): string[];
getByIndex(index: number, keys: string[]): any;
sort2(comparer: Stimulsoft.System.Collections.IComparer<any>): any[];
getLength(dimension: number): number;
toArray(): any[];
toNumber(float?: boolean): number;
peek(): any;
toList<T>(): Stimulsoft.System.Collections.Generic.List<T>;
subarray<T>(start: number, end: number): T[];
static create<T>(t: Stimulsoft.System.Type, count: number, isStructure?: boolean): T[];
static create2<T>(t: Stimulsoft.System.Type, count1: number, count2: number, isStructure?: boolean): T[][];
static create3<T>(t: Stimulsoft.System.Type, count1: number, count2: number, count3: number, isStructure?: boolean): T[][][];
static create1<T>(t: Stimulsoft.System.Type, ...values: any[]): T[];
static numberSortFunction: () => any;
static copy: (sourceArray: any[], startIndex: number, destinationArray: any[], count: number) => void;
static copy2: (sourceArray: any[], sourceIndex: number, destinationArray: any[], destinationIndex: number, count: number) => void;
static copy3: (sourceArray: any[], destinationArray: any[]) => void;
static reverse: (array: any[]) => any[];
static sort: (array: any[]) => any[];
static sort3(keys: number[], items: any[]): void;
static clear: (array: any[], index: number, length: number) => any[];
static distinct<T>(array: T[]): T[];
static isArray<T>(data: any): data is Array<T>;
constructor(value: any);
}
class StiDate extends StiObject implements IAsIs {
is<T>(type: any): this is T;
as(type: any): any;
}
}
interface Object {
//StiObject;
}
interface String {
//StiString;
}
interface Number {
//StiNumber;
}
interface Boolean {
//StiBoolean;
}
interface Array<T> {
//StiArray;
}
export namespace Stimulsoft.Report {
import Type = Stimulsoft.System.Type;
class List {
static isListType(type: Type): boolean;
get listName(): string;
get listType(): Type;
}
class BoolList extends List {
get listName(): string;
get listType(): Type;
}
class ByteList extends List {
get listName(): string;
get listType(): Type;
}
class CharList extends List {
get listName(): string;
get listType(): Type;
}
class DateTimeList extends List {
get listName(): string;
get listType(): Type;
}
class DecimalList extends List {
get listName(): string;
get listType(): Type;
}
class DoubleList extends List {
get listName(): string;
get listType(): Type;
}
class FloatList extends List {
get listName(): string;
get listType(): Type;
}
class GuidList extends List {
get listName(): string;
get listType(): Type;
}
class IntList extends List {
get listName(): string;
get listType(): Type;
}
class LongList extends List {
get listName(): string;
get listType(): Type;
}
class ShortList extends List {
get listName(): string;
get listType(): Type;
}
class StringList extends List {
get listName(): string;
get listType(): Type;
}
class TimeSpanList extends List {
get listName(): string;
get listType(): Type;
}
}
export namespace Stimulsoft.System {
enum MidpointRounding {
ToEven = 1000,
AwayFromZero = 1001,
ToZero = 1002,
ToNegativeInfinity = 1003,
ToPositiveInfinity = 1004
}
}
interface ObjectConstructor {
saveAs(data: any, fileName: string, type?: string): any;
}
export namespace Stimulsoft.System {
}
export namespace Stimulsoft.Report {
import Type = Stimulsoft.System.Type;
class Range {
static isRangeType(type: Type): boolean;
static isNumericRangeType(type: Type): boolean;
get rangeName(): string;
get rangeType(): Type;
get fromObject(): any;
set fromObject(value: any);
get toObject(): any;
set toObject(value: any);
parse(from: string, to: string): void;
equals(obj: any): boolean;
get fromStrLoc(): string;
get toStrLoc(): string;
toString(): string;
getHashCode(): number;
constructor();
}
class CharRange extends Range {
from: string;
to: string;
get rangeName(): string;
get rangeType(): Stimulsoft.System.Type;
get fromObject(): any;
set fromObject(value: any);
get toObject(): any;
set toObject(value: any);
contains(value: string): boolean;
constructor(from?: string, to?: string);
}
class DateTimeRange extends Range {
from: Stimulsoft.System.NullableDateTime;
to: Stimulsoft.System.NullableDateTime;
get rangeName(): string;
get rangeType(): Stimulsoft.System.Type;
get fromObject(): any;
set fromObject(value: any);
get toObject(): any;
set toObject(value: any);
get fromDate(): Stimulsoft.System.DateTime;
get toDate(): Stimulsoft.System.DateTime;
contains(value: Stimulsoft.System.DateTime): boolean;
toString(): string;
constructor(from?: Stimulsoft.System.DateTime, to?: Stimulsoft.System.DateTime);
}
class TimeSpanRange extends Range {
from: Stimulsoft.System.NullableTimeSpan;
to: Stimulsoft.System.NullableTimeSpan;
get rangeName(): string;
get rangeType(): Stimulsoft.System.Type;
get fromObject(): any;
set fromObject(value: any);
get toObject(): any;
set toObject(value: any);
get fromTime(): Stimulsoft.System.TimeSpan;
get toTime(): Stimulsoft.System.TimeSpan;
contains(value: Stimulsoft.System.TimeSpan): boolean;
toString(): string;
constructor(from?: Stimulsoft.System.TimeSpan, to?: Stimulsoft.System.TimeSpan);
}
class DecimalRange extends Range {
from: number;
to: number;
get rangeName(): string;
get rangeType(): Stimulsoft.System.Type;
get fromObject(): any;
set fromObject(value: any);
get toObject(): any;
set toObject(value: any);
contains(value: number): boolean;
constructor(from?: number, to?: number);
}
class FloatRange extends Range {
from: number;
to: number;
get rangeName(): string;
get rangeType(): Stimulsoft.System.Type;
get fromObject(): any;
set fromObject(value: any);
get toObject(): any;
set toObject(value: any);
contains(value: number): boolean;
constructor(from?: number, to?: number);
}
class DoubleRange extends Range {
from: number;
to: number;
get rangeName(): string;
get rangeType(): Stimulsoft.System.Type;
get fromObject(): any;
set fromObject(value: any);
get toObject(): any;
set toObject(value: any);
contains(value: number): boolean;
constructor(from?: number, to?: number);
}
class ByteRange extends Range {
from: number;
to: number;
get rangeName(): string;
get rangeType(): Stimulsoft.System.Type;
get fromObject(): any;
set fromObject(value: any);
get toObject(): any;
set toObject(value: any);
contains(value: number): boolean;
constructor(from?: number, to?: number);
}
class ShortRange extends Range {
from: number;
to: number;
get rangeName(): string;
get rangeType(): Stimulsoft.System.Type;
get fromObject(): any;
set fromObject(value: any);
get toObject(): any;
set toObject(value: any);
contains(value: number): boolean;
constructor(from?: number, to?: number);
}
class IntRange extends Range {
from: number;
to: number;
get rangeName(): string;
get rangeType(): Stimulsoft.System.Type;
get fromObject(): any;
set fromObject(value: any);
get toObject(): any;
set toObject(value: any);
contains(value: number): boolean;
constructor(from?: number, to?: number);
}
class LongRange extends Range {
from: number;
to: number;
get rangeName(): string;
get rangeType(): Stimulsoft.System.Type;
get fromObject(): any;
set fromObject(value: any);
get toObject(): any;
set toObject(value: any);
contains(value: number): boolean;
constructor(from?: number, to?: number);
}
class GuidRange extends Range {
from: Stimulsoft.System.Guid;
to: Stimulsoft.System.Guid;
get rangeName(): string;
get rangeType(): Stimulsoft.System.Type;
get fromObject(): any;
set fromObject(value: any);
get toObject(): any;
set toObject(value: any);
contains(value: Stimulsoft.System.Guid): boolean;
constructor(from?: Stimulsoft.System.Guid, to?: Stimulsoft.System.Guid);
}
class StringRange extends Range {
from: string;
to: string;
get rangeName(): string;
get rangeType(): Stimulsoft.System.Type;
get fromObject(): any;
set fromObject(value: any);
get toObject(): any;
set toObject(value: any);
contains(value: string): boolean;
constructor(from?: string, to?: string);
}
}
export namespace Stimulsoft.System {
import CultureInfo = Stimulsoft.System.Globalization.CultureInfo;
class ResourceManager {
private resource;
getString(name: string, culture: CultureInfo): string;
}
}
export namespace Stimulsoft.System {
class StiError {
static consoleErrorLog: boolean;
static consoleWarningLog: boolean;
static consoleMessageLog: boolean;
private static lastErrorMessage;
static errorMessageForm: any;
static showError(e: Exception | string, showForm?: boolean, infoForm?: boolean): void;
}
}
export namespace Stimulsoft.System {
import MidpointRounding = Stimulsoft.System.MidpointRounding;
class StiMath {
static readonly E: number;
static readonly PI: number;
private static roundToInt;
static round2(value: number, precision?: number, mode?: MidpointRounding): number;
static abs(value: number): number;
static acos(d: number): number;
static acosh(x: number): number;
static asin(d: number): number;
static asinh(x: number): number;
static atan(d: number): number;
static atanh(x: number): number;
static atan2(y: number, x: number): number;
static ceiling(d: number): number;
static ceil(d: number): number;
static cbrt(x: number): number;
static cos(d: number): number;
static cosh(d: number): number;
static exp(d: number): number;
static floor(d: number): number;
static log(d: number): number;
static log10(d: number): number;
static log2(x: number): number;
static max(a: number, b: number): number;
static min(a: number, b: number): number;
static pow(x: number, y: number): number;
static round(d: number, digits?: number): number;
static sign(x: number): number;
static sin(d: number): number;
static sinh(d: number): number;
static sqrt(d: number): number;
static tan(d: number): number;
static tanh(d: number): number;
static truncate(d: number): number;
static trunc(d: number): number;
}
}
export namespace Stimulsoft.System {
enum StiNavigatorType {
Unknown = 0,
Edge = 1,
MSIE = 2,
Chrome = 3,
Safari = 4,
Mozilla = 5,
Opera = 6
}
class StiNavigator {
private static _type;
static get type(): StiNavigatorType;
static get isIE(): boolean;
}
}
type NumberFormatInfo = Stimulsoft.System.Globalization.NumberFormatInfo;
export namespace Stimulsoft.System.Internals {
function formatNumber(value: number, format: string, info?: NumberFormatInfo): string;
namespace formatNumber {
export function decimalFormat(value: number, precision?: number, info?: NumberFormatInfo): string;
export function hexadecimalFormat(value: number, precision?: number, isUpper?: boolean): string;
export function fixedPointFormat(value: number, precision?: number, info?: NumberFormatInfo): string;
export function currencyFormat(value: number, precision?: number, info?: NumberFormatInfo): string;
export function placeCurrencyValue(value: string, isPositive: boolean, negativeSign: string, currencySymbol: string, patternNumber: number): string;
export function numericFormat(value: number, precision?: number, info?: NumberFormatInfo): string;
export function exponentialFormat(value: number, precision?: number, isUpper?: boolean, info?: NumberFormatInfo, minExpDigits?: number): string;
export function roundTripFormat(value: number, info?: NumberFormatInfo): string;
export function generalFormat(value: number, precision?: number, isUpper?: boolean, info?: NumberFormatInfo): string;
export function percentFormat(value: number, precision?: number, info?: NumberFormatInfo): string;
const SpecifierToken = 1;
const TextToken = 2;
type CustomFormatElement = {
type: (typeof SpecifierToken | typeof TextToken);
token: string;
};
type CustomFormat = {
tokens: CustomFormatElement[];
useGroupSeparators: boolean;
numbersBeforeDot: number;
numbersAfterDot: number;
effectiveNumbersBeforeDot: number;
effectiveNumbersAfterDot: number;
dotIndex: number;
scaling: number;
expIndex: number;
};
export function parseCustomFormatString(format: string): {
tokens: CustomFormatElement[];
useGroupSeparators: boolean;
numbersBeforeDot: number;
numbersAfterDot: number;
effectiveNumbersBeforeDot: number;
effectiveNumbersAfterDot: number;
dotIndex: number;
scaling: number;
expIndex: number;
};
export function normalizeForFormat(value: number, format: CustomFormat, info?: NumberFormatInfo): string[];
export function customFormat(numberParts: string[], format: CustomFormat, info?: NumberFormatInfo): string;
export function trimTrailingZeros(value: string, decimalSeparator: string): string;
export function splitToGroups(intPart: string, groupSeparator?: string, groupSizes?: number[]): string;
export function splitToGroupsArray(intPart: string, groupSizes?: number[]): string[];
export function getFixedPointNumberParts(value: number, precision: number, negativeSign?: string): string[];
export function seemsToBeZero(intPart: string, fraction: string): boolean;
export {};
}
}
export namespace Stimulsoft.System {
class StiPromise<T> {
private _this;
returnValue: T;
private _tryFunctions;
private _finallyFunction;
private _timeout;
private _startTime;
private _callTry;
private _callCatch;
private _callFinaly;
private _callTimeout;
pri