@servicenow/glide 26.0.1 → 27.0.2

package/src/types/GlideAggregate.d.ts

@@ -0,0 +1,162 @@
+import { GlideQueryCondition } from "./GlideQueryCondition";
+
+/**
+ * The scoped GlideAggregate class is an extension of GlideRecord and allows database aggregation (COUNT, SUM, MIN, MAX,
+ * AVG) queries to be done. This can be helpful in creating customized reports or in calculations for calculated fields.
+ * The GlideAggregate class works only on number fields. Since currency fields are strings, you can't use the
+ * GlideAggregate class on currency fields
+ */
+
+export type GlideAggregate<T extends keyof Tables = never> = IGlideAggregate<T>;
+export declare const GlideAggregate: IGlideAggregate;
+
+interface IGlideAggregate<T extends keyof Tables = never> {
+  // Construction and table setup
+  new <T extends keyof Tables>(tableName: T): GlideAggregate<T>;
+
+  // ScopedGlideAggregate
+  _next(): boolean;
+  _query<F extends keyof Tables[T]>(field: F, value: Tables[T][F]): void;
+  addNotNullQuery<F extends keyof Tables[T]>(
+    fieldName: F
+  ): GlideQueryCondition<T>;
+  addNullQuery<F extends keyof Tables[T]>(fieldName: F): GlideQueryCondition<T>;
+  addQuery<F extends keyof Tables[T], V extends keyof Tables[T][F]>(
+    name: F,
+    operator: any,
+    value: V
+  ): GlideQueryCondition<T>;
+  addSystemEncodedQuery(query: string): void;
+  addSystemQuery<F extends keyof Tables[T], V extends keyof Tables[T][F]>(
+    name: F,
+    operator: any,
+    value: V
+  ): GlideQueryCondition<T>;
+  addUserEncodedQuery(query: string): void;
+  addUserQuery<F extends keyof Tables[T], V extends keyof Tables[T][F]>(
+    name: F,
+    operator: any,
+    value: V
+  ): GlideQueryCondition<T>;
+  disableSecurityFeature(feature: string): void;
+  enableSecurityFeature(feature: string): void;
+  /**
+   * Moves to the next record in the GlideAggregate
+   */
+  next(): boolean;
+  hasNext(): boolean;
+  query<F extends keyof Tables[T]>(field: F, value: Tables[T][F]): void;
+
+  // GlideAggregate
+
+  /**
+   * Adds an aggregate
+   */
+  addAggregate(agg: string, name: string): void;
+  addBizCalendarTrend<F extends keyof Tables[T]>(
+    fieldName: F,
+    bizCalendarSysId: string
+  ): void;
+  addBizCalendarTrendBase<F extends keyof Tables[T]>(
+    fieldName: F,
+    bizCalendarSysId: string
+  ): void;
+  addBizCalendarTrendIntersect(
+    anotherCalendarSysId: string,
+    overlapMode: string
+  ): void;
+
+  /**
+   * Adds a query to the aggregate. Adds an encoded query to the other queries that may have been set for this aggregate
+   */
+  addEncodedQuery(query: string, enforceFieldACLs: any): void;
+  getEncodedQuery(): string;
+  addHaving(arg1: string, arg2: string, arg3: string, arg4: string): void;
+  addSystemOrderBy<F extends keyof Tables[T]>(name: F): void;
+
+  /**
+   * Sorts the aggregates into descending order based on the specified field
+   */
+  addSystemOrderByDesc<F extends keyof Tables[T]>(name: F): void;
+  addTrend<F extends keyof Tables[T]>(
+    fieldName: F,
+    timeInterval: string,
+    numUnits: number
+  ): void;
+  addUserOrderBy<F extends keyof Tables[T]>(name: F): void;
+
+  /**
+   * Sorts the aggregates into descending order based on the specified field
+   */
+  addUserOrderByDesc<F extends keyof Tables[T]>(name: F): void;
+  /**
+   * Gets the value of the specified aggregate
+   */
+  getAggregate(agg: string, name: string): string;
+
+  /**
+   * Gets the query necessary to return the current aggregate
+   */
+  getAggregateEncodedQuery(): string;
+  getCount(): number;
+  getQuery(): string;
+  getTotal(agg: string, name: string): number;
+
+  /**
+   * Gets the value of a field
+   */
+  getValue<F extends keyof Tables[T]>(name: F): string;
+
+  /**
+   * Provides the name of a field to use in grouping the aggregates. May be called numerous times to set multiple
+   * group fields
+   */
+  groupBy<F extends keyof Tables[T]>(name: F): void;
+  isBizCalendarTrendFillGap(): boolean;
+
+  /**
+   * Orders the aggregates using the value of the specified field. The field will also be added to the group-by list
+   */
+  orderBy<F extends keyof Tables[T]>(name: F): void;
+
+  /**
+   * Sorts the aggregates based on the specified aggregate and field
+   */
+  orderByAggregate(agg: string, name: string): void;
+
+  /**
+   * Sorts the aggregates into descending order based on the specified field
+   */
+  orderByDesc<F extends keyof Tables[T]>(name: F): void;
+  setAggregateWindow(firstRowWanted: number, lastRowWanted: number): void;
+  setBizCalendarTrendFillGap(b: boolean): void;
+
+  /**
+   * Sets whether the results are to be grouped
+   */
+  setGroup(b: boolean): void;
+  setGroupByFollowRef(b: boolean): void;
+  setIntervalYearIncluded(b: boolean): void;
+  setOrder(b: boolean): void;
+  setOrderByFollowRef(b: boolean): void;
+
+  /**
+   * <p/>
+   * Enables or disables session language join which allows GlideRecord and GlideAggregate
+   * to work with translated fields before a query.
+   * <p/>
+   * <pre>
+   * var ga = new GlideAggregate("cmn_department");
+   * ga.enableSessionLanguageJoin();
+   * ga.addQuery("name", "人力资源");
+   * ga.addAggregate("count", null);
+   * ga.query();
+   * </pre>
+   */
+  enableSessionLanguageJoin(): void;
+
+  // GlideRecord
+  _get<F extends keyof Tables[T]>(name: F, value: Tables[T][F]): boolean;
+  getTableName(): string;
+  getRowCount(): number;
+}

package/src/types/GlideAppCache.d.ts

@@ -0,0 +1,6 @@
+export declare class GlideAppCache {
+  static clear(): void;
+  static get(key: string): any;
+  static put(key: string, value: any): void;
+  static remove(key: string): void;
+}

package/src/types/GlideAppCustomizationPackager.d.ts

@@ -0,0 +1,8 @@
+import { GlideRecord } from "./GlideRecord";
+import { GlideZipOutputStream } from "./GlideZipOutputStream";
+
+export declare class GlideAppCustomizationPackager {
+  constructor(storeAppGr: GlideRecord);
+  packageAppCustomization(): GlideZipOutputStream;
+  packageAppCustomizationV2(): any;
+}

package/src/types/GlideAppInstallValidationHelper.d.ts

@@ -0,0 +1,21 @@
+import { GlideRecord } from "./GlideRecord";
+
+export declare class GlideAppInstallValidationHelper {
+  constructor();
+  getMessage(): string;
+  shouldInstallOrUpgrade(
+    storeApp: GlideRecord,
+    version: string,
+    isReinstall: boolean
+  ): boolean;
+  shouldInstallOrUpgradeCustomization(
+    app: GlideRecord,
+    version: string,
+    isReinstall: boolean
+  ): boolean;
+  shouldInstallOrUpgradeStoreApp(
+    app: GlideRecord,
+    version: string,
+    isReinstall: boolean
+  ): boolean;
+}

package/src/types/GlideAppLoader.d.ts

@@ -0,0 +1,81 @@
+import { GlideRecord } from "./GlideRecord";
+
+export declare class GlideAppLoader {
+  canUninstall(appScope: string, sysCode: string): boolean;
+  constructor();
+  installBatch(jsonPayload: string, isScheduled: boolean): string;
+  installOrUpgradeApp(
+    storeAppId: string,
+    appAttachmentId: string,
+    loadDemoData: boolean,
+    isAppV2Install: boolean,
+    offeringPluginId: string,
+    optionalDependencies: Array<string>,
+    isReinstallRequested: boolean
+  ): boolean;
+  installOrUpgradeAppCustomization(
+    appCustomization: GlideRecord,
+    obtainMutex: boolean,
+    isAppV2Install: boolean,
+    offeringPluginId: string,
+    optionalDependencies: Array<string>
+  ): boolean;
+  installOrUpgradeAppCustomizationAndStoreApp(
+    appCustomization: GlideRecord,
+    storeApp: GlideRecord,
+    obtainMutex: boolean,
+    loadDemoData: boolean,
+    isAppV2Install: boolean,
+    offeringPluginId: string,
+    optionalDependencies: Array<string>
+  ): boolean;
+  installOrUpgradeAppCustomizationAndStoreAppInteractive(
+    appCustomization: GlideRecord,
+    storeApp: GlideRecord,
+    obtainMutex: boolean,
+    loadDemoData: boolean,
+    isAppV2Install: boolean,
+    offeringPluginId: string,
+    optionalDependencies: Array<string>
+  ): boolean;
+  installOrUpgradeAppCustomizationInteractive(
+    appCustomization: GlideRecord,
+    obtainMutex: boolean,
+    isAppV2Install: boolean,
+    offeringPluginId: string,
+    optionalDependencies: Array<string>
+  ): boolean;
+  installOrUpgradeAppWithMutex(
+    storeAppId: string,
+    loadDemoData: boolean,
+    isAppV2Install: boolean,
+    offeringPluginId: string,
+    optionalDependencies: Array<string>,
+    isReinstallRequested: boolean
+  ): boolean;
+  installOrUpgradeAppWithMutexInteractive(
+    storeAppId: string,
+    loadDemoData: boolean,
+    isAppV2Install: boolean,
+    offeringPluginId: string,
+    optionalDependencies: Array<string>,
+    isReinstallRequested: boolean
+  ): boolean;
+  isAllowedAsDependency(pluginId: string): boolean;
+  loadConditionalContent(
+    appScope: string,
+    isFirstTimeActivation: boolean
+  ): void;
+  loadOfflineAppsWithOOB(): void;
+  reapOldLogo(logoRecord: GlideRecord): void;
+  reapOldPackages(storeApp: GlideRecord, newPackageAttachmentId: string): void;
+  reapOldRemoteApp(
+    sourceRemoteApp: GlideRecord,
+    targetStoreApp: GlideRecord
+  ): void;
+  resetAllStoreRequestLimits(): void;
+  setAuthorProperties(properties: Map<string, string>): void;
+  setStoreRequestLimits(storeRequestLimits: Map<string, number>): void;
+  unloadDeleteToXML(gr: GlideRecord): string;
+  unloadRecordToXML(gr: GlideRecord): string;
+}

package/src/types/GlideApplicationProperty.d.ts

@@ -0,0 +1,5 @@
+export declare class GlideApplicationProperty {
+        static getValue(name: string, domainSysId: string): string
+        static setValue(name: string, value: string, domainSysId: string): boolean
+
+}

package/src/types/GlideAvatarFinder.d.ts

@@ -0,0 +1,4 @@
+export declare class GlideAvatarFinder {
+  static getAvatarID(userId: string): string;
+  static getAvatarPath(userId: string): string;
+}

package/src/types/GlideCalendarDateTime.d.ts

@@ -0,0 +1,19 @@
+import { GlideDateTime } from "./GlideDateTime";
+
+export declare class GlideCalendarDateTime extends GlideDateTime {
+  /**
+   * Sets the dateTime value to the UTC value of the initial dateTime value, adjusted from the system timezone.
+   * Uses the fDate to determine if DST is applicable.
+   * does nothing when fDate is null, as there's nothing to adjust.
+   */
+  adjustFromFloatingTzToUTC(): void;
+  /**
+   * Sets the value of this CalendarDateTime object to the specified value.
+   * Enhances the GlideDateTime.setValue method to support both time_zone_field and time_zone_value attributes.
+   * If time_zone_field is present, it's checked if the timezone is empty. If it is, the timezone is treated as 'floating', i.e. derived from system time.
+   * If time_zone_value is present, the value of the attribute is used to set the timezone. This timezone is used to convert the value to UTC.
+   *
+   * @param o The value to set this CalendarDateTime object to.
+   */
+  setValue(o: any): void;
+}

package/src/types/GlideChoice.d.ts

@@ -0,0 +1,18 @@
+export declare class GlideChoice {
+  constructor(value: string, label: string);
+  constructor(value: string, label: string, sysId: string);
+
+  getLabel(): string;
+  getValue(): string;
+  getId(): string;
+  setId(sysId: string): void;
+  getImage(): string;
+  getSelected(): boolean;
+  setLabel(label: string): void;
+  setValue(value: string): void;
+  setImage(image: string): void;
+  setSelected(selected: boolean): void;
+  setParameter(name: string, value: string): void;
+  getParameter(name: string): string;
+  getParameters(): Record<string, string>;
+}

package/src/types/GlideChoiceList.d.ts

@@ -0,0 +1,39 @@
+import { GlideChoice } from "./GlideChoice";
+import { GlideController } from "./GlideController";
+
+export declare class GlideChoiceList {
+  static getChoiceList(tableName: string, fieldName: string): GlideChoiceList;
+  static getChoiceList(
+    tableName: string,
+    fieldName: string,
+    useExtensionTables: boolean
+  ): GlideChoiceList;
+
+  add(sc: GlideChoice): boolean;
+  add(value: string, label: string): GlideChoice;
+  addAll(cl: GlideChoiceList): void;
+  addFirst(value: string, label: string): void;
+  addNone(): GlideChoice;
+  getChoice(index: number): GlideChoice;
+  getChoice(value: string): GlideChoice;
+  getChoiceNoTrim(value: string): GlideChoice;
+  getLabelOf(value: string): string;
+  getNullOverride(gc: GlideController): string;
+  getSelectedIndex(): number;
+  getSize(): number;
+  getValueOf(label: string): string;
+  indexOf(o: any): number;
+  removeChoice(value: string): GlideChoice;
+  removeChoice(index: number): GlideChoice;
+  removeNone(): void;
+  sort(): void;
+  toXML(): string;
+  getChoice(value: string): GlideChoice;
+  getChoiceNoTrim(value: string): GlideChoice;
+  removeChoice(value: string): GlideChoice;
+  removeChoice(index: number): GlideChoice;
+  getLabelOf(value: string): string;
+  getValueOf(label: string): string;
+  getSize(): number;
+  toJSON(): any[];
+}

package/src/types/GlideClientDate.d.ts

@@ -0,0 +1,5 @@
+export declare class GlideClientDate {
+  constructor();
+  getDisplayValue(): string;
+  setValue(o: any): void;
+}

package/src/types/GlideClientExtensionPoint.d.ts

@@ -0,0 +1,4 @@
+export declare class GlideClientExtensionPoint {
+  constructor();
+  getExtensions(name: string): Array<string>;
+}

package/src/types/GlideCodeSigningTracker.d.ts

@@ -0,0 +1,6 @@
+export declare class GlideCodeSigningTracker {
+        trackCallerScript(): void
+        trackRecord(tableName: string, sysId: string): void
+        constructor()
+
+}

package/src/types/GlideContentType.d.ts

@@ -0,0 +1,13 @@
+import { GlideRecord } from "./GlideRecord";
+
+export declare class GlideContentType {
+  /**
+   * Returns the detail page for the given GlideRecord.
+   */
+  getDetailPage(current: GlideRecord): string;
+
+  /**
+   * Returns a GlideContentType instance for the given content GlideRecord.
+   */
+  static get(content: GlideRecord): GlideContentType;
+}

package/src/types/GlideController.d.ts

@@ -0,0 +1,15 @@
+import { GlideElementDescriptor } from "./GlideElementDescriptor";
+import { GlideLRUCache } from "./GlideLRUCache";
+
+export declare class GlideController {
+  constructor();
+
+  static putGlobal(name: string, value: any): void;
+  static getGlobal(name: string): any;
+  static exists(name: string): boolean;
+  static getSandboxGlobal(name: string): any;
+  static getCache(): GlideLRUCache;
+  removeGlobal(name: string): void;
+  evaluateAsObject(expression: string): any;
+  evaluateAsObject(expression: string, ed: GlideElementDescriptor): any;
+}

package/src/types/GlideCounter.d.ts

@@ -0,0 +1,20 @@
+export declare class GlideCounter {
+  constructor();
+  constructor(fullSequence: string);
+  constructor(milliseconds: number);
+
+  static next(name: string): string;
+  static getDate(counter: string): Date;
+  static getSequenceFromDate(dt: string): string;
+
+  format(time: number): string;
+
+  after(c: GlideCounter): boolean;
+  before(c: GlideCounter): boolean;
+  onOrAfter(c: GlideCounter): boolean;
+  onOrBefore(c: GlideCounter): boolean;
+  compareTo(o: any): number;
+  toString(): string;
+  hashCode(): number;
+  equals(o: any): boolean;
+}

package/src/types/GlideCustomTableUtils.d.ts

@@ -0,0 +1,7 @@
+export declare class GlideCustomTableUtils {
+        static getInventoryURI(searchType: string, value: string): string
+        static getUnmappedTableCount(searchType: string, value: string): number
+        static getUnmappedTables(searchType: string, value: string): string[]
+        static isLicensedInstance(): boolean
+
+}

package/src/types/GlideDBFunctionBuilder.d.ts

@@ -0,0 +1,102 @@
+
+
+/**
+ * The Scoped GlideDBFunctionBuilder provides a builder API for creating platform function definition
+ */
+export declare class GlideDBFunctionBuilder {
+
+        /**
+         * Start an addition function
+         */
+        add(): GlideDBFunctionBuilder
+        andFunc(): GlideDBFunctionBuilder
+
+        /**
+         * Return the completed function definition
+         */
+        build(): string
+        caseFunc(): GlideDBFunctionBuilder
+
+        /**
+         * Start a function that will return the first non-null value in a list of values
+         */
+        coalesce(): GlideDBFunctionBuilder
+        compare(): GlideDBFunctionBuilder
+
+        /**
+         * Start a concatenation function
+         */
+        concat(): GlideDBFunctionBuilder
+
+        /**
+         * Add a constant parameter to the current function
+         */
+        constant(constant?: string): GlideDBFunctionBuilder
+
+        /**
+         * Start a function that return the duration between 2 dates
+         */
+        datediff(): GlideDBFunctionBuilder
+
+        /**
+         * Start a function that returns the day of the week of a given date
+         */
+        dayofweek(): GlideDBFunctionBuilder
+
+        /**
+         * Start a division function
+         */
+        divide(): GlideDBFunctionBuilder
+
+        /**
+         * End the current function
+         */
+        endfunc(): GlideDBFunctionBuilder
+
+        /**
+         * Add a field parameter to the current function
+         */
+        field(field?: string): GlideDBFunctionBuilder
+        getLatitude(): GlideDBFunctionBuilder
+        getLongitude(): GlideDBFunctionBuilder
+        greatest(): GlideDBFunctionBuilder
+        jsonValue(): GlideDBFunctionBuilder
+        least(): GlideDBFunctionBuilder
+
+        /**
+         * Start a length function
+         */
+        length(): GlideDBFunctionBuilder
+
+        /**
+         * Start a multiplication function
+         */
+        multiply(): GlideDBFunctionBuilder
+
+        /**
+         * Start a function that returns the current timestamp in the UTC timezone. This function should be used as a
+         * parameter to the datediff function to calculate a duration between the current datetime and...
+         */
+        now(): GlideDBFunctionBuilder
+        orFunc(): GlideDBFunctionBuilder
+
+        /**
+         * Start a function that will return the first occurrence of a substring within a string. Takes optional search
+         * start position as third arg.
+         */
+        position(): GlideDBFunctionBuilder
+
+        /**
+         * Start a function that will return a substring when given a string and an integer position. Optionally a third
+         * length parameter can be included to limit the length of the resulting substring.
+         */
+        substring(): GlideDBFunctionBuilder
+
+        /**
+         * Start a subtraction function
+         */
+        subtract(): GlideDBFunctionBuilder
+        toGeoPoint(): GlideDBFunctionBuilder
+        constructor()
+
+}

package/src/types/GlideDBFunctionCaseBuilder.d.ts

@@ -0,0 +1,12 @@
+import { GlideDBFunctionCaseBuilderThen } from "./GlideDBFunctionCaseBuilderThen";
+
+export declare class GlideDBFunctionCaseBuilder {
+  when(param: string): GlideDBFunctionCaseBuilderThen;
+  whenCompare(
+    left: string,
+    op: string,
+    right: string
+  ): GlideDBFunctionCaseBuilderThen;
+  whenEqual(left: string, right: string): GlideDBFunctionCaseBuilderThen;
+  constructor();
+}

package/src/types/GlideDBFunctionCaseBuilderBuild.d.ts

@@ -0,0 +1,5 @@
+export declare class GlideDBFunctionCaseBuilderBuild {
+        build(): string
+        constructor()
+
+}

package/src/types/GlideDBFunctionCaseBuilderThen.d.ts

@@ -0,0 +1,6 @@
+import { GlideDBFunctionCaseBuilderWhenOtherwiseBuild } from "./GlideDBFunctionCaseBuilderWhenOtherwiseBuild";
+
+export declare class GlideDBFunctionCaseBuilderThen {
+  then(value: string): GlideDBFunctionCaseBuilderWhenOtherwiseBuild;
+  constructor();
+}

package/src/types/GlideDBFunctionCaseBuilderWhenOtherwiseBuild.d.ts

@@ -0,0 +1,15 @@
+import { GlideDBFunctionCaseBuilderBuild } from "./GlideDBFunctionCaseBuilderBuild";
+import { GlideDBFunctionCaseBuilderThen } from "./GlideDBFunctionCaseBuilderThen";
+
+export declare class GlideDBFunctionCaseBuilderWhenOtherwiseBuild {
+  build(): string;
+  otherwise(value: string): GlideDBFunctionCaseBuilderBuild;
+  when(param: string): GlideDBFunctionCaseBuilderThen;
+  whenCompare(
+    left: string,
+    op: string,
+    right: string
+  ): GlideDBFunctionCaseBuilderThen;
+  whenEqual(left: string, right: string): GlideDBFunctionCaseBuilderThen;
+  constructor();
+}

package/src/types/GlideDataBrokerScriptableQueryAPI.d.ts

@@ -0,0 +1,12 @@
+import { NativeObject } from "../imports/NativeObject";
+
+export declare class GlideDataBrokerScriptableQueryAPI {
+  append(queryFragment: string): void;
+  appendAggregateQuery(inputs: NativeObject): void;
+  appendDeleteMutation(inputs: NativeObject): void;
+  appendInsertMutation(inputs: NativeObject): void;
+  appendRecordQuery(inputs: NativeObject): void;
+  appendRecordsQuery(inputs: NativeObject): void;
+  appendUpdateMutation(inputs: NativeObject): void;
+  constructor();
+}

package/src/types/GlideDate.d.ts

@@ -0,0 +1,66 @@
+import { GlideDuration } from "./GlideDuration";
+
+/**
+ * The scoped GlideDate class provides methods for performing operations on GlideDate objects, such as instantiating
+ * GlideDate objects or working with GlideDate fields
+ */
+export declare class GlideDate {
+  constructor();
+  constructor(date: Date);
+  constructor(date: GlideDate);
+  constructor(value: string);
+  constructor(value: string, isDisplayValue: boolean);
+
+  /**
+   * Gets the date in the given date format
+   */
+  getByFormat(format: string): string;
+
+  /**
+   * Returns the day part of a date with no timezone conversion
+   */
+  getDayOfMonthNoTZ(): number;
+  getDisplayValue(): string;
+
+  /**
+   * Gets the display value in the internal format (yyyy-MM-dd). Note: This method is useful for date or time fields,
+   * but not date fields
+   */
+  getDisplayValueInternal(): string;
+  getDisplayValueLang(style: string): string;
+  getDisplayValueLang(style: string, language: string): string;
+
+  /**
+   * Returns the month part of a date with no timezone conversion
+   */
+  getMonthNoTZ(): number;
+
+  /**
+   * Returns the year part of a date with no timezone conversion
+   */
+  getYearNoTZ(): number;
+  static parseDate(date: string, language: string, country: string): GlideDate;
+
+  /**
+   * Sets a date value using the current user's display format and time zone
+   */
+  setDisplayValue(asDisplayed: string): void;
+
+  /**
+   * Gets the date in the current user's display format and time zone
+   */
+  setDisplayValueLang(asDisplayed: string, style: string): void;
+  setDisplayValueLang(
+    asDisplayed: string,
+    style: string,
+    language: string
+  ): void;
+
+  /**
+   * Sets the date of the GlideDate object
+   */
+  setValue(o: any): void;
+
+  static subtract(start: GlideDate, end: GlideDate): GlideDuration;
+  static parseDate(date: string, country: string, language: string): GlideDate;
+}