argous 1.2.134 → 1.2.138

package/dist/reducers/argous.js

@@ -0,0 +1,63 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var argous = function (state, action) {
+    var _a, _b, _c, _d;
+    if (state === void 0) { state = {
+        usuarioLogado: {},
+        loading: true,
+        processos: [],
+        favorites: [],
+        initialPage: '/',
+        fields: {},
+        block: false,
+        vldPsw: false,
+        sidebar: true
+    }; }
+    switch (action.type) {
+        case 'setUsuarioLogado':
+            return __assign(__assign({}, state), { usuarioLogado: action.usuarioLogado });
+        case 'setLoading':
+            return __assign(__assign({}, state), { loading: action.loading });
+        case 'setProcesso':
+            return __assign(__assign({}, state), { processos: action.processo });
+        case 'setNotificacao':
+            return __assign(__assign({}, state), { notificacao: action.notificacao });
+        case 'setInitialPage':
+            return __assign(__assign({}, state), { initialPage: action.initialPage });
+        case 'setCurrentProgram':
+            return __assign(__assign({}, state), { currentProgram: action.currentProgram });
+        case 'setCurrentField':
+            return __assign(__assign({}, state), { fields: state.fields[action.program]
+                    ? __assign(__assign({}, state.fields), (_a = {}, _a[action.program] = __assign(__assign({}, state.fields[action.program]), (_b = {}, _b[action.field] = action.value, _b)), _a)) : __assign(__assign({}, state.fields), (_c = {}, _c[action.program] = (_d = {},
+                    _d[action.field] = action.value,
+                    _d), _c)) });
+        case 'clearAllFields':
+            return __assign(__assign({}, state), { fields: {} });
+        case 'setFields':
+            return __assign(__assign({}, state), { fields: action.fields });
+        case 'setFavorites':
+            return __assign(__assign({}, state), { favorites: action.favorites });
+        case 'setBlockUser':
+            return __assign(__assign({}, state), { block: action.block });
+        case 'setVldPsw':
+            return __assign(__assign({}, state), { block: action.vldPsw });
+        case 'setSidebar':
+            return __assign(__assign({}, state), { sidebar: action.sidebar });
+        case 'setMensagensNaoLidas':
+            return __assign(__assign({}, state), { mensagensNaoLidas: action.mensagensNaoLidas });
+        default:
+            return state;
+    }
+};
+exports.default = argous;

package/dist/reducers/index.d.ts

@@ -0,0 +1,4 @@
+declare const reducers: import("redux").Reducer<import("redux").CombinedState<{
+    argous: never;
+}>, import("../types").ActionType>;
+export default reducers;

package/dist/reducers/index.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var argous_1 = __importDefault(require("./argous"));
+var redux_1 = require("redux");
+var reducers = redux_1.combineReducers({ argous: argous_1.default });
+exports.default = reducers;

package/dist/types.d.ts

@@ -0,0 +1,144 @@
+import { BasicModalProps } from './components';
+import { Store } from 'redux';
+
+export type argousConfig = {
+  ssl: boolean,
+  ip: string,
+  ipImagePosts?: string,
+  codigoCliente: string,
+  path?: string
+}
+
+export interface UsuarioLogado {
+  habGrupo?: boolean,
+  habChat?: boolean,
+  habProcesso?: boolean,
+  habFavorito?: boolean,
+  habNotificacao?: boolean,
+  email?: string,
+  funcao?: string,
+  idFornecedorInterno?: number,
+  idUsuario?: number,
+  nome?: string,
+  ramal?: string,
+  publTL?: boolean,
+  imagem?: string,
+  imagemCapa?: string
+}
+
+interface PromiseOptions extends BasicModalProps{
+  resolve: (value: boolean | PromiseLike<boolean>) => void, 
+  reject: (reason?: any) => void
+}
+export interface ArgousSystemType {
+  WSHandler: { onMessage: (params: any) => void },
+  headerState: { value?: 'min' },
+  pessoasChatOpen: { value: boolean },
+  janelaChatOpen?: {
+    idUsuario: number,
+    idSala: number,
+    titulo: string,
+    subtitulo: string,
+    online: boolean,
+    msgsNaoLidas: number
+  },
+  systemTopAlert?: Record<string, any>,
+  openModal?: PromiseOptions,
+  [other: string]: Record<string, any> | undefined
+}
+
+export interface FieldsType {
+  argousSystem: ArgousSystemType,
+  [program: string]: Record<string, any> | undefined
+}
+
+export interface ArgousType {
+  block: boolean,
+  currentProgram: string,
+  favorites: any[],
+  fields: FieldsType,
+  initialPage: string,
+  loading: boolean,
+  processos: any[],
+  sidebar: boolean
+  usuarioLogado: UsuarioLogado,
+  vldPsw: boolean
+}
+export interface StoreState {
+  argous: ArgousType
+}
+
+export type ArgousStore = Store<StoreState, ActionType>
+
+interface setUsuarioLogado {
+  type: 'setUsuarioLogado',
+  usuarioLogado: UsuarioLogado
+} 
+
+interface setLoading {
+  type: 'setLoading',
+  loading: boolean 
+} 
+
+interface setProcesso {
+  type: 'setProcesso',
+  processo: any 
+} 
+
+interface setInitialPage {
+  type: 'setInitialPage',
+  initialPage: string 
+} 
+
+interface setCurrentProgram {
+  type: 'setCurrentProgram',
+  currentProgram: string 
+} 
+
+interface setCurrentField {
+  type: 'setCurrentField',
+  program: string,
+  field: string,
+  value: any   
+} 
+
+interface clearAllFields {
+  type: 'clearAllFields'
+} 
+
+interface setFields {
+  type: 'setFields',
+  fields: any 
+} 
+
+interface setFavorites {
+  type: 'setFavorites',
+  favorites: any[] 
+} 
+
+interface setBlockUser {
+  type: 'setBlockUser',
+  block: boolean 
+} 
+
+interface setNotificacao {
+  type: 'setNotificacao',
+  notificacao: any 
+} 
+
+interface setSidebar {
+  type: 'setSidebar',
+  sidebar: boolean 
+} 
+
+interface setMensagensNaoLidas {
+  type: 'setMensagensNaoLidas',
+  mensagensNaoLidas: number 
+}
+
+interface setVldPsw {
+  type: 'setVldPsw',
+  vldPsw: boolean 
+} 
+
+export type ActionType = setUsuarioLogado|setLoading|setProcesso|setInitialPage|setCurrentProgram|setCurrentField|clearAllFields|setFields|setFavorites|setBlockUser|setNotificacao|setSidebar|setMensagensNaoLidas|setVldPsw

package/dist/utils/api.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @deprecated
+ */
+export declare const getServerValue: (field: string) => Promise<any>;
+/**
+ * @deprecated
+ *
+ * @param {string} field - String
+ * @param {any} value - Valor
+ *
+ * @returns {Promise<any>} retorno
+ */
+export declare const setServerValue: (field: string, value: any) => Promise<any>;
+export declare const enableDebugger: () => void;
+export declare const serverAction: (metodo: string, dados?: {}, pgCode?: string | boolean | undefined, tratarErro?: string | boolean | undefined) => Promise<any>;
+export declare function setAlert(mensagem: string, type: 'error' | 'success' | 'info' | 'warning', title: string, time?: number): void;
+export declare function setError(mensagem: string, title?: string): void;
+export declare function setSuccess(mensagem: string, title: string, time?: number): void;
+export declare function setInfo(mensagem: string, title: string, time?: number): void;
+export declare function setWarning(mensagem: string, title: string, time?: number): void;
+export declare function sendNotification({ id, mensagem, title, type, link, dsLabel }: {
+    id: string | number;
+    mensagem: string;
+    title: string;
+    type: string;
+    link: string;
+    dsLabel: string;
+}): void;
+export declare const getUrlParameters: (pgCode?: string | undefined) => Promise<any>;

package/dist/utils/api.js

@@ -0,0 +1,255 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUrlParameters = exports.sendNotification = exports.setWarning = exports.setInfo = exports.setSuccess = exports.setError = exports.setAlert = exports.serverAction = exports.enableDebugger = exports.setServerValue = exports.getServerValue = void 0;
+var config_1 = require("./config");
+var store_1 = require("./store");
+var api_1 = require("../api");
+var fieldsRedux_1 = require("../fieldsRedux");
+var getCurrentProgram = function (n) {
+    if (n === void 0) { n = 0; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var state, currentProgram;
+        return __generator(this, function (_a) {
+            state = store_1.getStore().getState();
+            currentProgram = state.argous.currentProgram;
+            if (!currentProgram) {
+                return [2 /*return*/, new Promise(function (resolve, reject) {
+                        if (n >= 10)
+                            reject(console.error('getServerValue, setServerValue ou serverAction chamado antes do mount do Programa. Use programDidMount().'));
+                        setTimeout(function () { return __awaiter(void 0, void 0, void 0, function () {
+                            var _a;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        _a = resolve;
+                                        return [4 /*yield*/, getCurrentProgram(n++)];
+                                    case 1:
+                                        _a.apply(void 0, [_b.sent()]);
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); }, 100);
+                    })];
+            }
+            return [2 /*return*/, currentProgram];
+        });
+    });
+};
+/**
+ * @deprecated
+ */
+var getServerValue = function (field) { return __awaiter(void 0, void 0, void 0, function () {
+    var currentProgram, res, value;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, getCurrentProgram()];
+            case 1:
+                currentProgram = _a.sent();
+                return [4 /*yield*/, api_1.agGet({ pgCode: currentProgram, field: field })];
+            case 2:
+                res = _a.sent();
+                if (res.pgmOk) {
+                    value = res[field];
+                    try {
+                        value = typeof value === 'object'
+                            ? value : JSON.parse(value);
+                    }
+                    catch (err) { }
+                    return [2 /*return*/, value];
+                }
+                return [2 /*return*/, ''];
+        }
+    });
+}); };
+exports.getServerValue = getServerValue;
+/**
+ * @deprecated
+ *
+ * @param {string} field - String
+ * @param {any} value - Valor
+ *
+ * @returns {Promise<any>} retorno
+ */
+var setServerValue = function (field, value) { return __awaiter(void 0, void 0, void 0, function () {
+    var currentProgram, res;
+    var _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0: return [4 /*yield*/, getCurrentProgram()];
+            case 1:
+                currentProgram = _b.sent();
+                return [4 /*yield*/, api_1.agSet((_a = { pgCode: currentProgram }, _a[field] = value, _a))];
+            case 2:
+                res = _b.sent();
+                return [2 /*return*/, !!res.pgmOk];
+        }
+    });
+}); };
+exports.setServerValue = setServerValue;
+var debuging = false;
+var enableDebugger = function () {
+    debuging = true;
+};
+exports.enableDebugger = enableDebugger;
+var serverAction = function (metodo, dados, pgCode, tratarErro) {
+    if (dados === void 0) { dados = {}; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var code, tErro, currentProgram, _a, data, res;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    code = typeof pgCode === 'string' ? pgCode : typeof tratarErro === 'string' ? tratarErro : undefined;
+                    tErro = typeof tratarErro === 'boolean' ? tratarErro : typeof pgCode === 'boolean' ? pgCode : false;
+                    _a = code;
+                    if (_a) return [3 /*break*/, 2];
+                    return [4 /*yield*/, getCurrentProgram()];
+                case 1:
+                    _a = (_b.sent());
+                    _b.label = 2;
+                case 2:
+                    currentProgram = _a;
+                    data = {
+                        pgCode: currentProgram,
+                        action: metodo,
+                        dados: dados
+                    };
+                    return [4 /*yield*/, api_1.action(data)];
+                case 3:
+                    res = _b.sent();
+                    if (debuging && process.env.NODE_ENV !== 'production') {
+                        console.log('-------- Server Action ---------');
+                        console.log('pgCode: ', currentProgram);
+                        console.log('action: ', metodo);
+                        console.log('dados: ', dados);
+                        console.log('res: ', res);
+                        if (res.dsErro)
+                            console.error(res.dsErro);
+                        console.log('--------------------------------');
+                    }
+                    if (res.dsErro && tErro)
+                        setError(res.dsErro);
+                    if (res.chTkn)
+                        document.cookie = "lt=" + res.chTkn + ";path=/;SameSite=Lax;" + (config_1.getConfig().ssl ? 'secure' : '');
+                    if (res.blkTkn) {
+                        setInfo(res.blkTkn, 'Justificativa de Bloqueio', 0);
+                        window.localStorage.setItem('blkUs', JSON.stringify(store_1.getStore().getState().argous.usuarioLogado));
+                        store_1.getStore().dispatch({ type: 'setUsuarioLogado', usuarioLogado: {} });
+                        document.cookie = "lt=;path=/;SameSite=Lax;" + (config_1.getConfig().ssl ? 'secure' : '');
+                        store_1.getStore().dispatch({ type: 'setBlockUser', block: true });
+                    }
+                    if (res.vldPsw)
+                        store_1.getStore().dispatch({ type: 'setVldPsw', vldPsw: true });
+                    return [2 /*return*/, res];
+            }
+        });
+    });
+};
+exports.serverAction = serverAction;
+function setAlert(mensagem, type, title, time) {
+    if (time === void 0) { time = 5000; }
+    setTimeout(function () {
+        fieldsRedux_1.setAnotherProgramField('systemTopAlert', { mensagem: mensagem, type: type, title: title, time: time }, 'argousSystem');
+    }, 0);
+}
+exports.setAlert = setAlert;
+function setError(mensagem, title) {
+    if (title === void 0) { title = 'Erro'; }
+    setTimeout(function () {
+        fieldsRedux_1.setAnotherProgramField('systemTopAlert', { mensagem: mensagem, type: 'error', title: title }, 'argousSystem');
+    }, 0);
+}
+exports.setError = setError;
+function setSuccess(mensagem, title, time) {
+    if (time === void 0) { time = 5000; }
+    setTimeout(function () {
+        fieldsRedux_1.setAnotherProgramField('systemTopAlert', { mensagem: mensagem, type: 'success', title: title, time: time }, 'argousSystem');
+    }, 0);
+}
+exports.setSuccess = setSuccess;
+function setInfo(mensagem, title, time) {
+    if (time === void 0) { time = 5000; }
+    setTimeout(function () {
+        fieldsRedux_1.setAnotherProgramField('systemTopAlert', { mensagem: mensagem, type: 'info', title: title, time: time }, 'argousSystem');
+    }, 0);
+}
+exports.setInfo = setInfo;
+function setWarning(mensagem, title, time) {
+    if (time === void 0) { time = 5000; }
+    setTimeout(function () {
+        fieldsRedux_1.setAnotherProgramField('systemTopAlert', { mensagem: mensagem, type: 'warning', title: title, time: time }, 'argousSystem');
+    }, 0);
+}
+exports.setWarning = setWarning;
+function sendNotification(_a) {
+    var id = _a.id, mensagem = _a.mensagem, title = _a.title, type = _a.type, link = _a.link, dsLabel = _a.dsLabel;
+    setTimeout(function () {
+        fieldsRedux_1.setAnotherProgramField('systemTopAlert', { type: 'notification', id: id, mensagem: mensagem, title: title, link: link, dsLabel: dsLabel, icon: type }, 'argousSystem');
+    }, 0);
+}
+exports.sendNotification = sendNotification;
+var getUrlVars = function () {
+    var vars = {};
+    window.location.href.replace(/[?&]+([^=&]+)=([^&]*)/gi, function (_, key, value) {
+        vars[key] = value;
+        return '';
+    });
+    return vars;
+};
+var deleteURLParameters = function () {
+    var params = window.location.href;
+    var pos = params.indexOf('?');
+    if (pos > 0)
+        params = params.substring(0, pos);
+    window.history.replaceState('object or string', 'Title', params);
+};
+var getUrlParameters = function (pgCode) { return __awaiter(void 0, void 0, void 0, function () {
+    var urlPrms;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                urlPrms = getUrlVars();
+                if (!urlPrms.ctrl) return [3 /*break*/, 2];
+                deleteURLParameters();
+                return [4 /*yield*/, exports.serverAction('getURLParameters', { ctrl: urlPrms.ctrl }, pgCode, true)];
+            case 1: return [2 /*return*/, _a.sent()];
+            case 2: return [2 /*return*/];
+        }
+    });
+}); };
+exports.getUrlParameters = getUrlParameters;

package/dist/utils/config.d.ts

@@ -0,0 +1,3 @@
+import { argousConfig } from '../types';
+export declare function setConfig(providedConfig: argousConfig, callback?: () => any): void;
+export declare function getConfig(): argousConfig;

package/dist/utils/config.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfig = exports.setConfig = void 0;
+var config;
+function setConfig(providedConfig, callback) {
+    config = providedConfig;
+    callback && callback();
+}
+exports.setConfig = setConfig;
+function getConfig() {
+    return config;
+}
+exports.getConfig = getConfig;

package/dist/utils/date.d.ts

@@ -0,0 +1,8 @@
+export declare const getMonthName: (nr: number) => "" | "Janeiro" | "Fevereiro" | "Março" | "Abril" | "Maio" | "Junho" | "Julho" | "Agosto" | "Setembro" | "Outubro" | "Novembro" | "Dezembro";
+export declare const getDayName: (day: number) => "Segunda" | "Terça" | "Quarta" | "Quinta" | "Sexta" | "Sábado" | "Domingo";
+export declare const convertMinutesToHour: (minutes: number) => string;
+export declare const sqlDateToReadableDate: (sqlDate: string) => {
+    date: string;
+    hour: string;
+};
+export declare const fixInvalidDate: (date: string) => string;

package/dist/utils/date.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fixInvalidDate = exports.sqlDateToReadableDate = exports.convertMinutesToHour = exports.getDayName = exports.getMonthName = void 0;
+var _1 = require(".");
+var getMonthName = function (nr) {
+    switch (nr) {
+        case 0: return 'Janeiro';
+        case 1: return 'Fevereiro';
+        case 2: return 'Março';
+        case 3: return 'Abril';
+        case 4: return 'Maio';
+        case 5: return 'Junho';
+        case 6: return 'Julho';
+        case 7: return 'Agosto';
+        case 8: return 'Setembro';
+        case 9: return 'Outubro';
+        case 10: return 'Novembro';
+        case 11: return 'Dezembro';
+        default: return '';
+    }
+};
+exports.getMonthName = getMonthName;
+var getDayName = function (day) {
+    switch (day) {
+        case 1: return 'Segunda';
+        case 2: return 'Terça';
+        case 3: return 'Quarta';
+        case 4: return 'Quinta';
+        case 5: return 'Sexta';
+        case 6: return 'Sábado';
+        default: return 'Domingo';
+    }
+};
+exports.getDayName = getDayName;
+var convertMinutesToHour = function (minutes) {
+    var dtAux = new Date(0, 0, 0, 0, 0, 0, 0);
+    dtAux.setMinutes(minutes);
+    return _1.addExtraZero(dtAux.getHours()) + ":" + _1.addExtraZero(dtAux.getMinutes());
+};
+exports.convertMinutesToHour = convertMinutesToHour;
+var sqlDateToReadableDate = function (sqlDate) {
+    var readableDate = { date: '', hour: '' };
+    if (sqlDate.length > 10) {
+        var date = sqlDate.slice(0, 10).split('-');
+        readableDate.date = date[2] + "/" + date[1] + "/" + date[0];
+        if (sqlDate.indexOf(' ') > -1) {
+            var hour = sqlDate.split(' ')[1].split(':');
+            readableDate.hour = hour[0] + ":" + hour[1];
+        }
+    }
+    return readableDate;
+};
+exports.sqlDateToReadableDate = sqlDateToReadableDate;
+var fixInvalidDate = function (date) {
+    if (!date || typeof date !== 'string')
+        return date;
+    var splitDate = date.split(' ');
+    return splitDate[0] + " " + splitDate[1].split(':').map(function (t) { return _1.addExtraZero(t); }).join(':');
+};
+exports.fixInvalidDate = fixInvalidDate;

package/dist/utils/index.d.ts

@@ -0,0 +1,61 @@
+import { ActionType, ArgousType } from '../types';
+import { ChartOptions } from 'chart.js';
+import { BasicModalProps } from 'lib/components';
+import React from 'react';
+export declare const widthToCenterVertically: (content: number) => number;
+export declare const getCookie: (cName: string) => string;
+export declare const addExtraZero: (vl: number | string) => string | number;
+export declare const formataNome: (value: string) => string;
+export declare function downloadBase64(base64: string, fileName: string, fileExtension: string): void;
+/**
+ * Função faz o download de qualquer url
+ *
+ * @param {string} url - Url a ser baixada
+ * @param {string} fileName - Nome do arquivo baixado
+ * @param {string=} fileExtension - Extenção do arquivo baixado
+ *
+ * @returns {void}
+ */
+export declare function downloadFromUrl(url: string, fileName: string, fileExtension?: string): Promise<void>;
+export declare const printPdf: (URL?: string) => Promise<void>;
+export declare const getRandomColor: () => string;
+export declare const getInitials: (nome?: string) => string;
+export declare const getNumeroFromInitials: (initials: string, length: number) => number;
+export declare const usePrevious: (value: any) => undefined;
+/**
+ * Igual o useEffect, mas não ativa quando o componente monta
+ *
+ * @param {React.EffectCallback} effect - Função imperativa que pode retornar uma função de limpeza
+ * @param {React.DependencyList} dependencies - Dependencias que quando atualizadas rodarão o efeito
+ *
+ * @returns {void} Sem retorno
+ */
+export declare function useUpdateEffect(effect: React.EffectCallback, dependencies: React.DependencyList): void;
+export declare function formataDinheiro(n: number): string;
+export declare const sanitizaHTML: (html?: string) => string;
+/**
+ * Format bytes as human-readable text.
+ *
+ * @param {number} bytes - Number of bytes.
+ * @param {boolean} si - True to use metric (SI) units, aka powers of 1000. False to use binary (IEC) units, aka powers of 1024.
+ * @param {number} dp - Number of decimal places to display.
+ *
+ * @returns {string} Formatted string.
+ */
+export declare const humanFileSize: (bytes: number, si?: boolean, dp?: number) => string;
+export declare const randomColor: () => string;
+/**
+ * Hook para padronizar o tema dos gráficos
+ *
+ * @param {ChartOptions} props - Props customizados
+ * @returns {ChartOptions} - retorno com tema ajustado
+ */
+export declare const useGraph: ({ title, legend: { labels, ...legend }, plugins: { datalabels, ...plugins }, scales: { yAxes: [{ ticks: yticks, gridLines: ygridLines, ...yAxes }, ...y], xAxes: [{ ticks: xticks, gridLines: xgridLines, ...xAxes }, ...x], ...scales }, ...props }?: ChartOptions) => ChartOptions;
+export declare const useModal: () => import("lib/components").ModalProviderContextProps;
+export declare const useStore: () => ArgousType;
+export declare const reduxDispatch: (action: ActionType) => void;
+export declare const formataTelefone: (value: string) => string;
+export declare const useWebSocket: () => {};
+export declare const formataCpf: (value: string) => string;
+export declare const copyToClipboard: (text: string) => void;
+export declare const confirm: (props: BasicModalProps | string) => Promise<boolean>;