Pular para o conteúdo principal

Módulo de Eventos RTM

O Módulo de Eventos RTM fornece funcionalidade para assinar e lidar com eventos em tempo real no SDK da Web do Gamanza Engage. Ele permite que os desenvolvedores assinem vários eventos, cancelem a assinatura de eventos e emitam dados para a conexão WebSocket.

Acessando o Módulo​

O Módulo de Eventos RTM pode ser acessado por meio da instância do SDK do Gamanza Engage:

const Events = sdk.Events;

Métodos Públicos​

assinar​

Assina para receber eventos em tempo real com base na API de comunicação em tempo real fornecida pelo Gamanza Engage.

Assinatura:

assinar(evento, callback, opções)

Definições de Tipo:

function assinar<T extends keyof EventTypeMap>(
  evento: T, 
  callback: SDKEventListener<T>, 
  opções?: SubscriptionOptions
): string;

Parâmetros:

NomeTipoDescrição
eventokeyof EventTypeMapO nome do evento para o qual assinar
callbackSDKEventListener<T>A função de retorno de chamada que será chamada quando o evento for disparado
opçõesSubscriptionOptions (opcional)Opções adicionais para a assinatura

Retorna:

TipoDescrição
Tipo stringUm ID de assinatura exclusivo que pode ser usado para cancelar a assinatura do evento

Exemplo:

// Assinar a eventos de aumento de XP
const idAssinatura = rtmEvents.assinar('ranks:on:xpUp', (data, eventoRaw) => {
  console.log('O XP do jogador aumentou:', data.xpBalance);
  console.log('Evento bruto:', eventoRaw);
});

// Assinar com opções
const idAssinaturaComOpcoes = rtmEvents.assinar('ranks:on:levelUp', 
  (data, eventoRaw) => {
    console.log('O jogador subiu para o nível:', data.level.levelNumber);
  },
  { 
    once: true, // Disparar apenas uma vez
    timeout: 60000, // Expirar após 60 segundos
    filter: (data) => data.level.levelNumber > 5 // Disparar apenas para níveis acima de 5
  }
);

cancelar assinatura​

Remove uma única assinatura por seu identificador.

Assinatura:

cancelar assinatura(idAssinatura)

Definições de Tipo:

function cancelar assinatura(idAssinatura: string): boolean;

Parâmetros:

NomeTipoDescrição
idAssinaturaTipo stringO ID de assinatura exclusivo retornado pelo método assinar

Retorna:

TipoDescrição
booleantrue se a assinatura foi removida com sucesso, false caso contrário

Exemplo:

// Cancelar a assinatura de um evento
const subscriptionId = rtmEvents.subscribe('ranks:on:xpUp', callback);
const unsubscribed = rtmEvents.unsubscribe(subscriptionId);

if (unsubscribed) {
  console.log('Assinatura cancelada com sucesso');
} else {
  console.log('Falha ao cancelar a assinatura ou assinatura não encontrada');
}

unsubscribeFromEvent​

Remove todas as assinaturas ativas de um evento específico.

Assinatura:

unsubscribeFromEvent(event)

Definições de Tipo:

function unsubscribeFromEvent<T extends keyof EventTypeMap>(event: T): number;

Parâmetros:

NomeTipoDescrição
eventkeyof EventTypeMapO nome do evento para o qual a assinatura será cancelada

Retorna:

TipoDescrição
numberO número de assinaturas removidas

Exemplo:

// Cancelar todas as assinaturas de eventos de aumento de XP
const removedCount = rtmEvents.unsubscribeFromEvent('ranks:on:xpUp');
console.log(`Removidas ${removedCount} assinaturas`);

getEventsStats​

Retorna estatísticas sobre as assinaturas de eventos atuais.

Assinatura:

getEventsStats()

Definições de Tipo:

function getEventsStats(): Record<string, any>;

Parâmetros:

Nenhum

Retorna:

TipoDescrição
Record<string, any>Um objeto contendo estatísticas sobre as assinaturas de eventos atuais

Exemplo:

// Obter estatísticas de assinaturas
const stats = rtmEvents.getEventsStats();
console.log('Assinaturas atuais:', stats);

emitToWebSocket​

Envia dados usando o Serviço de Mensagens Gamanza Engage (WebSockets).

Assinatura:

emitToWebSocket(event, data)

Definições de Tipo:

function emitToWebSocket<T extends keyof EmitterTypeMap>(event: T, data: EmitterTypeMap[T]): void;

Parâmetros:

NomeTipoDescrição
eventoskeyof EmitterTypeMapO nome do evento a ser emitido
dataEmitterTypeMap[T]Os dados a serem enviados com o evento

Retorna:

TipoDescrição
voidEste método não retorna um valor

Exemplo:

// Enviar uma mensagem de confirmação
rtmEvents.emitToWebSocket('send:ack', { messageId: 'message-123' });

// Enviar um evento de rastreamento de análises
rtmEvents.emitToWebSocket('send:analytics:event', { 
  eventName: 'button_click',
  properties: {
    buttonId: 'login-button',
    timestamp: Date.now()
  }
});

Eventos​

O Módulo de Eventos RTM fornece acesso a vários eventos em tempo real que podem ser assinados. Esses eventos são categorizados em diferentes grupos com base em sua funcionalidade.

Constantes de Evento​

Para melhor manutenção e evitar erros de digitação, é recomendável usar a constante exportada EVENTS. Estas constantes são organizadas por namespace, correspondendo às categorias nas tabelas abaixo.

Exemplo de UI:

import { EVENTS } from '@gamanza/engage-web-client-sdk';

// Assinar usando a constante
sdk.Events.subscribe(EVENTS.RANKS.ON_XP_UP, (data) => {
  console.log('XP Atualizado:', data.xpBalance);
});

// Ou usando a constante de namespace para eventos do jogador
sdk.Events.subscribe(EVENTS.PLAYER.ON_GAMIFICATION_OPT_IN, (data) => {
  console.log('Jogador optou');
});

Selecionar Eventos​

ConstanteNome do EventoDescriçãoTipoTipo de GarantiaPropriedades
SYSTEM.ON_ERRORon:errorEventos de erro do sistemaDiretoFIRE_FORGETpropriedades de erro adicionais

Estrutura do Evento de Acionamento​

interface ErrorEventData extends BaseEventData {
  [key: string]: unknown; // Propriedades de erro adicionais
}

Eventos do Jogador​

ConstanteNome do EventoDescriçãoTipoTipo de GarantiaPropriedades
RANKS.ON_XP_UPranks:on:xpUpEventos de aumento de XPDiretoFIRE_FORGETplayerId: string, level: Level, nextLevel?: Level, nextRank?: Rank, pointsUntilNextLevel: number, pointsUntilNextRank: number, rank: Rank, xpBalance: number, rewardsGroupId: string
RANKS.ON_LEVEL_UPranks:on:levelUpEventos de aumento de nívelDiretoFIRE_FORGETplayerId: string, level: Level, nextLevel?: Level, nextRank?: Rank, pointsUntilNextLevel: number, pointsUntilNextRank: number, rank: Rank, xpBalance: number, claimReward: true, rewards: LoyaltyRewards[], rewardsGroupId: string
RANKS.ON_RANK_UPranks:on:rankUpEventos de aumento de postoDiretoFIRE_FORGETplayerId: string, level: Level, nextLevel?: Level, nextRank?: Rank, pointsUntilNextLevel: number, pointsUntilNextRank: number, rank: Rank, xpBalance: number, claimReward: boolean, rewards: Reward[], rewardsGroupId: string
RANKS.ON_MAX_CAP_REACHEDcapsMultipliers:on:capReachedEventos de alcance do limite máximoDiretoFIRE_FORGETplayerId: string, type: string, limit: number, period: string, reached: boolean
RANKS.ON_LEVEL_BOOSTER_ACTIVATEDranks:on:levelBoosterActivatedEventos de ativação de impulsionador de nívelDiretoFIRE_FORGET_id: string, playerId: string, rewardId: string, boosterRate: number, timeStart: string, timeEnd: string, status: string, type: string, boosterType?: RewardTypeEnum, countDown?: ActiveCountdownBoosterType, metadata?: ActiveMetadataBoosterType, isNew?: boolean, isRecentBooster?: boolean, createAt?: string
RANKS.ON_LEVEL_BOOSTER_ENDranks:on:levelBoosterEndEventos de término de impulsionador de nívelDiretoFIRE_FORGET_id: string, playerId: string, rewardId: string, boosterRate: number, timeStart: string, timeEnd: string, status: string, type: string, boosterType?: RewardTypeEnum, countDown?: ActiveCountdownBoosterType, metadata?: ActiveMetadataBoosterType, isNew?: boolean, isRecentBooster?: boolean, createAt?: string
PLAYER.ON_GAMIFICATION_OPT_INranks:on:optInEventos de ativação da gamificaçãoDiretoFIRE_FORGETplayerId: string, status: string
PLAYER.ON_GAMIFICATION_OPT_OUTranks:on:optOutEventos de cancelamento da GamificaçãoDiretoFIRE_FORGETplayerId: string, status: string

Estrutura de Dados do Evento de Aumento de XP​

interface XpUpEventData extends BaseEventData {
  playerId: string;
  level: {
    _id: string;
    levelNumber: number;
  };
  nextLevel?: {
    _id: string;
    levelNumber: number;
  };
  nextRank?: {
    _id: string;
    name: string;
    imageUrl: string;
    translations: {
      language: string;
      name: string;
      description: string;
    }[];
  };
  pointsUntilNextLevel: number;
  pointsUntilNextRank: number;
  rank: {
    _id: string;
    name: string;
    imageUrl: string;
    translations: {
      language: string;
      name: string;
      description: string;
    }[];
  };
  xpBalance: number;
  rewardsGroupId: string;
}

Estrutura de Dados do Evento de Aumento de Nível​

interface LevelUpEventData extends BaseEventData {
  playerId: string;
  level: {
    _id: string;
    levelNumber: number;
  };
  nextLevel?: {
    _id: string;
    levelNumber: number;
  };
  nextRank?: {
    _id: string;
    name: string;
    imageUrl: string;
    translations: {
      language: string;
      name: string;
      description: string;
    }[];
  };
  pointsUntilNextLevel: number;
  pointsUntilNextRank: number;
  rank: {
    _id: string;
    name: string;
    imageUrl: string;
    translations: {
      language: string;
      name: string;
      description: string;
    }[];
  };
  xpBalance: number;
  claimReward: true;
  rewards: LoyaltyRewards[];
  rewardsGroupId: string;
}

Estrutura de Dados do Evento de Aumento de Patente​

interface RankUpEventData extends BaseEventData {
  playerId: string;
  level: {
    _id: string;
    levelNumber: number;
  };
  nextLevel?: {
    _id: string;
    levelNumber: number;
  };
  nextRank?: {
    _id: string;
    name: string;
    imageUrl: string;
    translations: {
      language: string;
      name: string;
      description: string;
    }[];
  };
  pointsUntilNextLevel: number;
  pointsUntilNextRank: number;
  rank: {
    _id: string;
    name: string;
    imageUrl: string;
    translations: {
      language: string;
      name: string;
      description: string;
    }[];
  };
  xpBalance: number;
  claimReward: boolean;
  rewards: LoyaltyRewards[];
  rewardsGroupId: string;
}

Tipo LoyaltyRewards​

LoyaltyRewards é uma forma de recompensa especializada usada pelos eventos de Lealdade (Patentes/Níveis).

export type LoyaltyRewards = Omit<Reward, 'rewardType'> & { type: RewardTypeEnum };

Estrutura de Dados do Evento de Limite Máximo de Patentes Atingido​

interface RanksMaxCapReachedEventData extends BaseEventData {
  playerId: string;
  type: string;
  limit: number;
  period: string;
  reached: boolean;
}

Estrutura de Dados do Evento de Booster Ativo​

interface ActiveBoosterEventData extends BaseEventData {
  _id: string;
  playerId: string;
  rewardId: string;
  boosterRate: number;
  timeStart: string;
  timeEnd: string;
  status: string;
  type: string;
  boosterType?: RewardTypeEnum;
  countDown?: {
    days: number;
    hours: number;
    minutes: number;
    seconds: number;
    totalSeconds: number;
  };
  metadata?: {
    [key: string]: unknown;
  };
  isNew?: boolean;
  isRecentBooster?: boolean;
  createAt?: string;
}

Estrutura de Dados do Evento de Opt de Gamificação​

interface GamificationOptEventData extends BaseEventData {
  playerId: string;
  status: string;
}

Eventos de Moeda Virtual​

ConstanteNome do EventoDescriçãoTipoTipo de GarantiaPropriedades
VIRTUAL_CURRENCY.ON_WALLET_UPDATEvirtualCurrency:on:walletUpdateEventos de atualização do saldo da carteiraDiretoFIRE_FORGETbalance: number, playerId: string
VIRTUAL_CURRENCY.ON_TOKEN_BOOSTER_ACTIVATEDvirtualCurrency:on:tokenBoosterActivatedEventos de ativação do intensificador de tokenDiretoFIRE_FORGET_id: string, playerId: string, rewardId: string, boosterRate: number, timeStart: string, timeEnd: string, status: string, type: string, boosterType?: RewardTypeEnum, countDown?: ActiveCountdownBoosterType, metadata?: ActiveMetadataBoosterType, isNew?: boolean, isRecentBooster?: boolean, createAt?: string
VIRTUAL_CURRENCY.ON_TOKEN_BOOSTER_ENDvirtualCurrency:on:tokenBoosterEndEventos de término do intensificador de tokenDiretoFIRE_FORGET_id: string, playerId: string, rewardId: string, boosterRate: number, timeStart: string, timeEnd: string, status: string, type: string, boosterType?: RewardTypeEnum, countDown?: ActiveCountdownBoosterType, metadata?: ActiveMetadataBoosterType, isNew?: boolean, isRecentBooster?: boolean, createAt?: string

Estrutura de dados do evento de atualização da carteira​

interface WalletUpdateEventData extends BaseEventData {
  balance: number;
  playerId: string;
}

Eventos de Missões​

ConstanteNome do eventoDescriçãoTipoTipo de garantiaPropriedades
MISSIONS.ON_MISSION_BOOSTER_ACTIVATEDmissions:on:missionsBoosterActivatedEventos de ativação do intensificador de missõesDiretoFIRE_FORGET_id: string, playerId: string, rewardId: string, boosterRate: number, timeStart: string, timeEnd: string, status: string, type: string, boosterType?: RewardTypeEnum, countDown?: ActiveCountdownBoosterType, metadata?: MissionBoosterMetadataType, isNew?: boolean, isRecentBooster?: boolean, createAt?: string
MISSIONS.ON_MISSION_BOOSTER_ENDmissions:on:missionsBoosterEndEventos de término do intensificador de missõesDiretoFIRE_FORGET_id: string, playerId: string, rewardId: string, boosterRate: number, timeStart: string, timeEnd: string, status: string, type: string, boosterType?: RewardTypeEnum, countDown?: ActiveCountdownBoosterType, metadata?: MissionBoosterMetadataType, isNew?: boolean, isRecentBooster?: boolean, createAt?: string
MISSIONS.ON_MISSION_OBJECTIVE_UPDATEmissions:on:objectiveUpdateEventos de atualização de objetivo da missãoDiretoFIRE_FORGETplayerId: string, bundleId: string, bundleStateId: string, missionId: string, missionStateId: string, objectiveId: string, objectiveStateId: string, objectiveSummary: any, date: string
MISSIONS.ON_MISSION_OBJECTIVE_COMPLETEmissions:on:objectiveCompleteEventos de conclusão de objetivo da missãoDiretoFIRE_FORGETplayerId: string, bundleId: string, bundleStateId: string, missionId: string, missionStateId: string, objectiveId: string, objectiveStateId: string, objectiveSummary: any, date: string
MISSIONS.ON_MISSION_UPDATEmissions:on:missionUpdateEventos de atualização de missãoDiretoFIRE_FORGETplayerId: string, easterEggs: any, _id: string, name: string, description: string, tags: string[], objectives: any[], validityTime: any, status: string, rewardCategories: any[], rewardClaimStatus: string, missionBundleState: any, bundleInternalDetails: any, bundleExternalDetails: any, enabled: boolean, version: number, state: string, missionBundleId: string, bundleStateId: string, missionId: string, endDate: string, startDate: string
MISSIONS.ON_MISSION_COMPLETEmissions:on:missionCompleteEventos de conclusão de missãoDiretoFIRE_FORGETplayerId: string, easterEggs: any, _id: string, name: string, description: string, tags: string[], objectives: any[], validityTime: any, status: string, rewardCategories: any[], rewardClaimStatus: string, missionBundleState: any, bundleInternalDetails: any, bundleExternalDetails: any, enabled: boolean, version: number, state: string, missionBundleId: string, bundleStateId: string, missionId: string, endDate: string, startDate: string
MISSIONS.ON_MISSION_BUNDLE_COMPLETEmissions:on:missionBundleCompleteEventos de conclusão de pacote de missãoDiretoFIRE_FORGETplayerId: string, bundleId: string, status: string, bundleSummary: any, date: string
MISSIONS.ON_MISSION_BUNDLE_ASSIGNEDmissions:on:missionBundleAssignEventos de atribuição de pacote de missãoDiretoIGNORAR_INCÊNDIOplayerId: string, missionBundleExternalDescription: any, date: string
MISSIONS.ON_MISSION_ENDEDmissions:on:missionEndedEvento acionado quando uma missão é encerrada manualmente por um operador do painel administrativo.DiretaIGNORAR_INCÊNDIObundleId: string, missionId: string
MISSIONS.ON_MISSION_BUNDLE_ENDEDmissions:on:bundleEndedEvento acionado quando um pacote é encerrado manualmente por um operador do painel administrativo.Direta e DifusãoIGNORAR_INCÊNDIObundleId: string
MISSIONS.ON_MISSION_REWARD_CLAIMEDmissions:on:rewardClaimedEvento acionado quando uma recompensa é reivindicada pelo jogador do pacote de missões.DiretaIGNORAR_INCÊNDIOplayerId: string, rewardId: string, status: RewardStatusEnum, missBundleStateId: string, missionStateId: string, timestamp: number

Estrutura de Tipo de Metadados do Booste de Missão​

interface MissionBoosterMetadataType {
  missionId: string;
  bundleId: string;
  missionDescription: string;
  missionBundleExternalDetails: {
    language: string;
    name: string;
    description: string;
  };
  rewardId: string;
  bundleStateId: string;
  missionStateId: string;
  [key: string]: unknown;
}

Estrutura de Dados de Evento de Objetivo de Missão​

interface MissionObjectiveEventData extends BaseEventData {
  playerId: string;
  bundleId: string;
  bundleStateId: string;
  missionId: string;
  missionStateId: string;
  objectiveId: string;
  objectiveStateId: string;
  objectiveSummary: {
      _id: string;
      conditionValue: string;
      conditionType: string;
      translations: Pick<TranslationType, 'language' | 'name' | 'description'>[];
      missionEventType: string;
      value: number;
      completed: boolean;
      state: MissionProgressType;
  };
  date: string;
}

Estrutura de Dados de Evento de Atualização de Missão​

export interface MissionUpdateEventData extends BaseEventData {
    _id: string;
    name: string;
    description: string;
    tags: SlimTagType[];
    objectives: ObjectiveMissionTypes[];
    validityTime: ValidityTimeType | ValidityTimePeriodType | ValidityTimeSpecificDateType;
    status: MissionStatusEnum;
    rewardCategories: MissionRewardCategoryType[];
    rewardClaimStatus?: MissionClaimStatusType;
    missionBundleState?: MissionProgressType;
    bundleInternalDetails: InternalDetailType;
    bundleExternalDetails: TranslationType[];
    enabled: boolean;
    version: number;
    state?: MissionProgressType;
    missionBundleId?: string;
    bundleStateId?: string;
    missionId?: string;
    endDate?: string;
    startDate?: string;
    originalMissionBundleId: string;
    playerId: string;
    repetitionCount?: number;
    repetitionEnabled: boolean;
    playerId: string;
    easterEggs?: EasterEggsType[];
}

Estrutura de Dados de Evento de Pacote de Missão​

interface MissionBundleEventData extends BaseEventData {
  playerId: string;
  bundleId: string;
  status: string;
  bundleSummary: {
      _id: string;
      missionBundleExternalDescription: TranslationType;
      state: MissionProgressType;
  };
  date: string;
}

Estrutura de Dados de Evento de Atribuição de Pacote de Missão​

interface MissionBundleAssignEventData extends BaseEventData {
  playerId: string;
  missionBundleExternalDescription: TranslationType[];
  date: string;
}

Estrutura de Dados de Evento de Missão Encerrada​

interface MissionEndedEventData extends BaseEventData {
    /**
     * O identificador exclusivo do pacote no pacote atribuído deve ser originalId
     */
    bundleId: string;
    /**
     * Identificador exclusivo da missão no estado do pacote do jogador.
     */
    missionId: string;
}

Estrutura de Dados de Evento de Pacote de Missão Encerrado​

interface MissãoBunbleEndedEventData extends BaseEventData {
    /**
     * O identificador único do bunble no bunble assignado deve ser originalId
     */
    bundleId: string;
}

Estrutura de Dados do Evento de Recompensa de Missão Reivindicada​

interface MissãoRewardClaimedEventData extends BaseEventData {
  playerId: string;
  rewardId: string;
  status: RewardStatusEnum;
  missBundleStateId: string;
  missionStateId: string;
  timestamp: number;
}
Exemplo​
// Assine eventos de recompensa de missão reivindicada
sdk.Events.subscribe(EVENTS.MISSIONS.ON_MISSION_REWARD_CLAIMED, (data) => {
  console.log(`Recompensa ${data.rewardId} reivindicada com sucesso!`);
  console.log(`Status: ${data.status}`);
});

Eventos de Torneios​

ConstanteNome do EventoDescriçãoTipoTipo de GarantiaPropriedades
TOURNAMENTS.ON_TOURNAMENT_BEFORE_STARTStournaments:on:beforeStartsEventos de torneio prestes a começarDiretoFIRE_FORGETplayerId: string, tournamentId?: string, tournamentName: string, tournamentDescription: string, tournamentType: TournamentTypeEnum, optIn: boolean, maxNumberOfBets: number, timePeriod?: TimePeriodType, externalDetails: ExternalDetailsEntity[], industry: TournamentIndustryTypeEnum, leaderboardRewards: LeaderboardReward[]
TOURNAMENTS.ON_TOURNAMENT_STARTStournaments:on:startsEventos de início de torneioDiretoFIRE_FORGETplayerId: string, tournamentId?: string, tournamentName: string, tournamentDescription: string, tournamentType: TournamentTypeEnum, optIn: boolean, maxNumberOfBets: number, timePeriod?: TimePeriodType, externalDetails: ExternalDetailsEntity[], industry: TournamentIndustryTypeEnum, leaderboardRewards: LeaderboardReward[]
TOURNAMENTS.ON_TOURNAMENT_ENDStournaments:on:endedEventos de fim de torneioDiretoFIRE_FORGETexternalDetails: ExternalDetailsEntity[], industry: TournamentIndustryTypeEnum, maxNumberOfBets: number, optIn: boolean, timePeriod?: TimePeriodType, tournamentDescription: string, tournamentId: string, tournamentName: string, tournamentType: TournamentTypeEnum, leaderboardRewards: LeaderboardReward[]
TOURNAMENTS.ON_TOURNAMENT_CANCELEDtournaments:on:canceledTorneio cancelado por um administradorBroadcastFIRE_FORGETtournamentId?: string, externalDetails: ExternalDetailsEntity[]
TOURNAMENTS.ON_TOURNAMENT_PLAYER_REWARDStournaments:on:playerWonRewardsEventos de recompensas de jogador de torneioDiretoFIRE_FORGETindústria: TournamentIndustryTypeEnum, maxNumberOfBets: number, optIn: boolean, timePeriod?: TimePeriodType, tournamentDescription: string, tournamentId: string, tournamentName: string, tournamentType: TournamentTypeEnum, leaderboard: { position: number }, leaderboardRewards: LeaderboardReward[], earnedRewards?: { [key: string]: Reward }
TOURNAMENTS.ON_LEADERBOARD_UPDATEDtournaments:on:leaderboardUpdatedAtualização de quadro de líderes de torneioTransmissãoFIRE_FORGETtorneio: Omit<TournamentEventData, 'tournamentId'>[], leaderboard: Omit<PlayerLeaderboard & { rankId: string }, 'leaderboardRewards'>[], timestamp: number
TOURNAMENTS.ON_TOURNAMENT_PLAYER_LEADERBOARD_UPDATEDtournaments:on:playerLeaderboardUpdatedEventos de atualização de quadro de líderes de jogadorDiretoFIRE_FORGETtorneios: { tournamentId: string, position: number, score: number, spinsLeft: number, type: TournamentTypeEnum, round?: RoundInfo }[], timestamp: number
TOURNAMENTS.ON_SPINS_LEFT_EMPTYtournaments:on:spinsLeftEmptyEventos de sem giros restantesDiretoFIRE_FORGETplayerId: string, torneio: { _id: string } & Omit<TournamentEventData, 'tournamentId'>
TOURNAMENTS.ON_LEADERBOARD_READYtournaments:on:leaderboardReadyEventos de quadro de líderes prontoTransmissãoFIRE_FORGETtournamentId: string, externalDetails: ({ elegibilityDisplayName?: string } & TranslationType)[], leaderboardRewards: LeaderboardReward[], eligibility: TournamentEligibilityType

Estrutura de Dados de Evento de Notificação de Torneio​

// Equivalente a Omit<TournamentEventData, 'player' | 'earnedRewards' | 'internalDetails' | 'rewardsGroupId' | 'leaderboard' | 'eligibility' | 'objectives' | 'status' | '_id'>
interface TournamentNotificationsEventData extends BaseEventData {
  playerId: string;
  tournamentId?: string;
  tournamentName: string;
  tournamentDescription: string;
  tournamentType: TournamentTypeEnum;
  optIn: boolean;
  maxNumberOfBets: number;
  timePeriod?: TimePeriodType;
  externalDetails: ExternalDetailsEntity[];
  industry: TournamentIndustryTypeEnum;
  leaderboardRewards: LeaderboardReward[];
}

Estrutura de Dados de Evento de Torneio Encerrado​

interface TournamentEndedEventData extends BaseEventData {
  externalDetails: ExternalDetailsEntity[];
  industry: TournamentIndustryTypeEnum;
  leaderboardRewards: LeaderboardReward[];
  maxNumberOfBets: number;
  optIn: boolean;
  timePeriod?: TimePeriodType;
  tournamentDescription: string;
  tournamentId: string;
  tournamentName: string;
  tournamentType: TournamentTypeEnum;
}

Estrutura de Dados de Evento de Torneio Cancelado​

// Equivalente a Pick<TournamentEventData, 'tournamentId' | 'externalDetails'>
interface TournamentCanceledEventData extends BaseEventData {
  /**
   * O identificador exclusivo do torneio. Opcional porque em algumas notificações de torneio é opcional no tipo base.
   */
  tournamentId?: string;
  /**
   * Informações públicas localizadas sobre o torneio visíveis para o jogador.
   */
  externalDetails: ExternalDetailsEntity[];
}

Exemplo de assinatura

// Escute o cancelamento de torneios (transmissão)
const subId = sdk.Events.subscribe('tournaments:on:canceled', (data, raw) => {
  console.log('Torneio cancelado:', data.tournamentId);
  // Você pode usar externalDetails para renderizar cópia localizada na interface do usuário
};

Estrutura de dados de eventos do jogador do torneio vencedor​

interface TournamentPlayerWonEventData extends BaseEventData {
  earnedRewards?: { [key: string]: Reward };
  externalDetails: ExternalDetailsEntity[];
  industry: TournamentIndustryTypeEnum;
  leaderboardRewards: LeaderboardReward[];
  maxNumberOfBets: number;
  optIn: boolean;
  timePeriod?: TimePeriodType;
  tournamentDescription: string;
  tournamentId: string;
  tournamentName: string;
  tournamentType: TournamentTypeEnum;
  leaderboard: {
    position: number;
  };
}

Estrutura de dados do evento de torneios atualizados​

interface TournamentsUpdatedEventData extends BaseEventData {
  tournament: Omit<TournamentEventData, 'tournamentId'>[];
  leaderboard: Omit<PlayerLeaderboard & { rankId: string }, 'leaderboardRewards'>[];
  timestamp: number;
}

Estrutura de dados do evento de atualização da tabela de classificação do jogador​

interface PlayerLeaderboardUpdatedEventData extends BaseEventData {
  tournaments: {
    tournamentId: string;
    position: number;
    score: number;
    spinsLeft: number;
    type: TournamentTypeEnum;
    /**
     * Round only exists for tournaments of type TournamentTypeEnum.HIGHEST_WIN but can be undefined
     * under certain conditions.
     *  1- If type is TournamentTypeEnum.MOST_POINTS
     *  2- If type is TournamentTypeEnum.HIGHEST_WIN, and the player does not have any winning rounds
     */
    round?: RoundInfo;
  }[];
  timestamp: number;
}

Estrutura de dados do evento de jogadas restantes vazias​

interface SpinsLeftEmptyEventData extends BaseEventData {
  playerId: string;
  tournament: { _id: string } & Omit<TournamentEventData, 'tournamentId'>;
}

Estrutura da tabela de classificação do torneio pronta​

type TournamentLeaderboardReady = {
  tournamentId: string;
  externalDetails: ({ elegibilityDisplayName?: string } & TranslationType)[];
  leaderboardRewards: LeaderboardReward[];
  eligibility: TournamentEligibilityType;
};

Eventos de CRM​

ConstanteNome do EventoDescriçãoTipoTipo de GarantiaPropriedades
CRM.ON_ONSITE_NOTIFICATION_ARRIVEmessageGateway:on:sendOnSiteNotificationEventos de notificações no localDiretoBEST_EFFORTmsg: { type: string, contentHtml: string, language: string }, playerId: string
CRM.ON_RICH_INBOX_NOTIFICATIONmessageGateway:on:sendRichInboxNotificationNotifique o jogador sobre uma mensagem da Caixa de Entrada Rica que chegou.DiretoBEST_EFFORTmessage: RichInboxMessage, playerId: string, timestamp: number

Estrutura de dados do evento de notificação no local​

interface OnSiteNotificationEventData extends BaseEventData {
  msg: {
    type: string;
    contentHtml: string;
    language: string;
  };
  playerId: string;
}

Estrutura de dados do evento de notificação da Caixa de Entrada Rica​

interface RichInboxMessage {
  id: string;
  title: string;
  content: string;
  createdAt: Date;
}

interface RichInboxMessageEventData extends BaseEventData {
  message: RichInboxMessage;
  playerId: string;
  timestamp: number;
}
Exemplo​
// Assine os eventos de notificação da caixa de entrada rica
sdk.Events.subscribe(EVENTS.CRM.ON_RICH_INBOX_NOTIFICATION, (data) => {
  console.log('Nova mensagem da caixa de entrada rica chegou:');
  console.log('Título:', data.message.title);
  console.log('Conteúdo:', data.message.content);
});

Eventos do Processador de Recompensas​

ConstanteNome do EventoDescriçãoTipoTipo de GarantiaPropriedades
REWARD_PROCESSOR.ON_MANUAL_REWARD_AWARDEDrewardProcessor:on:manualRewardAwardedRecompensa manual concedida ao jogador pelo Painel AdministrativoDiretoFIRE_FORGETplayerId: string, rewardType: RewardTypeEnum, earnedReward: Reward (by type), rewardId: string, `source: 'manual''automatic', timestamp: number, groupId?: string`
REWARD_PROCESSOR.ON_REWARD_CLAIMED_BY_ADMINrewardProcessor:on:claimRewardAdminRecompensa reivindicada por um operador administrativoDiretoFIRE_FORGETplayerId: string, rewardType: RewardTypeEnum, rewardId: string, `source: 'manual''automatic', timestamp: number, groupId?: string`
REWARD_PROCESSOR.ON_REWARD_CANCELLEDrewardProcessor:on:rewardCancelledRecompensa cancelada por um operador administrativoDiretoFIRE_FORGETplayerId: string, rewardType: RewardTypeEnum, rewardId: string, `source: 'manual''automatic', timestamp: number, groupId?: string`
REWARD_PROCESSOR.ON_BONUS_REWARD_GRANTEDrewardProcessor:on:bonusRewardGrantedEvento disparado quando uma bonificação é concedida e vinculada a uma recompensaDiretoFIRE_FORGETplayerId: string, rewardId: string, rewardType: RewardTypeEnum.BONUS_OFFER, groupId: string, bonusOfferId: string, currency?: string

Estrutura de Dados do Evento de Recompensa Manual Concedida​

// União discriminada por rewardType
// Carga de evento
interface ManualRewardAwardedEventData_Tokens {
  playerId: string;
  rewardType: RewardTypeEnum.TOKENS; // 'tokens'
  earnedReward: TokensReward;
  rewardId: string;
  source: 'manual' | 'automatic';
  timestamp: number;
  groupId?: string;
}

interface ManualRewardAwardedEventData_BonusOffer {
  playerId: string;
  rewardType: RewardTypeEnum.BONUS_OFFER; // 'bonus_offer'
  earnedReward: BonusOfferReward;
  rewardId: string;
  source: 'manual' | 'automatic';
  timestamp: number;
  groupId?: string;
}

interface ManualRewardAwardedEventData_LevelBooster {
  playerId: string;
  rewardType: RewardTypeEnum.LEVEL_BOOSTER; // 'level_booster'
  earnedReward: LevelBoosterReward;
  rewardId: string;
  source: 'manual' | 'automatic';
  timestamp: number;
  groupId?: string;
}

interface ManualRewardAwardedEventData_MissionBooster {
  playerId: string;
  rewardType: RewardTypeEnum.MISSION_BOOSTER; // 'mission_booster'
  earnedReward: MissionBoosterReward;
  rewardId: string;
  source: 'manual' | 'automatic';
  timestamp: number;
  groupId?: string;
}

interface ManualRewardAwardedEventData_TokenBooster {
  playerId: string;
  rewardType: RewardTypeEnum.TOKEN_BOOSTER; // 'token_booster'
  earnedReward: TokenBoosterReward;
  rewardId: string;
  source: 'manual' | 'automatic';
  timestamp: number;
  groupId?: string;
}

interface ManualRewardAwardedEventData_External {
  playerId: string;
  rewardType: RewardTypeEnum.EXTERNAL; // 'external'
  earnedReward: ExternalReward;
  rewardId: string;
  source: 'manual' | 'automatic';
  timestamp: number;
  groupId?: string;
}

// União usada pelo evento
// type ManualRewardAwardedEventData =
//   | ManualRewardAwardedEventData_Tokens
//   | ManualRewardAwardedEventData_BonusOffer
//   | ManualRewardAwardedEventData_LevelBooster
//   | ManualRewardAwardedEventData_MissionBooster
//   | ManualRewardAwardedEventData_TokenBooster
//   | ManualRewardAwardedEventData_External;

Estrutura de Dados de Evento de Concessão de Recompensa Bônus​

interface BonusRewardGranted extends BaseEventData {
  playerId: string;
  rewardId: string;
  rewardType: RewardTypeEnum.BONUS_OFFER;
  groupId: string;
  /**
   * Identificador de oferta bônus, retornado no evento Bônus Concedido
   * propagado pelo operador quando a concessão do bônus é
   * confirmada.
   */
  bonusOfferId: string;
  currency?: string;
}
Tipo de Recompensa Enum​
enum RewardTypeEnum {
  TOKENS = 'tokens',
  BONUS_OFFER = 'bonus_offer',
  LEVEL_BOOSTER = 'level_booster',
  MISSION_BOOSTER = 'mission_booster',
  TOKEN_BOOSTER = 'token_booster',
  EXTERNAL = 'external',
  MINI_GAME = 'mini_game',
}
Estruturas de Recompensa Ganhas​
// Campos de base compartilhados para recompensas de impulsionador
interface BaseReward {
  type: RewardTypeEnum;
  translations?: { language: string; description: string }[];
  level: number;
  activation: string;
  boosterRate: number;
  expirationValidityTime?: { timeType: string };
  timeFrame: string; // duração ISO8601
  termsAndConditions?: { language: string; description: string };
}

interface TokensReward extends Pick<BaseReward, 'type'> {
  type: RewardTypeEnum.TOKENS;
  amount: number;
}

interface BonusOfferReward extends Pick<BaseReward, 'type'> {
  type: RewardTypeEnum.BONUS_OFFER;
  bonusByCurrency: {
    [currency: string]: {
      name: string;
      bonusOfferId: string;
    };
  };
}

interface LevelBoosterReward extends BaseReward {
  type: RewardTypeEnum.LEVEL_BOOSTER;
}

interface MissionBoosterReward extends BaseReward {
  type: RewardTypeEnum.MISSION_BOOSTER;
}

interface TokenBoosterReward extends BaseReward {
  type: RewardTypeEnum.TOKEN_BOOSTER;
}

interface ExternalReward extends Pick<BaseReward, 'type'> {
  type: RewardTypeEnum.EXTERNAL;
  imageUrl: string;
  description: string;
}
Exemplo​
// Assine-se a eventos de recompensa manual atribuída
const subId = rtmEvents.subscribe('rewardProcessor:on:manualRewardAwarded', (data, raw) => {
  // Campos comuns
  console.log(data.playerId, data.rewardType, data.rewardId, data.source, data.timestamp, data.groupId);

  // Reduza por tipo de recompensa
  switch (data.rewardType) {
    case 'tokens':
      console.log('Tokens concedidos:', data.earnedReward.amount);
      break;
    case 'bonus_offer':
      console.log('Moedas da oferta bônus:', Object.keys(data.earnedReward.bonusByCurrency));
      break;
    case 'level_booster':
    case 'mission_booster':
    case 'token_booster':
      console.log('Taxa do impulsionador:', data.earnedReward.boosterRate);
      break;
    case 'external':
      console.log('Descrição da recompensa externa:', data.earnedReward.description);
      break;
  }
});

Interfaces Relacionadas​

SubscriptionOptions​

Interface para configurar assinaturas de eventos.

interface SubscriptionOptions {
  once?: boolean;
  timeout?: number;
  filter?: (data: any) => boolean;
  maxRetries?: number;
  autoAck?: boolean;
}
PropriedadeTipoDescrição
onceboolean (opcional)Se true, a assinatura será removida automaticamente após o recebimento do primeiro evento
timeoutnumber (opcional)Tempo em milissegundos após o qual a assinatura será removida automaticamente se nenhum evento for recebido
filtroFunção (opcional)Uma função que recebe os dados do evento e retorna um valor booleano indicando se o evento deve ser processado
maxRetriesnúmero (opcional)Número máximo de tentativas para o processamento de eventos com falha
autoAckbooleano (opcional)Se true, os eventos serão confirmados automaticamente. O padrão é false

SDKEventListener​

Definição de tipo para os retornos de chamada do ouvinte de eventos.

type SDKEventListener<T extends keyof EventTypeMap> = (
  data: EventTypeMap[T],
  internalRawEvent: InternalRawEvent<T>
) => void;
ParâmetroTipoDescrição
dataEventTypeMap[T]Os dados do evento específicos para o tipo de evento
internalRawEventInternalRawEvent<T>Os dados brutos do evento recebidos do servidor

InternalRawEvent​

Interface que representa os dados brutos do evento recebidos do servidor.

interface InternalRawEvent<T extends keyof EventTypeMap> {
  id: string;
  event: T;
  data: EventTypeMap[T];
  timestamp: number;
  guaranteeType: MessagingServiceGuaranteeType;
}
PropriedadeTipoDescrição
idTipo stringO identificador único do evento
eventosTO nome do evento
dataEventTypeMap[T]Os dados do evento
timestampTipo numberO carimbo de data/hora quando o evento foi gerado
garantiaTipoTipoGarantiaServiçoMensagemO tipo de garantia do evento

TipoGarantiaServiçoMensagem​

Um enum definindo diferentes níveis de garantia para a entrega de mensagens.

enum TipoGarantiaServiçoMensagem {
  ENVIO_SIMPLES = 'ENVIO_SIMPLES',
  MELHOR_ESFORÇO = 'MELHOR_ESFORÇO',
  ENTREGA_CONFIÁVEL = 'ENTREGA_CONFIÁVEL',
  RECEBIMENTO_CONFIÁVEL = 'RECEBIMENTO_CONFIÁVEL',
}
Tipo de GarantiaDescrição
ENVIO_SIMPLESA mensagem é entregue ao jogador apenas se estiver conectado. Se desconectado, a mensagem é descartada.
MELHOR_ESFORÇOA mensagem é entregue se conectado. Se desconectado, a mensagem é armazenada e entregue na próxima conexão.
ENTREGA_CONFIÁVELIgual a MELHOR_ESFORÇO, mas aguarda a notificação de confirmação (ACK) antes de marcar como entregue.
RECEBIMENTO_CONFIÁVELMesmo que BEST_EFFORT, mas o microserviço de origem é notificado quando a mensagem é entregue.

EmitterTypeMap​

Um mapeamento dos nomes de eventos de emissor para seus tipos de dados correspondentes.

interface EmitterTypeMap {
  'enviar:ack': AckMessageEmitter;
  'enviar:analytics:evento': AnalyticsTrackingEventEmitter;
}
Nome do EventoTipo de DadoDescrição
enviar:ackAckMessageEmitterEmissor de mensagem de confirmação para confirmar o recebimento de eventos
enviar:analytics:eventoAnalyticsTrackingEventEmitterEmissor de evento de rastreamento de análise

AckMessageEmitter​

Interface para mensagens de confirmação.

interface AckMessageEmitter {
  mensagemId: string;
}
PropriedadeTipoDescrição
mensagemIdTipo stringO ID da mensagem sendo confirmada

AnalyticsTrackingEventEmitter​

Interface para eventos de rastreamento de análise.

interface AnalyticsTrackingEventEmitter {
  propriedades: Record<string, any>;
}
PropriedadeTipoDescrição
nomeEventoTipo stringO nome do evento de análise
propriedadesRecord<string, any>Propriedades adicionais para o evento de análise