Pular para o conteúdo
Iara Syncfusion Adapter

Guia TypeScript

Instalação de Tipos

O pacote @iarastt/adapters já inclui as definições de tipos TypeScript:

import { IaraSyncfusionAdapter } from '@iarastt/adapters';
// Tipos são importados automaticamente

Interfaces Principais

IaraSyncfusionConfig

Interface de configuração do adapter.

interface IaraSyncfusionConfig {
  // Assistente de IA
  assistant?: {
    enabled: boolean;
    enableDiffHighlighting?: boolean;
    impression?: {
      itemizedOutput: boolean;
    };
    user_rules?: {
      report?: string[];
      impression?: string[];
    };
    draggable?: {
      containerId: string;
      defaultPosition: { x: number; y: number };
    };
  };


  // Funcionalidades
  enableSpeechRecognition?: boolean;
  saveReport?: boolean;
  highlightInference?: boolean;


  // Interface
  replaceToolbar?: boolean;
  showFinishReportButton?: boolean;
  showBookmarks?: boolean;
  mouseButton?: boolean;


  // Comportamento
  navigateAdditiveMode?: 'use' | 'registry';


  // Aparência
  darkMode?: boolean;
  language?: 'pt-BR' | 'es';
  zoomFactor?: string;


  // Fonte
  font?: {
    family: string;
    size: number;
    availableFamilies?: string[];
    availableSizes?: number[];
  };


  // Ribbon
  ribbon?: {
    displayMode: 'Classic' | 'Simplified';
    collections?: {
      logo?: boolean;
      file?: boolean;
      insert?: boolean;
      clipboard?: boolean;
      navigation?: boolean;
      font?: boolean;
      paragraph?: boolean;
      export?: boolean;
    };
  };
}

IaraSyncfusionContentManager

Interface do gerenciador de conteúdo.

interface IaraSyncfusionContentManager {
  reader: {
    getHtmlContent(): Promise<string>;
    getPlainTextContent(): Promise<string>;
    getRtfContent(): Promise<string>;
    getSfdtContent(): Promise<IaraSFDT>;
  };
}

IaraSFDT

Formato de documento Syncfusion.

interface IaraSFDT {
  sections: Array<{
    blocks: Array<{
      paragraphFormat?: any;
      characterFormat?: any;
      inlines?: any[];
    }>;
  }>;
  characterFormat?: any;
  paragraphFormat?: any;
  defaultTabWidth?: number;
  enforcement?: boolean;
  hashValue?: string;
  saltValue?: string;
  formatting?: boolean;
  protectionType?: string;
  dontUseHTMLParagraphAutoSpacing?: boolean;
  alignTablesRowByRow?: boolean;
  formFieldShading?: boolean;
  styles?: any[];
  lists?: any[];
  abstractLists?: any[];
  background?: any;
  footnotes?: any;
  endnotes?: any;
}

Exemplo Completo TypeScript

import { IaraSyncfusionAdapter, type IaraSyncfusionConfig } from '@iarastt/adapters';
import { DocumentEditorContainer, Toolbar } from '@syncfusion/ej2-documenteditor';


// Declarar tipo global do Iara Speech SDK (vem do HTML via CDN)
declare const IaraSpeechRecognition: any;


// Configuração tipada COMPLETA
const config: IaraSyncfusionConfig = {
  assistant: {
    enabled: true,
    impression: {
      itemizedOutput: true
    },
    user_rules: {
      report: ['Usar terminologia médica padrão'],
      impression: ['Ser conciso']
    }
  },
  enableSpeechRecognition: true,
  saveReport: true,
  language: 'pt-BR',
  darkMode: false,
  mouseButton: false,
  replaceToolbar: false,
  showBookmarks: false,
  showFinishReportButton: false,
  highlightInference: true,
  zoomFactor: '100%',
  font: {
    availableFamilies: ['Arial', 'Times New Roman', 'Calibri'],
    availableSizes: [10, 11, 12, 14, 16, 18],
    family: 'Arial',
    size: 12
  }
};


// Função de inicialização tipada
async function initializeEditor(
  editorContainer: any, // DocumentEditorContainer do Syncfusion
  recognition: any // IaraSpeechRecognition não tem tipos públicos
): Promise<IaraSyncfusionAdapter> {
  return new Promise((resolve, reject) => {
    recognition.init({
      userId: process.env.IARA_USER_ID,
      apiToken: process.env.IARA_API_TOKEN,
      engine: 'Iara Desktop',
      lang: 'pt-BR',
      region: 'south-america',
      interimResults: true
    })
    .done(() => {
      try {
        const adapter = new IaraSyncfusionAdapter(
          editorContainer.documentEditor,
          recognition,
          config
        );
        resolve(adapter);
      } catch (error) {
        reject(error);
      }
    })
    .fail((error: Error) => {
      reject(error);
    });
  });
}


DocumentEditorContainer.Inject(Toolbar);


const editorContainer = new DocumentEditorContainer({
  enableToolbar: true,
  height: "600px"
});
editorContainer.appendTo('#editor-container');


const recognition = new IaraSpeechRecognition();


initializeEditor(editorContainer, recognition)
  .then(adapter => {
    console.log('✅ Adapter inicializado:', adapter);


    // Callback tipado
    adapter.onIaraCommand = (command: string) => {
      console.log('Comando:', command);
    };


    // ✅ CORRETO: Usar event listener para salvar
    addEventListener('IaraOnSaveReport', () => {
      console.log('💾 Salvando relatório');
      // Aqui você implementa a lógica de salvamento
    });
  })
  .catch(error => {
    console.error('❌ Erro:', error);
  });

Próximos Passos