jsegd-fluig-types 1.0.23 → 1.0.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsegd-fluig-types",
-  "version": "1.0.23",
+  "version": "1.0.25",
   "description": "Definições de tipos TypeScript para desenvolvimento na plataforma Fluig - Inclui APIs, SDK, datasets, workflows e webservices",
   "keywords": [
     "fluig",

package/types/fluig/fluig.dataset.d.ts

@@ -29,20 +29,39 @@ declare global {
     ? SearchConstraintBackend
     : SearchConstraintBase;
 
+  interface DatasetRequest {
+    name: string;
+    fields: string[];
+    constraints: SearchConstraint[];
+    order: string[];
+  }
   interface ErrorDetail {
     code: string;
     message: string;
     type?: "validation" | "business" | "system" | "network" | "auth";
     details?: string;
   }
-  interface DatasetResponse {
+  interface DatasetResponseValues {
     status: number;
     message: string;
     data?: unknown;
     errors?: ErrorDetail[];
-    timestamp?: string;
+    timestamp: java.lang.System.currentTimeMillis;
+  }
+  interface DatasetResponse {
+    response: DatasetResponseValues;
   }
 
+  interface ServiceRequestParams {
+    serviceCode: string;
+    endpoint: string;
+    method?: string;
+    timeoutService?: string | number;
+    options?: Record<string, unknown>;
+    headers?: Record<string, string>;
+    params?: unknown;
+    strParams?: string;
+  }
   interface DatasetWcmResult<T = unknown> {
     columns: string[];
     values: T[];
@@ -93,7 +112,7 @@ declare global {
     // Implementação para retornar um subconjunto dos dados do Dataset, na forma de um novo Dataset
     getSubDataset(
       field: java.lang.String,
-      value: java.lang.Object
+      value: java.lang.Object,
     ): DefaultDataset;
 
     // Implementação para retornar o valor armazenado no Dataset, na linha e coluna passadas por parâmetro
@@ -121,7 +140,7 @@ declare global {
       field: java.lang.String,
       initialValue: java.lang.String,
       finalValue: java.lang.String,
-      type: ConstraintType
+      type: ConstraintType,
     ): SearchConstraint;
     // frontend
     static createConstraint(
@@ -129,7 +148,7 @@ declare global {
       initialValue: string,
       finalValue: string,
       type: ConstraintType,
-      likeSearch?: boolean
+      likeSearch?: boolean,
     ): SearchConstraint;
 
     // backend
@@ -137,7 +156,7 @@ declare global {
       name: java.lang.String,
       fields: java.lang.String[],
       constraints: SearchConstraint[],
-      order: java.lang.String[]
+      order: java.lang.String[],
     ): DefaultDataset;
     // frontend
     static getDataset(
@@ -145,7 +164,7 @@ declare global {
       fields: string[],
       constraints: SearchConstraint[],
       order: string[],
-      callback?: DatasetCallback
+      callback?: DatasetCallback,
     ): DatasetWcmResult<unknown>;
 
     getAvailableDatasets(): java.util.List<java.lang.String>;
@@ -175,7 +194,7 @@ declare global {
   function createDataset(
     fields: string[],
     constraints: SearchConstraint[],
-    sortFields: string[]
+    sortFields: string[],
   ): DefaultDataset;
   function onMobileSync(user: string): void;
 }

package/types/fluig/fluig.sdk.d.ts

@@ -297,7 +297,9 @@ declare global {
           class PageWidgetService {}
           class PostService {}
           class SearchService {}
-          class SecurityService {}
+          class SecurityService {
+            getCurrentTenant(): com.fluig.sdk.tenant.TenantVO;
+          }
           class SocialBreadcrumbService {}
           class SocialSDKService {}
           class TagsCloudService {}
@@ -311,7 +313,11 @@ declare global {
             ): com.fluig.sdk.api.workflow.CancelInstancesResultVO;
           }
         }
-        namespace tenant {}
+        namespace tenant {
+          class TenantVO {
+            getOrganizationUrl(): java.lang.String;
+          }
+        }
         namespace user {}
         namespace web {}
       }

package/types/java/java.d.ts

@@ -1,158 +1,212 @@
 // java.d.ts
 declare global {
-  namespace java {
-    namespace util {
-      interface Collection<T> extends Iterable<T> {
-        size(): number;
-        isEmpty(): boolean;
-        contains(o: T): boolean;
-        add(e: T): boolean;
-        remove(o: T): boolean;
-        clear(): void;
-      }
+    namespace java {
+        namespace util {
+            interface Collection<T> extends Iterable<T> {
+                size(): number
+                isEmpty(): boolean
+                contains(o: T): boolean
+                add(e: T): boolean
+                remove(o: T): boolean
+                clear(): void
+            }
 
-      interface List<T> extends Collection<T> {
-        get(index: number): T;
-        set(index: number, element: T): T;
-        add(e: T): boolean;
-        add(index: number, element: T): void;
-        remove(o: T): boolean; // override from Collection<T>
-        remove(index: number): T; // List-specific
-        indexOf(o: T): number;
-        lastIndexOf(o: T): number;
-      }
+            interface List<T> extends Collection<T> {
+                get(index: number): T
+                set(index: number, element: T): T
+                add(e: T): boolean
+                add(index: number, element: T): void
+                remove(o: T): boolean // override from Collection<T>
+                remove(index: number): T // List-specific
+                indexOf(o: T): number
+                lastIndexOf(o: T): number
+            }
 
-      class ArrayList<T> implements List<T> {
-        constructor();
-        constructor(initialCapacity: number);
-        size(): number;
-        isEmpty(): boolean;
-        contains(o: T): boolean;
-        add(e: T): boolean;
-        add(index: number, element: T): void;
-        get(index: number): T;
-        set(index: number, element: T): T;
-        remove(o: T): boolean;
-        remove(index: number): T;
-        indexOf(o: T): number;
-        lastIndexOf(o: T): number;
-        clear(): void;
-        [Symbol.iterator](): Iterator<T>;
-      }
+            class ArrayList<T> implements List<T> {
+                constructor()
+                constructor(initialCapacity: number)
+                size(): number
+                isEmpty(): boolean
+                contains(o: T): boolean
+                add(e: T): boolean
+                add(index: number, element: T): void
+                get(index: number): T
+                set(index: number, element: T): T
+                remove(o: T): boolean
+                remove(index: number): T
+                indexOf(o: T): number
+                lastIndexOf(o: T): number
+                clear(): void
+                [Symbol.iterator](): Iterator<T>
+            }
 
-      interface Map<K, V> {
-        size(): number;
-        isEmpty(): boolean;
-        containsKey(key: K): boolean;
-        containsValue(value: V): boolean;
-        get(key: K): V | undefined;
-        put(key: K, value: V): V | undefined;
-        remove(key: K): V | undefined;
-        clear(): void;
-        keySet(): Set<K>;
-        values(): Collection<V>;
-        entrySet(): Set<Map.Entry<K, V>>;
-      }
+            interface Map<K, V> {
+                size(): number
+                isEmpty(): boolean
+                containsKey(key: K): boolean
+                containsValue(value: V): boolean
+                get(key: K): V | undefined
+                put(key: K, value: V): V | undefined
+                remove(key: K): V | undefined
+                clear(): void
+                keySet(): Set<K>
+                values(): Collection<V>
+                entrySet(): Set<Map.Entry<K, V>>
+            }
 
-      namespace Map {
-        interface Entry<K, V> {
-          getKey(): K;
-          getValue(): V;
-          setValue(value: V): V;
-        }
-      }
+            namespace Map {
+                interface Entry<K, V> {
+                    getKey(): K
+                    getValue(): V
+                    setValue(value: V): V
+                }
+            }
 
-      class HashMap<K, V> implements Map<K, V> {
-        constructor();
-        size(): number;
-        isEmpty(): boolean;
-        containsKey(key: K): boolean;
-        containsValue(value: V): boolean;
-        get(key: K): V | undefined;
-        put(key: K, value: V): V | undefined;
-        remove(key: K): V | undefined;
-        clear(): void;
-        keySet(): Set<K>;
-        values(): Collection<V>;
-        entrySet(): Set<Map.Entry<K, V>>;
-      }
+            class HashMap<K, V> implements Map<K, V> {
+                constructor()
+                size(): number
+                isEmpty(): boolean
+                containsKey(key: K): boolean
+                containsValue(value: V): boolean
+                get(key: K): V | undefined
+                put(key: K, value: V): V | undefined
+                remove(key: K): V | undefined
+                clear(): void
+                keySet(): Set<K>
+                values(): Collection<V>
+                entrySet(): Set<Map.Entry<K, V>>
+            }
 
-      class Base64 {
-        static getEncoder(): Base64Encoder;
-      }
+            class Base64 {
+                static getEncoder(): Base64Encoder
+            }
 
-      interface Base64Encoder {
-        encodeToString(data: Uint8Array): string;
-      }
-    }
-    namespace lang {
-      class Object {}
-      class String extends java.lang.Object {
-        constructor(arg: string);
-        equals(other: String): boolean;
-      }
-      interface CharSequence {
-        length(): number;
-      }
-      class Number {
-        intValue(): number;
-        doubleValue(): number;
-        longValue(): number;
-      }
-      class Integer extends java.lang.Number {
-        static parseInt(value: java.lang.String): Integer;
-      }
-      class Long extends java.lang.Number {
-        static parseLong(value: java.lang.String): Long;
-      }
-    }
-    namespace sql {
-      class Date {}
-      class Timestamp {}
-      interface ResultSet {
-        next(): boolean;
-        previous(): boolean;
-        getString(col: string): string;
-        getInt(col: string): number;
-        getBoolean(col: string): boolean;
-        getDouble(col: string): number;
-        getDate(col: string): java.sql.Date;
-        getTimestamp(col: string): java.sql.Timestamp;
-        getObject(col: string): java.lang.Object;
-        wasNull(): boolean;
-        getMetaData(): java.sql.ResultSetMetaData;
-        close(): void;
-      }
-      interface Connection {
-        createStatement(): java.sql.Statement;
-        close(): void;
-      }
+            interface Base64Encoder {
+                encodeToString(data: Uint8Array): string
+            }
+        }
+        namespace lang {
+            class Object {}
+            class String extends java.lang.Object {
+                constructor(arg: string)
+                equals(other: String): boolean
+                contains(substring: String): boolean
+            }
+            interface CharSequence {
+                length(): number
+            }
+            class Number {
+                intValue(): number
+                doubleValue(): number
+                longValue(): number
+            }
+            class Integer extends java.lang.Number {
+                static parseInt(value: java.lang.String): Integer
+            }
+            class Long extends java.lang.Number {
+                static parseLong(value: java.lang.String): Long
+            }
+            class System {
+                static currentTimeMillis(): number
+            }
+            class Boolean extends java.lang.Object {
+                constructor(value: boolean)
+                constructor(value: java.lang.String)
+                static parseBoolean(value: java.lang.String): boolean
+                booleanValue(): boolean
+            }
+            class Throwable extends java.lang.Object {
+                constructor(message: java.lang.String)
+                getMessage(): java.lang.String
+            }
+        }
+        namespace sql {
+            class Date {
+                constructor(date: number)
+                static valueOf(s: java.lang.String): java.sql.Date
+            }
+            class Time {
+                constructor(time: number)
+                static valueOf(s: java.lang.String): java.sql.Time
+            }
+            class Timestamp {
+                constructor(date: number)
+                static valueOf(s: java.lang.String): java.sql.Timestamp
+            }
+            interface ResultSet {
+                next(): boolean
+                previous(): boolean
+                getString(col: string): string
+                getInt(col: string): number
+                getBoolean(col: string): boolean
+                getDouble(col: string): number
+                getDate(col: string): java.sql.Date
+                getTimestamp(col: string): java.sql.Timestamp
+                getObject(col: string): java.lang.Object
+                wasNull(): boolean
+                getMetaData(): java.sql.ResultSetMetaData
+                close(): void
+            }
+            interface Connection {
+                createStatement(): java.sql.Statement
+                close(): void
+                prepareStatement(sql: java.lang.String): java.sql.PreparedStatement
+                prepareStatement(sql: java.lang.String, autoGeneratedKeys: number): java.sql.PreparedStatement
+                prepareStatement(sql: java.lang.String, columnIndexes: number[]): java.sql.PreparedStatement
+                prepareStatement(sql: java.lang.String, resultSetType: number, resultSetConcurrency: number): java.sql.PreparedStatement
+                prepareStatement(
+                    sql: java.lang.String,
+                    resultSetType: number,
+                    resultSetConcurrency: number,
+                    resultSetHoldability: number
+                ): java.sql.PreparedStatement
+                prepareStatement(sql: java.lang.String, columnNames: java.lang.String[]): java.sql.PreparedStatement
+            }
 
-      interface Statement {
-        executeQuery(query: string): java.sql.ResultSet;
-        close(): void;
-      }
-      interface ResultSetMetaData {
-        getColumnCount(): number;
-        getColumnName(column: number): java.lang.String;
-        getColumnTypeName(column: number): java.lang.String;
-      }
+            interface Statement {
+                executeQuery(query: string): java.sql.ResultSet
+                close(): void
+            }
+            interface ResultSetMetaData {
+                getColumnCount(): number
+                getColumnName(column: number): java.lang.String
+                getColumnTypeName(column: number): java.lang.String
+                getColumnType(column: number): number
+                getColumnLabel(column: number): java.lang.String
+            }
+            interface PreparedStatement extends Statement {
+                setString(parameterIndex: number, value: java.lang.String): void
+                setInt(parameterIndex: number, value: number): void
+                setBoolean(parameterIndex: number, value: boolean): void
+                setBigDecimal(parameterIndex: number, value: java.math.BigDecimal): void
+                setDouble(parameterIndex: number, value: number): void
+                setDate(parameterIndex: number, value: java.sql.Date): void
+                setTimestamp(parameterIndex: number, value: java.sql.Timestamp): void
+                setObject(parameterIndex: number, value: java.lang.Object): void
+                executeQuery(): java.sql.ResultSet
+                executeUpdate(): number
+            }
+        }
+        namespace math {
+            class BigDecimal {
+                constructor(value: java.lang.String)
+            }
+        }
     }
-  }
 
-  namespace javax {
-    namespace naming {
-      class InitialContext {
-        constructor();
-        lookup(dataSource: java.lang.String): java.lang.Object;
-      }
-    }
-    namespace sql {
-      interface DataSource {
-        getConnection(): java.sql.Connection;
-      }
+    namespace javax {
+        namespace naming {
+            class InitialContext {
+                constructor()
+                lookup(dataSource: java.lang.String): java.lang.Object<java.sql.DataSource>
+            }
+        }
+        namespace sql {
+            interface DataSource {
+                getConnection(): java.sql.Connection
+            }
+        }
     }
-  }
 }
 
-export {};
+export {}