jsegd-fluig-types 1.0.0

package/fluig.sdk.d.ts

@@ -0,0 +1,142 @@
+declare global {
+    declare namespace com {
+        namespace fluig {
+            namespace sdk {
+                namespace api {
+                    class FluigAPI {
+                        constructor(): FluigAPI
+                        getArticleService(): ArticleService
+                        getAuthorizeClientService(): AuthorizeClientSdkService
+                        getCardAPIService(): CardAPIService
+                        getCardIndexAPIService(): CardIndexAPIService
+                        getCardIndexService(): CardIndexService
+                        getCardService(): CardService
+                        getCollaborationService(): CollaborationSDKService
+                        getCommentService(): CommentService
+                        getCommunityService(): CommunityService
+                        getContentFilesService(): ContentFilesService
+                        getDocumentService(): DocumentService
+                        getFavoritesService(): FavoritesService
+                        getFilterService(): FilterAPIService
+                        getFolderDocumentService(): FolderDocumentService
+                        getGlobalParameterService(): GlobalParameterService
+                        getGroupService(): GroupService
+                        getHelpService(): DocumentationProxyServiceService
+                        getHolidayService(): HolidayAPIService
+                        getI18NService(): I18NService
+                        getIdentityService(): IdentityService
+                        getJobService(): JobService
+                        getLocalService(): LocalAPIService
+                        getPageService(): PageService
+                        getPageWidgetService(): PageWidgetService
+                        getPostService(): PostService
+                        getSearchService(): SearchService
+                        getSecurityService(): SecurityService
+                        getSocialBreadcrumbService(): SocialBreadcrumbService
+                        getSocialService(): SocialSDKService
+                        getTagsCloudService(): TagsCloudService
+                        getTasksService(): TasksService
+                        getTenantService(): TenantService
+                        getUserService(): UserService
+                        getWidgetService(): WidgetService
+                        getWorkflowService(): WorkflowAPIService
+                    }
+                    namespace workflow {
+                        class CancelInstancesVO {
+                            constructor(): CancelInstancesVO
+                            getCancelInstanceList(): java.util.List<CancelInstanceVO>
+                            getCancelText(): java.lang.String
+                            setCancelInstanceList(cancelInstanceList: java.util.List<CancelInstanceVO>): void
+                            setCancelText(cancelText: string): void
+                        }
+                        class CancelInstanceVO {
+                            constructor(): CancelInstanceVO
+                            getCancelText(): java.lang.String
+                            getProcessInstanceId(): number
+                            getReplacedId(): java.lang.String
+                            setCancelText(cancelText: string): void
+                            setProcessInstanceId(processInstanceId: number): void
+                            setReplacedId(replacedId: string): void
+                        }
+                        class CancelInstancesResultVO {
+                            getCancelInstanceResults(): java.util.List<CancelInstanceResultVO>
+                            getFailCount(): number
+                            getSuccessCount(): number
+                            setCancelInstanceResults(cancelInstanceResults: java.util.List<CancelInstanceResultVO>): void
+                            setFailCount(failCount: number): void
+                            setSuccessCount(successCount: number): void
+                        }
+
+                        class CancelInstanceResultVO {
+                            getErrorCode(): string
+                            getMessage(): string
+                            getProcessInstanceId(): number
+                            getStatus(): java.lang.String
+                            getTenantId(): number
+                            setErrorCode(errorCode: string): void
+                            setMessage(message: java.lang.String): void
+                            setProcessInstanceId(processInstanceId: number): void
+                            setStatus(status: java.lang.String): void
+                            setTenantId(tenantId: number): void
+                        }
+                    }
+                }
+                namespace service {
+                    class WorkflowAPIService {
+                        cancelInstances(instances: CancelInstancesVO): CancelInstancesResultVO
+                    }
+                    class AuthorizeClientSdkServiceVO {
+                        constructor(companyId: number, serviceCode: string, description: string, method: string)
+                        constructor(
+                            companyId: number,
+                            serviceCode: string,
+                            endpoint: string,
+                            method: string,
+                            timeoutService: string,
+                            params: Map<string, java.lang.Object>
+                        )
+                        constructor(serviceCode: string, endpoint: string, method: string, params: Map<string, java.lang.Object>, result: string)
+                        equals(obj: object): boolean
+                        getCompanyId(): java.lang.Long
+                        getDescription(): java.lang.String
+                        getEndpoint(): java.lang.String
+                        getHeaders(): java.util.Map<java.lang.String, java.lang.String>
+                        getHttpStatusResult(): number
+                        getMethod(): java.lang.String
+                        getOptions(): java.util.Map<java.lang.String, java.lang.Object>
+                        getParams(): Map<java.lang.String, java.lang.Object>
+                        getResult(): java.lang.String
+                        getServiceCode(): java.lang.String
+                        getStrParams(): java.lang.String
+                        getTimeoutService(): java.lang.String
+                        hashCode(): int
+                        setCompanyId(companyId: number): void
+                        setDescription(description: string): void
+                        setEndpoint(endpoint: string): void
+                        setHeaders(headers: Map<java.lang.String, java.lang.String>): void
+                        setHttpStatusResult(httpStatusResult: number): void
+                        setMethod(method: string): void
+                        setOptions(options: Map<java.lang.String, java.lang.Object>): void
+                        setParams(params: Map<java.lang.String, java.lang.Object>): void
+                        setResult(result: string): void
+                        setServiceCode(serviceCode: string): void
+                        setStrParams(strParams: string): void
+                        setTimeoutService(timeoutService: string): void
+                        toString(): java.lang.String
+                    }
+                    class AuthorizeClientSdkService {
+                        constructor()
+                        create(vo: OAuthSdkVO): OAuthSdkVO
+                        invoke(vo: AuthorizeClientSdkServiceVO): AuthorizeClientSdkServiceVO
+                        invoke(data: java.lang.String): AuthorizeClientSdkServiceVO
+                        invokeService(data: java.lang.String): AuthorizeClientSdkServiceVO
+                    }
+                    class DocumentService {
+                        getDocumentContentAsBytes(documentId: java.lang.Integer): number[]
+                    }
+                }
+            }
+        }
+    }
+}
+export {}

package/index.d.ts

@@ -0,0 +1,3 @@
+export * from './fluig.sdk.d';
+export * from './java.d';
+export * from './types.d';

package/java.d.ts

@@ -0,0 +1,136 @@
+// java.d.ts
+declare global {
+    declare 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(index: number, element: T): void
+                remove(index: number): T
+                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>
+            }
+
+            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
+                }
+            }
+
+            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 {
+                    return {
+                        encodeToString(data: Uint8Array): string {
+                            return Buffer.from(data).toString('base64')
+                        },
+                    }
+                }
+            }
+
+            interface Base64Encoder {
+                encodeToString(data: Uint8Array): string
+            }
+        }
+        namespace lang {
+            class Object {}
+            class String extends java.lang.Object {
+                constructor(arg: string): java.lang.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
+            }
+        }
+        namespace sql {
+            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
+            }
+        }
+    }
+
+    declare namespace javax {
+        namespace naming {
+            class InitialContext {
+                constructor()
+                lookup(dataSource: java.lang.String): java.lang.Object
+            }
+        }
+    }
+}
+
+export {}

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "jsegd-fluig-types",
+  "version": "1.0.0",
+  "description": "Pacote de tipos para fluig",
+  "license": "CC-BY-NC-ND-4.0",
+  "author": "Elemar Deckmann",
+  "homepage": "https://www.egd.tec.br/",
+  "types": "index.d.ts",
+  "files": [
+    "index.d.ts",
+    "fluig.sdk.d.ts",
+    "java.d.ts",
+    "types.d.ts"
+  ]
+}

package/types.d.ts

@@ -0,0 +1,662 @@
+// types.d.ts
+// =============================
+// ENUMS
+// =============================
+
+declare enum FormMod {
+    'ADD' = 'ADD',
+    'MOD' = 'MOD',
+    'VIEW' = 'VIEW',
+    'NONE' = 'NONE',
+}
+
+declare enum AutocompleteTypes {
+    tag = 'tag',
+    autocomplete = 'autocomplete',
+    tagAutocomplete = 'tagAutocomplete',
+}
+
+declare enum AutocompleteEvents {
+    cursorchanged = 'fluig.autocomplete.cursorchanged',
+    opened = 'fluig.autocomplete.opened',
+    closed = 'fluig.autocomplete.closed',
+    selected = 'fluig.autocomplete.selected',
+    autocompleted = 'fluig.autocomplete.autocompleted',
+    beforeItemAdd = 'fluig.autocomplete.beforeItemAdd',
+    itemAdded = 'fluig.autocomplete.itemAdded',
+    beforeItemUpdate = 'fluig.autocomplete.beforeItemUpdate',
+    itemUpdated = 'fluig.autocomplete.itemUpdated',
+    beforeItemRemove = 'fluig.autocomplete.beforeItemRemove',
+    itemRemoved = 'fluig.autocomplete.itemRemoved',
+}
+// Adicionar eventos conforme necessário
+
+// =============================
+// TIPOS DE DOMÍNIO - APROVADORES
+// =============================
+
+export type Aprovador = {
+    centro_custo: string
+    aprovador: string
+    email: string
+    nome_aprovador: string
+    nivel: number
+}
+
+export type CentroDeCusto = {
+    centro_custo: string
+    valor: number
+    parcelas: number
+    unitario: number
+}
+
+export type AlcadaRequest = {
+    alcada: CentroDeCusto[]
+}
+
+export type Alcada = {
+    centro_custo: string
+    aprovador: string
+    login: string
+    email: string
+    nome_aprovador: string
+    nivel: number
+    valor: number
+    valor_total: number
+    parcelas: number
+}
+
+export type Falha = {
+    mensagem: string
+    valor: number
+    centro_custo: string
+}
+
+export type Falhas = {
+    erros: Falha[]
+}
+
+// =============================
+// INTERFACES DE COMPONENTES UI
+// =============================
+
+interface Toast {
+    title?: string
+    message: string
+    type?: 'success' | 'warning' | 'danger' | 'info'
+    timeout?: number
+}
+
+interface ConfirmSettings {
+    title: string
+    message: string
+    labelYes?: string
+    labelNo?: string
+}
+
+interface AlertSettings {
+    title: string
+    message: string
+    label?: string
+}
+
+interface ErrorSettings {
+    title: string
+    message: string
+    details: string
+}
+
+interface ModalSettings {
+    title: string
+    content: string | Widget
+    id: string
+    showHeader: boolean
+    showFooter: boolean
+    actions: object[]
+    headerActions: unknown[]
+    headerContent: string
+    size: string
+    formModal: boolean
+}
+
+interface Widget {
+    widgetCode: string
+    ftl: string
+    data: {
+        sociableId: string
+        listType: string
+        customInstance: string
+    }
+}
+
+// =============================
+// INTERFACES DE AUTOCOMPLETE
+// =============================
+
+interface AutocompleteOptions<T> {
+    type: AutocompleteTypes
+    displayKey: string
+    templates: string
+    source: T[] | (() => T[])
+    searchTimeout: string
+    highlight: string
+    minLength: string
+    hint: string
+    tagClass: string
+    maxTags: string
+    allowDuplicates: string
+    onTagExists: string
+    onMaxTags: string
+    name: string
+    tagRemoveCss: string
+    tagMaxWidth: string
+    autoLoading?: boolean
+}
+
+// =============================
+// INTERFACES DE DATATABLE
+// =============================
+
+interface HeaderDatatable {
+    title: string
+    dataorder?: string
+    standard?: boolean
+    size?: string
+    display?: boolean
+}
+
+interface DataRequest<T> {
+    [key: string]: T
+}
+
+interface DatatableOptions<T> {
+    dataRequest: DataRequest<T>[] | object
+    renderContent: string | string[]
+    header: HeaderDatatable[]
+    multiSelect: boolean
+    classSelected: string
+    search: object
+    scroll: object
+    actions: {
+        enabled: boolean
+        template: string
+        actionAreaStyle: string
+    }
+    emptyMessage: string
+    navButtons: object
+    tableStyle: string
+    draggable: {
+        enabled: boolean
+        onDrag: () => void
+    }
+}
+
+// =============================
+// TIPOS DE CALLBACK
+// =============================
+
+declare type ConfirmCallback = (result: boolean, element: HTMLElement, event: Event) => void
+declare type MessageCallback = (element: HTMLElement, event: Event) => void
+
+// =============================
+// DECLARAÇÃO GLOBAL DE FUNÇÕES
+// =============================
+
+declare global {
+    // =============================
+    // INTERFACE WINDOW ESTENDIDA
+    // =============================
+
+    interface Window {
+        $: unknown
+        FLUIGC: {
+            popover(arg0: string, arg1: { trigger: string; placement: string }): unknown
+            message: message
+            toast: (options: Toast) => void
+            loading: (target: unknown, options?: object) => Loading
+            modal: (option: ModalSettings, callback: (err: unknown, data: object) => void) => Modal
+            datatable: <T>(target: string, options: DatatableOptions<T>) => Datatable
+            autocomplete<T>(target: string | HTMLElement, options: object, callback?: (error: unknown, data: object) => void): Autocomplete<T>
+        }
+        ECM: {
+            workflowView: {
+                availableStates: any
+                forecastedEffortType: number
+                appointments: any
+                adHocTask: boolean
+                processDefinition: {
+                    processInstanceId: number
+                }
+                sequence: number
+            }
+            attachmentTable: {
+                getData(): { [key: string]: string }[]
+            }
+        }
+        WCMAPI: WCMAPI
+        WKFViewAttachment: WKFViewAttachment
+        formMode: FormMod
+        ECM_WKFView: {
+            load: any
+            validateBeforeSend(arg0: null, arg1: null, isAutomatic: boolean, pass: string, isTransfer: boolean): unknown
+            enableActionButtons(): unknown
+            enableSendButton(): unknown
+            getSelectedColleagues(): unknown
+            getFormData(): unknown
+            lastSelectedState: null
+            conditionsAutomatic: any
+            hideModals(): unknown
+            createUserSelectionModal(): unknown
+            createAdHoc(): unknown
+            movimentActivity(
+                arg0: boolean,
+                formData: any,
+                selectedColleague: any,
+                selectedState: any,
+                arg4: boolean,
+                isAutomatic: boolean,
+                arg6: null,
+                isReturn: any,
+                passValue: string | number | string[],
+                subProcessId: string,
+                subProcessSequence: string,
+                arg11: boolean,
+                isTransfer: boolean
+            ): unknown
+            sendRequest: (isAutomatic: boolean, isTransfer: boolean, pass: string) => void
+        }
+    }
+    /**
+     * Função principal para criação de datasets no Fluig
+     * Cada arquivo de dataset deve implementar esta função
+     */
+    function createDataset(fields: string[], constraints: Constraint[], sortFields: string[]): Dataset
+
+    // Funções globais do Fluig
+    function wdkAddChild(tablename: string): number
+    function fnWdkRemoveChild(element: Element): void
+    function getValue(element: string): string
+
+    // Variável global definida pelo Fluig no navegador
+    const formMode: FormMod
+
+    // Namespace hAPI
+    namespace hAPI {
+        function getCardValue(nomeCampo: string): string
+        function setCardValue(nomeCampo: string, valor: string): string
+        function addCardChild(tableName: string, cardData: java.util.HashMap<java.lang.String, java.lang.String>): void
+        function removeCardChild(tableName: string, index: number): void
+        function setAutomaticDecision(taskNumber: number, responsible: java.util.ArrayList<string>, comment: string): void
+        function getActiveStates(): java.util.ArrayList<object>
+        function getParentInstance(processInstanceId: number): number
+        function getChildrenInstances(processInstanceId: number): java.util.List<number>
+        function setDueDate(processId: number, numThread: number, userId: string, dueDate: Date, timeInSeconds: number): void
+        function transferTask(users: java.util.ArrayList<string>, comment: string, numThread?: number): void
+        function setTaskComments(userId: string, processId: number, threadId: number, comment: string): void
+        function getAdvancedProperty(nomePropriedade: string): string
+        function getCardData(numProcesso: number): java.util.HashMap<string, string>
+        function startProcess(
+            processId: string,
+            taskNumber: number,
+            users: java.util.ArrayList<java.lang.String>,
+            comment?: string,
+            taskFinished?: boolean,
+            form?: java.util.HashMap<java.lang.String, java.lang.String>,
+            managerMode?: boolean
+        ): java.util.HashMap<string, string>
+        function calculateDeadLineHours(deadlineDate: Date, seconds: number, deadlineInHours: number, periodId: string): unknown
+        function calculateDeadLineTime(deadlineDate: Date, seconds: number, deadlineInHours: number, periodId: string): unknown
+        function setColleagueReplacement(responsible: string): void
+        function getUserTaskLink(numAtividade: number): string
+        function getActualThread(companyNumber: number, processNumber: number, activityNumber: number): number
+        function createAdHocTasks(processoId: number, sequenciaId: number, assunto: string, detalhamento: string, tarefas: unknown[]): void
+        function listAttachments(): java.util.List<unknown>
+        function publishWorkflowAttachment(documentDto: unknown): void
+        function attachDocument(documentId: number): void
+        function getChildrenFromTable(tableName: string): java.util.HashMap<string, string>
+        function getChildrenIndexes(tableName: string): number[]
+        function getAvailableStatesDetail(
+            companyId: number,
+            userId: string,
+            processId: number,
+            processInstanceId: number,
+            threadSequenceId?: number
+        ): unknown
+    }
+
+    declare class log {
+        static dir(object: object): void
+        static info(message: string): void
+        static error(message: string): void
+    }
+
+    declare class DatasetFactory {
+        static getAvailableDatasets(): string[]
+        static createConstraint(fieldName: string, initialValue: string, finalValue: string, constraintType: ConstraintType): Constraint
+        static createConstraint(
+            fieldName: string,
+            initialValue: string,
+            finalValue: string,
+            constraintType: ConstraintType,
+            searchLike: boolean
+        ): Constraint
+        static getDataset(
+            nomeDataset: string,
+            campos: string[] | null,
+            constraints: Constraint[] | null,
+            ordem: string[] | null
+        ): Dataset | DatasetWcmResult
+    }
+
+    declare class JSONUtil {
+        static toJSON(data: object): string
+    }
+
+    declare enum ConstraintType {
+        MUST = 1,
+        SHOULD = 2,
+        MUST_NOT = 3,
+    }
+
+    // Adicione as declarações de tipos para Dataset e Constraint se não estiverem disponíveis globalmente
+    declare type Dataset = {
+        rowsCount: number
+        updateRow(valores: string[] | object[]): void
+        addOrUpdateRow(valores: string[] | object[]): void
+        deleteRow(valores: string[] | object[]): void
+        addColumn(): void
+        addRow(): void
+        getColumnName(): java.lang.String
+        getColumnsName(): java.lang.String[]
+        getColumnsCount(): number
+        getMap(): java.util.ArrayList<java.util.HashMap<java.lang.String, java.lang.Object>>
+        getRowsCount(): number
+        getSubDataset(): Dataset
+        getValue(row: number, col: number): string
+        getValue(row: number, colName: string): string
+        getValues(): java.lang.Object[][]
+        toResultSet(): java.sql.ResultSet
+        addColumn(name: string): void
+        addRow(row: unknown[]): void
+        getValue(row: number, column: string): string
+    }
+
+    // =============================
+    // CLASSES DE DATASET
+    // =============================
+
+    interface DatasetRequest {
+        serviceParams: string
+        serviceCode: string
+        endpoint: string
+        method: HttpMethod
+        options?: Record<string, string>
+        headers?: Record<string, string>
+    }
+
+    declare class DatasetBuilder {
+        static newDataset(): Dataset
+    }
+
+    declare class Constraint {
+        fieldName: string
+        initialValue: string
+        finalValue: string
+        constraintType: ConstraintType
+        setLikeSearch(likeSearch: boolean): void
+        getFieldName(): string
+        getInitialValue(): string
+        getFinalValue(): string
+    }
+
+    declare class SearchConstraint {}
+
+    declare class DatasetWcmCallback {
+        success: (result: DatasetWcmResult) => unknown
+        error: (error: object, message: string, details: string) => void
+    }
+
+    interface DataCallback {
+        selectedRows(): number[]
+        selectedIndex: number[]
+    }
+    declare class Datatable {
+        reload<T>(data: DataRequest<T>): void
+        on(event: string, callback: (data: DataCallback) => void): void
+        getRow(index: number, isHtml: boolean): unknown
+        showLoading(): void
+        hideLoading(): void
+    }
+
+    // =============================
+    // CLASSES DO FLUIG
+    // =============================
+
+    declare class FLUIGC {
+        static popover(
+            arg0: string,
+            arg1: {
+                trigger: string
+                placement: string
+                template?: string
+                container?: string | boolean
+                maxheight?: string
+                content?: string
+                html?: boolean
+            }
+        ): void
+        static message: message
+        static toast: (options: Toast) => void
+        static loading: (option: unknown) => Loading
+        static modal: (option: ModalSettings, callback: (err: unknown, data: object) => void) => Modal
+        static datatable: <T>(target: string, options: DatatableOptions<T>) => Datatable
+        static autocomplete<T>(target: string | HTMLElement, options: object, callback?: (error: unknown, data: object) => void): Autocomplete<T>
+        static switcher: {
+            onInitSendScope(element: any, scope: any, arg2: (element: any, event: any, scope: any) => void): unknown
+            enable(arg0: string): unknown
+            disable(arg0: string): unknown
+            setFalse(arg0: string): unknown
+            setTrue(arg0: string): unknown
+            onInit(arg0: string, arg1: (event: any) => void): unknown
+            onChange(element: any, arg1: (event: any, state: any) => void): unknown
+            init: (
+                selector: string,
+                options?: {
+                    state?: boolean
+                    size?: 'mini' | 'small' | 'normal' | 'large'
+                    animate?: boolean
+                    disabled?: boolean
+                    readonly?: boolean
+                    onColor?: 'primary' | 'info' | 'success' | 'warning' | 'danger' | 'default'
+                    offColor?: 'primary' | 'info' | 'success' | 'warning' | 'danger' | 'default'
+                    onText?: string
+                    offText?: string
+                }
+            ) => void
+        }
+    }
+
+    declare class Loading {
+        setMessage(message: string): void
+        show(): void
+        hide(): void
+    }
+
+    declare class Modal {
+        remove(): void
+        isOpen(): boolean
+    }
+
+    declare class Autocomplete<T> {
+        val(value: string): void
+        val(): string
+        on(event: AutocompleteEvents, callback: (event: unknown) => void): void
+        items(): T[]
+    }
+
+    declare class Datatable {
+        reload<T>(data: DataRequest<T>): void
+        on(event: string, callback: (data: DataCallback) => void): void
+        getRow(index: number, isHtml: boolean): unknown
+        showLoading(): void
+        hideLoading(): void
+    }
+
+    declare class message {
+        confirm(settings: ConfirmSettings, callback: ConfirmCallback): void
+        static alert(settings: AlertSettings, callback: MessageCallback): void
+        static error(settings: ErrorSettings, callback: MessageCallback): void
+    }
+
+    // =============================
+    // CLASSES DE WORKFLOW
+    // =============================
+
+    declare class WKFViewAttachment {
+        removeAttach(indexes: number[]): void
+        getAllAttachments(): Attachment[]
+        openAttachmentView(colleagueId: string, docId: number, docVersion: number): void
+        confirmRemoveAttach(index: number[]): void
+        checkAllAttachments(): void
+        desmarkAllCheckbox(): void
+        selectedRowOpenAttachmentView(): void
+    }
+
+    declare class Attachment {
+        id: number
+        fullPath: string
+        droppedZipZone: boolean
+        name: string
+        internalId: number
+        newAttach: boolean
+        description: string
+        documentId: number
+        attachedUser: string
+        attachedActivity: string
+        attachments: Array<{
+            attach: boolean
+            principal: boolean
+            fileName: string
+        }>
+        hasOwnSubMenu: boolean
+        enablePublish: boolean
+        enableEdit: boolean
+        enableEditContent: boolean
+        fromUpload: boolean
+        enableDownload: boolean
+        hasMoreOptions: boolean
+        deleted: boolean
+        iconClass: string
+        iconUrl: boolean
+        colleagueId: string
+        version: number
+        attachedDate: string
+    }
+
+    // =============================
+    // CLASSES DE FORMULÁRIO
+    // =============================
+
+    declare class FormController {
+        getCompanyId(): number
+        getDocumentId(): number
+        getVersion(): number
+        getCardIndex(): number
+        setEnabled(nomeCampo: string, habilita: boolean, protegido: boolean): void
+        getEnabled(nomeCampo: string): boolean
+        setValue(nomeCampo: string, valor: string): void
+        getValue(nomeCampo: string): string
+        setVisible(nomeCampo: string, visible: boolean): void
+        setVisibleById(idDoCampo: string, visible: boolean): void
+        setShowDisabledFields(habilita: boolean): void
+        setHidePrintLink(habilita: boolean): void
+        setHideDeleteButton(habilita: boolean): void
+        setEnhancedSecurityHiddenInputs(proteger: boolean): void
+        getFormMode(): FormMod
+        isHidePrintLink(): boolean
+        getChildrenFromTable(tableName: string): object
+        getChildrenIndexes(tableName: string): number[]
+        isHideDeleteButton(): boolean
+        getMobile(): boolean
+        isVisible(nomeCampo: string): boolean
+        isVisibleById(id: string): boolean
+    }
+
+    declare class customHTML {
+        append(html: string): void
+    }
+
+    // =============================
+    // CLASSES DE API
+    // =============================
+
+    declare class WCMAPI {
+        getServerURL(): string
+        userCode: string
+        tenantURL: string
+        convertFtlAsync(): string
+        generateId(): string
+        userEmail: string
+        userLogin: string
+        user: string
+    }
+
+    declare class ServiceManager {
+        static getServiceInstance(service: string): unknown
+    }
+
+    declare class JSInterface {
+        static showCamera(param: string): void
+    }
+
+    declare class loading {
+        static setMessage(message: string): void
+        static setVisible(visible: boolean): void
+    }
+
+    interface DatasetWcmResult<T = unknown> {
+        columns: string[]
+        values: T[]
+    }
+
+    interface ServiceRequestOptions {
+        companyId: string
+        serviceCode: string
+        endpoint: string
+        timeoutService?: number
+        method: HttpMethod
+        params: string
+        options?: Record<string, string> | undefined
+        headers?: Record<string, string> | undefined
+    }
+
+    interface ErrorDetail {
+        code: string
+        message: string
+        field?: string
+    }
+    interface DatasetValue {
+        status: Status
+        code: number
+        message: string
+        data?: unknown | null
+        errors?: ErrorDetail[]
+    }
+    interface ClientErrorInstance extends Error {
+        name: string
+        message: string
+        statusCode: number
+        stack?: string
+    }
+
+    class ClientServiceResult {
+        getHttpStatusResult(): string
+        getResult(): string
+    }
+
+    interface ResultDataset {
+        status: number
+        result: string
+    }
+}
+export {}