Element API

import { ElementAPI } from '@avaya/infinity-elements-api';

const api = new ElementAPI({
  elementId: 'my-element',
  timeout: 5000,
  debug: true
});

const userInfo = await api.getUserInfo();
console.log('Agent name:', userInfo.firstName, userInfo.lastName);
console.log('Email:', userInfo.email);

api.onInteractionAccepted((interactionId) => {
  console.log('Interaction accepted:', interactionId);
});

api.onInteractionEnded((interactionId) => {
  console.log('Interaction ended:', interactionId);
});

new ElementAPI(options?: ElementAPIOptions): ElementAPI;

const api = new ElementAPI({
  elementId: 'my-custom-element',
  timeout: 10000,
  debug: true
});

getInteraction(options?: InteractionContextOptions): Promise<InteractionInfo>;

// Interaction-level widget (no interactionId needed)
try {
  const interaction = await api.getInteraction();
  console.log('Interaction ID:', interaction.interactionId);
  console.log('Customer:', interaction.customer?.name);
  console.log('Status:', interaction.status);
} catch (error) {
  console.error('No active interaction');
}

// App-level widget (interactionId required)
const interaction = await api.getInteraction({ interactionId: 'int-123' });
console.log('Status:', interaction.status);

getUserInteractions(params?: GetUserInteractionsParams): Promise<GetUserInteractionsResponse>;

// Get current user's interactions with full details
const result = await api.getUserInteractions({ details: true });
console.log('Owned interactions:', result.interactions);
console.log('Viewing interactions:', result.viewing);
console.log('Logged in queues:', result.queue.loggedIn);

// Get interactions without queue/user details for better performance
const result = await api.getUserInteractions({ details: false });
const totalCount = result.interactions.length + result.viewing.length;
console.log('Total active interactions:', totalCount);

viewerRemoveInteraction(options?: InteractionContextOptions): Promise<{ message: string }>;

// Interaction-level widget
await api.viewerRemoveInteraction();

// App-level widget
await api.viewerRemoveInteraction({ interactionId: 'int-123' });

endInteraction(options?: InteractionContextOptions): Promise<{ message: string }>;

// Interaction-level widget
await api.endInteraction();
console.log('Interaction ended');

// App-level widget
await api.endInteraction({ interactionId: 'int-123' });

startVoiceCall(options?: InteractionContextOptions): Promise<{ message: string }>;

// Interaction-level widget
await api.startVoiceCall();

// App-level widget
await api.startVoiceCall({ interactionId: 'int-123' });

createVoiceInteraction(params: CreateVoiceInteractionParams): Promise<{ message: string }>;

await api.createVoiceInteraction({
  phoneNumber: '+1234567890',
  queueId: '003'
});

completeBlindTransfer(options: BlindTransferOptions): Promise<boolean>;

const interaction = await api.getInteraction();
await api.completeBlindTransfer({
  interactionId: interaction.interactionId,
  transferTo: '[email protected]',
  transferToName: 'John Doe',
  transferCallerIdType: 'internal'
});

singleStepTransfer(params: SingleStepTransferParams): Promise<{ message: string }>;

// Interaction-level widget (no interactionId needed)
await api.singleStepTransfer({
  targetId: 'user123',
  targetName: 'Support Team'
});

// App-level widget (interactionId required)
await api.singleStepTransfer({
  targetId: 'queue-456',
  targetName: 'Sales Queue',
  interactionId: 'int-123'
});

consultCall(options: ConsultCallOptions): Promise<{ message: string }>;

// Consult with agent
const interaction = await api.getInteraction();
await api.consultCall({
  interactionId: interaction.interactionId,
  transferTo: '[email protected]'
});

// Consult with phone number
await api.consultCall({
  interactionId: interaction.interactionId,
  phoneNumber: '+1234567890'
});

// Consult with queue
const queues = await api.getTransferQueuesInteraction();
const targetQueue = queues.find(q => q.name === 'Support Queue');

await api.consultCall({
  interactionId: interaction.interactionId,
  queueId: targetQueue.id
});

completeAttendedTransfer(options?: InteractionContextOptions): Promise<{ message: string }>;

// Interaction-level widget
await api.completeAttendedTransfer();

// App-level widget
await api.completeAttendedTransfer({ interactionId: 'int-123' });

completeConference(options?: InteractionContextOptions): Promise<{ message: string }>;

// Interaction-level widget — after consulting
await api.completeConference();

// App-level widget
await api.completeConference({ interactionId: 'int-123' });

attendedTransferWarm(options?: InteractionContextOptions): Promise<{ message: string }>;

// Interaction-level widget
await api.attendedTransferWarm();

// App-level widget
await api.attendedTransferWarm({ interactionId: 'int-123' });

attendedTransferCancel(options?: InteractionContextOptions): Promise<{ message: string }>;

// Interaction-level widget
await api.attendedTransferCancel();

// App-level widget
await api.attendedTransferCancel({ interactionId: 'int-123' });

acceptInteraction(options?: InteractionContextOptions): Promise<{ message: string }>;

// Interaction-level widget
api.onInteractionAccepted(async (interactionId) => {
  console.log('New interaction:', interactionId);
});

await api.acceptInteraction();

// App-level widget
await api.acceptInteraction({ interactionId: 'int-123' });

onInteractionStatusChanged(callback: InteractionStatusChangedCallback): () => void;

const unsubscribe = api.onInteractionStatusChanged(({ interactionId, status }) => {
  console.log(`Interaction ${interactionId} status changed to ${status}`);
});

// Later, to unsubscribe:
unsubscribe();

onInteractionAccepted(callback: InteractionAcceptedCallback): () => void;

api.onInteractionAccepted((interactionId) => {
  console.log('Accepted interaction:', interactionId);
  // Load customer data, show interaction UI, etc.
});

onInteractionEnded(callback: InteractionEndedCallback): () => void;

api.onInteractionEnded((interactionId) => {
  console.log('Interaction ended:', interactionId);
  // Clean up UI, save data, etc.
});

onInteractionUpdated(callback: InteractionUpdatedCallback): () => void;

api.onInteractionUpdated(({ interactionId, payload }) => {
  console.log('Interaction updated:', interactionId);
  console.log('New data:', payload);
});

onConsultStatusChanged(callback: ConsultStatusChangedCallback): () => void;

api.onConsultStatusChanged(({ interactionId, consultStatus, consultParty }) => {
  console.log(`Consult ${consultStatus} with ${consultParty}`);
});

onCompleteAsConference(callback: CompleteAsConferenceCallback): () => void;

api.onCompleteAsConference(({ interactionId }) => {
  console.log(`Interaction ${interactionId} completed as conference`);
});

sendDialpadDigit(
  digit: DialpadDigit,
  audioOutputDeviceId: string | null,
  noSendDialTone: boolean,
  audioContextOverride?: "standard" | "webkit" | "none",
  options?: InteractionContextOptions
): Promise<{ message: string }>;

// Interaction-level widget
import { DialpadDigit } from '@avaya/infinity-elements-api';

await api.sendDialpadDigit(
  DialpadDigit.One,
  null,
  false
);

// App-level widget
await api.sendDialpadDigit(
  DialpadDigit.One,
  null,
  false,
  undefined,
  { interactionId: 'int-123' }
);

insertTextIntoFeedInput(
  text: string,
  options?: InteractionContextOptions
): Promise<{ message: string }>;

// Interaction-level widget
await api.insertTextIntoFeedInput('Hello, how can I help you today?');

// App-level widget
await api.insertTextIntoFeedInput('Hello!', { interactionId: 'int-123' });

sendRichMediaMessage(options: SendRichMediaMessageOptions): Promise<{ message: string }>;

// Send image from URL (interaction-level widget)
await api.sendRichMediaMessage({
  name: 'Product Image',
  mediaUrl: 'https://example.com/image.jpg',
  text: 'Here is the product you requested'
});

// Send file upload (app-level widget)
const fileInput = document.querySelector('input[type="file"]');
const file = fileInput.files[0];

await api.sendRichMediaMessage({
  name: 'Document',
  file: file,
  text: 'Attached document',
  interactionId: 'int-123'
});

sendChatMessage(options: SendChatMessageOptions): Promise<{ message: string }>;

// Send text message
await api.sendChatMessage({
  interactionId: 'int-123',
  text: 'Hello, how can I help you today?'
});

// Send image from URL
await api.sendChatMessage({
  interactionId: 'int-123',
  mediaUrl: 'https://example.com/image.jpg',
  text: 'Here is the product you requested'
});

// Send file upload
const fileInput = document.querySelector('input[type="file"]');
const file = fileInput.files[0];

await api.sendChatMessage({
  interactionId: 'int-123',
  file: file,
  text: 'Attached document'
});

// Send text with file
await api.sendChatMessage({
  interactionId: 'int-123',
  text: 'Please review this document',
  file: documentFile,
  fileName: 'Important Document.pdf'
});

onReceivedFeedMessage(callback: FeedMessageCallback): () => void;

api.onReceivedFeedMessage((message, interactionId) => {
  // Helper function to extract text from a message
  function getMessageText(msg: Message): string {
    if (typeof msg.message === 'string') {
      return msg.message;
    }
    // Handle rich content array
    if (Array.isArray(msg.message)) {
      return msg.message
        .map(part => {
          if (part.type === 'text') return part.text;
          if (part.type === 'email' && part.email) return part.email.plainText;
          return '';
        })
        .join(' ')
        .trim();
    }
    return '';
  }

  const text = getMessageText(message);
  console.log('New message:', text);
  console.log('From:', message.author?.displayName);
  console.log('For interaction:', interactionId);
});

getUserInfo(): Promise<UserInfo>;

const userInfo = await api.getUserInfo();
console.log('Agent:', userInfo.firstName, userInfo.lastName);
console.log('Queues:', userInfo.queues);
console.log('Email:', userInfo.email);

setAgentStatus(
  userId: string,
  status: AgentStatus,
  reason?: { id: string; name: string }
): Promise<{ message: string }>;

// Set agent to Available
const userInfo = await api.getUserInfo();
await api.setAgentStatus(
  userInfo.userId,
  { id: 'available', name: 'Available', category: 'available' }
);

// Set agent to Away with reason
const userInfo = await api.getUserInfo();
await api.setAgentStatus(
  userInfo.userId,
  { id: 'away', name: 'Away', category: 'away' },
  { id: 'lunch', name: 'Lunch Break' }
);

getAvayaJwt(options?: {
  authorizationEndpoint?: string;
  tokenEndpoint?: string;
  clientId?: string;
  scopes?: string[];
  redirectUri?: string;
  popupOptions?: PopupOptions;
  forceRefresh?: boolean;
}): Promise<string>;

// Use defaults
const jwt = await api.getAvayaJwt();

// With configuration
const jwt = await api.getAvayaJwt({
  authorizationEndpoint: 'https://keycloak.example.com/auth/realms/xxx/protocol/openid-connect/auth',
  tokenEndpoint: 'https://keycloak.example.com/auth/realms/xxx/protocol/openid-connect/token',
  clientId: 'my-client-id',
  redirectUri: 'https://myapp.com/redirect.html',
  forceRefresh: true
});

refreshToken(options?: {
  tokenEndpoint?: string;
  clientId?: string;
}): Promise<string>;

try {
  const newJwt = await api.refreshToken({
    tokenEndpoint: 'https://keycloak.example.com/auth/realms/xxx/protocol/openid-connect/token',
    clientId: 'my-client-id'
  });
  console.log('Token refreshed successfully');
} catch (error) {
  console.error('Token refresh failed:', error);
  // May need to re-authenticate
}

clearAvayaJwt(): void;

api.clearAvayaJwt();
const newJwt = await api.getAvayaJwt(); // Will trigger OAuth flow

onChangedAgentState(callback: AgentStateChangedCallback): () => void;

api.onChangedAgentState(({ previousState, currentState, reason }) => {
  console.log(`Agent state changed from ${previousState} to ${currentState}`);
  if (reason) console.log(`Reason: ${reason}`);
});

getUsers(params?: {
  interactionId?: string;
  filter?: string;
}): Promise<GetUsersResponse[]>;

// Get all users (interaction level - no interactionId needed)
const users = await api.getUsers();
users.forEach(user => {
  console.log(`$USER.FULLNAME - ${user.cxStatus.status} - $USER.PRESENCE`);
});

// Get filtered users by name (interaction level)
const users = await api.getUsers({ filter: 'john' });
console.log('Found users:', users.map(u => u.fullName));

// Get all users (app level - requires interactionId)
const users = await api.getUsers({ interactionId: 'int-123' });
users.forEach(user => {
  console.log(`$USER.FULLNAME - ${user.cxStatus.status} - $USER.PRESENCE`);
});

// Get filtered users (app level)
const users = await api.getUsers({
  interactionId: 'int-123',
  filter: 'john'
});

// Use for transfer target selection
const users = await api.getUsers({ filter: searchInput });
const eligibleUsers = users.filter(u => u.eligible);
eligibleUsers.forEach(user => {
  console.log(`$USER.FULLNAME ($USER.EXTENSION) - ${user.cxStatus.status}`);
});

getUserQueues(params?: { filter?: string }): Promise<UserQueueInfo[]>;

const queues = await api.getUserQueues();
console.log('Available queues:', queues.map(q => q.name));

// With filter
const salesQueues = await api.getUserQueues({ filter: 'Sales' });

getTransferQueues(params: {
  interactionId: string;
  filter?: string;
}): Promise<InteractionQueueInfo[]>;

const queues = await api.getTransferQueues({
  interactionId: 'int-123',
  filter: 'support'
});
queues.forEach(queue => {
  console.log(`${queue.name}: ${queue.waitingInteractions} waiting`);
  console.log(`Active agents: ${queue.countActiveAgents}`);
});

getTransferQueuesInteraction(params?: {
  filter?: string;
  interactionId?: string;
}): Promise<InteractionQueueInfo[]>;

// Interaction-level widget
const queues = await api.getTransferQueuesInteraction({ filter: 'support' });
queues.forEach(queue => {
  console.log(`${queue.name}: ${queue.waitingInteractions} waiting`);
  console.log(`Active agents: ${queue.countActiveAgents}`);
});

// App-level widget
const queues = await api.getTransferQueuesInteraction({
  filter: 'support',
  interactionId: 'int-123'
});

getReasonCodes(params?: GetReasonCodesParams): Promise<GetReasonCodesResponse>;

// Get all reason codes
const response = await api.getReasonCodes();
console.log('Reason codes:', response.reasons);

// Get away reason codes only
const response = await api.getReasonCodes({ type: 'away' });
const awayReasons = response.reasons;

sendInterElementMessage<T>(message: T): void;

api.sendInterElementMessage({ type: 'my-event', payload: { key: 'value' } });

onInterElementMessage<T>(callback: (message: T) => void): () => void;

const unsubscribe = api.onInterElementMessage<MyMessageType>((message) => {
  console.log('Received:', message);
});

// Later, stop listening
unsubscribe();

onError(callback: ErrorCallback): () => void;

api.onError((error) => {
  console.error('API Error:', error.code, error.message);
  // Display error notification to user
});

destroy(): void;

// In a React component
useEffect(() => {
  const api = new ElementAPI();
  return () => {
    api.destroy(); // Cleanup on unmount
  };
}, []);

import { DialpadDigit } from '@avaya/infinity-elements-api';

await api.sendDialpadDigit(DialpadDigit.Five, null, false);

function setupOAuthCallbackHandler(): void;

function refreshAccessToken(
  refreshToken: string,
  tokenEndpoint: string,
  clientId: string
): Promise<TokenResponse>;

function getStoredTokenData(jwtStorageKey: string): StoredTokenData | null;

function isTokenExpired(tokenData: StoredTokenData): boolean;

function isRefreshTokenExpired(tokenData: StoredTokenData): boolean;

const CHANNEL_NAMES = {
  INTERACTION_STATUS_CHANGED: "interaction-status-changed";
  INTERACTION_ENDED: "on-interaction-ended";
  INTERACTION_ACCEPTED: "on-interaction-accepted";
  INTERACTION_UPDATED: "on-interaction-updated";
  CONSULT_STATUS_CHANGED: "consult-status-changed";
  COMPLETE_AS_CONFERENCE: "on-complete-as-conference";
  FEED_MESSAGE: "feed-message";
  AGENT_STATE_CHANGED: "agent-state-changed";
  INTER_ELEMENT: "inter-element";
} as const;

type InteractionStatusChangedCallback = (payload: {
  interactionId: string;
  status: string;
}) => void;

type InteractionEndedCallback = (interactionId: string) => void;

type InteractionAcceptedCallback = (interactionId: string) => void;

type InteractionUpdatedCallback = (payload: {
  interactionId: string;
  event: "interaction.update";
  payload: Interaction;
}) => void;

type ConsultStatusChangedCallback = (payload: {
  interactionId: string;
  consultStatus: string;
  consultParty?: string;
  error?: string;
}) => void;

type CompleteAsConferenceCallback = (payload: {
  interactionId: string;
}) => void;

type FeedMessageCallback = (message: Message, interactionId?: string) => void;

type ErrorCallback = (error: {
  code: string;
  message: string;
  details?: unknown;
}) => void;

type AgentStateChangedCallback = (payload: {
  previousState: string;
  currentState: string;
  reason?: string;
}) => void;

type FancyMessage =
  | AudioMessage
  | TextMessage
  | PreviewMessage
  | FileMessage
  | ActionMessage
  | EmailMessage;

type MessageSubType = "babelVoice" | "transcription" | null;

export const VERSION = "1.2.0";