SDK FastComments JavaScript/TypeScript

Ceci est le SDK officiel JavaScript/TypeScript pour FastComments.

Gérez les commentaires, les utilisateurs, le SSO et la modération depuis Node.js ou le navigateur.

Dépôt

Agents de codage IA

Donnez à votre agent de codage le contexte FastComments dont il a besoin - widgets, configuration, SSO sécurisé, l’API REST et les SDK :

npx skills add fastcomments/skills

Fonctionne avec Claude Code, Codex, Cursor, Copilot, Gemini et tout autre agent pris en charge par le skills CLI supports.

Installation

npm install fastcomments-sdk

Documentation de l'API

Référence complète de l'API: docs/api/README.md

Compatibilité Navigateur vs Serveur

Ce SDK utilise des points d'entrée doubles pour garantir une compatibilité optimale et éviter les erreurs d'exécution :

fastcomments-sdk/browser - Version sécurisée pour les navigateurs avec fetch natif
fastcomments-sdk/server - Version complète pour Node.js avec prise en charge du SSO
fastcomments-sdk (par défaut) - Contient uniquement des types, sûr à importer n'importe où

Utilisation

Ce SDK fournit des points d'entrée distincts pour les environnements navigateur et serveur afin d'assurer une compatibilité et une sécurité optimales :

Utilisation dans le navigateur (côté client)

Pour les applications front-end/navigateurs, utilisez l'export sécurisé pour le navigateur qui exclut les dépendances Node.js :

// Import sécurisé pour le navigateur (sans dépendances Node.js)
import { createFastCommentsBrowserSDK } from 'fastcomments-sdk/browser';

// Créer une instance du SDK pour le navigateur
const sdk = createFastCommentsBrowserSDK({
  basePath: 'https://fastcomments.com' // optionnel, valeur par défaut : https://fastcomments.com
});

// Utiliser les API publiques (pas de clé API nécessaire - sûr pour les navigateurs)
const comments = await sdk.publicApi.getCommentsPublic({ 
  tenantId: 'your-tenant-id',
  urlId: 'page-url-id'
});

Utilisation côté serveur (Node.js)

Pour les applications serveur/back-end, utilisez le SDK complet avec les fonctionnalités SSO et d'authentification :

// Import côté serveur (inclut SSO et conçu pour fonctionner avec NodeJS)
import { createFastCommentsSDK } from 'fastcomments-sdk/server';

// Créer une instance du SDK pour le serveur
const sdk = createFastCommentsSDK({
  apiKey: 'your-api-key', // Gardez ceci secret sur le serveur !
  basePath: 'https://fastcomments.com' // optionnel, valeur par défaut : https://fastcomments.com
});

// Utiliser les API sécurisées avec votre clé API
const comments = await sdk.defaultApi.getComments({ 
  tenantId: 'your-tenant-id',
  urlId: 'page-url-id'
});

Import de types uniquement

Si vous avez seulement besoin des types TypeScript (aucun code d'exécution), utilisez l'import par défaut :

// Types uniquement (aucune dépendance d'exécution - sûr partout)
import type { 
  PublicComment, 
  CreateCommentParams, 
  GetCommentsPublic200Response 
} from 'fastcomments-sdk';

Utilisation des classes d'API individuelles

Environnement navigateur

import { PublicApi, Configuration } from 'fastcomments-sdk/browser';

const config = new Configuration({
  basePath: 'https://fastcomments.com'
});

const publicApi = new PublicApi(config);

Environnement serveur

import { DefaultApi, PublicApi, Configuration } from 'fastcomments-sdk/server';

const config = new Configuration({
  apiKey: 'your-api-key',
  basePath: 'https://fastcomments.com'
});

const defaultApi = new DefaultApi(config);
const publicApi = new PublicApi(config);

APIs Publiques vs Sécurisées

Le SDK fournit ces classes d'API :

DefaultApi - Points de terminaison sécurisés qui nécessitent votre API key pour l'authentification. Utilisez-les pour les opérations côté serveur.
PublicApi - Points de terminaison publics accessibles sans API key. Ils peuvent être appelés directement depuis des navigateurs, appareils mobiles, etc.
ModerationApi - Points de terminaison du tableau de bord des modérateurs (modération des commentaires, bannissements, badges, facteur de confiance, recherche). Authentifié par la session du modérateur ; passez le paramètre de requête sso pour les modérateurs authentifiés via SSO.
HiddenApi - Points de terminaison internes/admin pour des cas d'utilisation avancés.

Exemple : Utilisation de l'API publique (compatible navigateur)

import { PublicApi } from 'fastcomments-sdk/browser';

const publicApi = new PublicApi();

// Récupère les commentaires d'une page (pas d'API key requise)
const response = await publicApi.getCommentsPublic({
  tenantId: 'your-tenant-id',
  urlId: 'page-url-id'
});

Exemple : Utilisation de l'API Default (côté serveur uniquement)

import { DefaultApi, Configuration } from 'fastcomments-sdk/server';

const config = new Configuration({
  apiKey: 'your-api-key' // Gardez ceci secret!
});
const defaultApi = new DefaultApi(config);

// Récupère les commentaires avec un accès administrateur complet
const response = await defaultApi.getComments({
  tenantId: 'your-tenant-id',
  urlId: 'page-url-id'
});

Exemple : Utilisation de l'API de modération

import { createFastCommentsSDK } from 'fastcomments-sdk/server';

const sdk = createFastCommentsSDK({ /* basePath, etc. */ });

// Appels authentifiés par le modérateur (cookie de session, ou passez `sso` pour un modérateur SSO).
const comments = await sdk.moderationApi.getApiComments({
  tenantId: 'your-tenant-id'
});

await sdk.moderationApi.postSetCommentSpamStatus({
  commentId: 'comment-id',
  spam: true
});

Intégration SSO (Authentification Unique)

FastComments prend en charge le SSO pour s'intégrer à votre système d'authentification utilisateur existant. La fonctionnalité SSO n'est disponible que dans l'export côté serveur car elle nécessite les fonctionnalités crypto de Node.js.

SSO simple (côté serveur uniquement)

Le SSO simple doit être généré côté serveur et envoyé au client :

// Code côté serveur (Node.js/backend)
import { FastCommentsSSO, PublicApi } from 'fastcomments-sdk/server';

// Créez un SSO simple en utilisant l'assistant intégré  
const userData = {
  username: 'john_doe',
  email: 'john@example.com',
  displayName: 'John Doe',
  avatar: 'https://example.com/avatar.jpg'
};

const sso = FastCommentsSSO.createSimple(userData, {
  loginURL: '/login',
  logoutURL: '/logout'
});

const ssoToken = sso.createToken();

// Envoyez ssoToken à votre code côté client
// Le code côté client peut ensuite utiliser ce jeton avec le SDK pour navigateur

SSO sécurisé (côté serveur, recommandé)

Le SSO sécurisé doit être implémenté côté serveur et offre une meilleure sécurité :

// Code côté serveur (Node.js/backend)
import { FastCommentsSSO, PublicApi } from 'fastcomments-sdk/server';

// Créez un SSO sécurisé en utilisant l'assistant intégré
const userData = {
  id: 'user-123',
  email: 'john@example.com',
  username: 'john_doe',
  displayName: 'John Doe',
  avatar: 'https://example.com/avatar.jpg',
  isAdmin: false,
  isModerator: false
};

const sso = FastCommentsSSO.createSecure('your-api-key', userData, {
  loginURL: '/login',
  logoutURL: '/logout'
});

const ssoConfig = sso.prepareToSend();

// À utiliser avec les appels API côté serveur
const publicApi = new PublicApi();
const response = await publicApi.getCommentsPublic({
  tenantId: 'your-tenant-id',
  urlId: 'page-url-id',
  sso: JSON.stringify(ssoConfig)
});

// Ou envoyez ssoConfig au client pour une utilisation dans le navigateur

Utiliser le SSO depuis le navigateur (avec un jeton généré par le serveur)

// Code côté client (navigateur)
import { PublicApi } from 'fastcomments-sdk/browser';

// Récupérez le jeton SSO depuis votre endpoint serveur
const ssoToken = await fetch('/api/sso-token').then(r => r.json());

const publicApi = new PublicApi();
const response = await publicApi.getCommentsPublic({
  tenantId: 'your-tenant-id',
  urlId: 'page-url-id',
  sso: ssoToken // Utilisez le jeton SSO généré par le serveur
});

SSO avec création de commentaire

// Côté serveur : créer le SSO et le commentaire
import { FastCommentsSSO, PublicApi } from 'fastcomments-sdk/server';

const sso = FastCommentsSSO.createSecure('your-api-key', userData);
const ssoConfig = sso.prepareToSend();

const response = await publicApi.createCommentPublic({
  tenantId: 'your-tenant-id',
  urlId: 'page-url-id',
  broadcastId: 'unique-broadcast-id',
  commentData: {
    comment: 'This is my comment',
    date: Date.now(),
    commenterName: 'John Doe',
    url: 'https://example.com/page',
    urlId: 'page-url-id'
  },
  sso: JSON.stringify(ssoConfig)
});

Cas d'utilisation courants

Récupérer les commentaires d'une page

const comments = await sdk.publicApi.getCommentsPublic({
  tenantId: 'your-tenant-id',
  urlId: 'article-123'
});

Créer un commentaire

const newComment = await sdk.publicApi.createCommentPublic({
  createCommentParams: {
    tenantId: 'your-tenant-id',
    urlId: 'article-123',
    comment: 'Great article!',
    commenterName: 'John Doe',
    commenterEmail: 'john@example.com'
  }
});

Voter sur un commentaire

const voteResponse = await sdk.publicApi.voteComment({
  voteBodyParams: {
    commentId: 'comment-id',
    direction: 1 // 1 pour un vote positif, -1 pour un vote négatif
  }
});

Gestion des utilisateurs (Nécessite une clé API)

// Rechercher des utilisateurs (nécessite DefaultApi)
const users = await sdk.defaultApi.searchUsers({
  tenantId: 'your-tenant-id',
  urlId: 'page-id',
  usernameStartsWith: 'john'
});

Événements en direct (Mises à jour en temps réel)

Abonnez-vous aux événements en direct pour recevoir des mises à jour en temps réel concernant les commentaires, les votes et autres activités.

Événements au niveau de la page

Écoutez les événements en direct sur une page spécifique (commentaires, votes, etc.) :

import { subscribeToChanges, LiveEvent, LiveEventType } from 'fastcomments-sdk/browser';

const config = {
  tenantId: 'your-tenant-id',
  urlId: 'page-url-id',
};

// Subscribe to live events for a page
const subscription = subscribeToChanges(
  config,
  'your-tenant-id', // tenantIdWS
  'page-url-id',    // urlIdWS  
  'user-session-id', // userIdWS (get this from getComments response)
  (event: LiveEvent) => {
    console.log('Live event received:', event);
    
    switch (event.type) {
      case LiveEventType.new_comment:
        console.log('New comment:', event.comment);
        // Mettez à jour votre interface avec le nouveau commentaire
        break;
      case LiveEventType.new_vote:
        console.log('New vote:', event.vote);
        // Mettez à jour les compteurs de votes dans votre interface
        break;
      case LiveEventType.updated_comment:
        console.log('Comment updated:', event.comment);
        break;
      default:
        console.log('Other event type:', event.type);
    }
    
    return true; // Retournez true si l'événement a été traité
  },
  (isConnected: boolean) => {
    console.log('Connection status:', isConnected ? 'Connected' : 'Disconnected');
  }
);

// Close the subscription when done
subscription.close();

S'abonner aux événements utilisateur

Écoutez les événements spécifiques à un utilisateur (notifications, mentions, etc.) :

import { subscribeToUserFeed, LiveEvent, LiveEventType } from 'fastcomments-sdk/browser';

const userConfig = {
  userIdWS: 'user-session-id', // Get this from getComments response
};

// Subscribe to user's personal feed
const userSubscription = subscribeToUserFeed(
  userConfig,
  (event: LiveEvent) => {
    console.log('User event received:', event);
    
    switch (event.type) {
      case LiveEventType.notification:
        console.log('New notification:', event.notification);
        // Affichez la notification dans votre interface
        break;
      case LiveEventType.notification_update:
        console.log('Notification updated:', event.notification);
        break;
      default:
        console.log('Other user event:', event.type);
    }
    
    return true;
  },
  (isConnected: boolean) => {
    console.log('User feed connection:', isConnected ? 'Connected' : 'Disconnected');
  }
);

// Close when done
userSubscription.close();

Obtenir userIdWS

Le paramètre userIdWS est requis pour les événements en direct et peut être obtenu à partir des réponses de l'API :

const response = await sdk.publicApi.getCommentsPublic({
  tenantId: 'your-tenant-id',
  urlId: 'page-id'
});

// Extract userIdWS from the response
const userIdWS = response.data?.userSessionInfo?.userIdWS;

if (userIdWS) {
  // Now you can subscribe to live events
  const subscription = subscribeToChanges(config, tenantIdWS, urlIdWS, userIdWS, handleEvent);
}

Identifiants de diffusion

Vous verrez qu'il faut transmettre un broadcastId dans certains appels d'API. Quand vous recevez des événements, vous récupérerez cet ID, ce qui vous permet d'ignorer l'événement si vous comptez appliquer les changements de manière optimiste côté client (ce que vous voudrez probablement faire car cela offre la meilleure expérience). Passez un UUID ici. L'ID doit être suffisamment unique pour ne pas apparaître deux fois durant une session de navigateur.

import { v4 as uuidv4 } from 'uuid';

const response = await sdk.publicApi.createCommentPublic({
  createCommentParams: {
    tenantId: 'your-tenant-id',
    urlId: 'page-id',
    comment: 'My comment',
    broadcastId: uuidv4() // ID unique pour cette opération
  }
});

Gestion des erreurs

try {
  const comments = await sdk.publicApi.getCommentsPublic({
    tenantId: 'your-tenant-id',
    urlId: 'page-id'
  });
} catch (error) {
  if (error.response?.status === 404) {
    console.log('Page not found');
  } else {
    console.error('API Error:', error.message);
  }
}

createAgentTenant

Crée un nouveau compte d'essai pour un agent IA sans inscription humaine. Aucune clé API n'est nécessaire pour appeler cette fonction.

La réponse contient l'identifiant du locataire, une clé API qui fonctionne immédiatement avec l'API REST et le serveur MCP, ainsi qu'une URL de réclamation. Donnez l'URL de réclamation à la personne pour laquelle vous travaillez : l'ouvrir tout en étant connecté à FastComments associe le compte à cette personne. Les comptes non réclamés, ainsi que leurs clés, sont supprimés 72 heures après leur création. Jusqu'à ce qu'ils soient réclamés, le compte bénéficie des limites d'essai standard.

Paramètres

Nom	Type	Obligatoire	Description
createAgentTenantBody	CreateAgentTenantBody	Oui

Réponse

Returns: CreateAgentTenantResponse

Exemple

createAgentTenant Exemple

Copy

const tenantBody: CreateAgentTenantBody = {
  name: "Acme Corp",
  domain: "acme.example.com",
  contactEmail: "admin@acme.example.com", // optional
  planId: 3 // optional
};
const result: CreateAgentTenantResponse = await createAgentTenant(tenantBody);

aggregate

Aggregates documents by grouping them (if groupBy is provided) and applying multiple operations. Different operations (e.g. sum, countDistinct, avg, etc.) are supported.

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
aggregationRequest	AggregationRequest	Oui
parentTenantId	string	Non
includeStats	boolean	Non

Réponse

Retourne : AggregateResponse

Exemple

Exemple d'agrégation

Copy

const tenantId: string = "tenant-12345";
const aggregationRequest: AggregationRequest = {
  predicates: [
    {
      field: "status",
      operator: "eq",
      value: { type: "string", value: "approved" }
    }
  ],
  operations: [
    { type: "count", field: "commentId" }
  ],
  sort: { field: "createdAt", direction: "desc" }
};
const parentTenantId: string = "parent-001";
const includeStats: boolean = true;
const result: AggregateResponse = await aggregate(
  tenantId,
  aggregationRequest,
  parentTenantId,
  includeStats
);

getAuditLogs

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
limit	number	Non
skip	number	Non
order	SORTDIR	Non
after	number	Non
before	number	Non
username	string	Non
ip	string	Non
crudType	string	Non
resourceName	string	Non
targetId	string	Non
target	string	Non
includeManagedTenants	boolean	Non

Réponse

Retourne : GetAuditLogsResponse

Exemple

Exemple getAuditLogs

Copy

async function fetchAuditLogs(): Promise<void> {
  const tenantId: string = "tenant_12345";
  const limit: number = 50;
  const skip: number = 0;
  const order: SORTDIR = { direction: "DESC" };
  const after: number = Date.now() - 86400000; // il y a 1 jour
  const before: number = Date.now();
  const username: string = "alice.smith";
  const ip: string = "198.51.100.23";
  const crudType: string = "CREATE";
  const resourceName: string = "thread";
  const targetId: string = "thread_45678";
  const target: string = "forum_12";
  const includeManagedTenants: boolean = false;
  const logs: GetAuditLogsResponse = await getAuditLogs(
    tenantId,
    limit,
    skip,
    order,
    after,
    before,
    username,
    ip,
    crudType,
    resourceName,
    targetId,
    target,
    includeManagedTenants
  );
  console.log(logs);
}
fetchAuditLogs();

blockFromCommentPublic

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
publicBlockFromCommentParams	PublicBlockFromCommentParams	Oui
sso	string	Non

Réponse

Renvoie : BlockSuccess

Exemple

Exemple blockFromCommentPublic

Copy

async function demoBlock() {
  const tenantId: string = "tenant_9f8b7c";
  const commentId: string = "comment_3e2d1a";
  const blockParams: PublicBlockFromCommentParams = {
    reason: "harassment",
    expiresInHours: 48
  };
  const ssoToken: string = "sso_5g6h7i";
  const resultWithSso: BlockSuccess = await blockFromCommentPublic(tenantId, commentId, blockParams, ssoToken);
  const resultWithoutSso: BlockSuccess = await blockFromCommentPublic(tenantId, commentId, blockParams);
}

unBlockCommentPublic

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
publicBlockFromCommentParams	PublicBlockFromCommentParams	Oui
sso	string	Non

Réponse

Renvoie : UnblockSuccess

Exemple

Exemple unBlockCommentPublic

Copy

const tenantId: string = "c9f1e2a4-5b6d-4f8a-9c2e-123456789abc";
const commentId: string = "d3b2c1a9-8f7e-4d6b-9a0b-987654321def";
const unblockParams: PublicBlockFromCommentParams = {
    reason: "User request resolved",
    moderatorId: "mod-456"
};
const ssoToken: string = "sso-token-789xyz";
const unblockResult: UnblockSuccess = await unBlockCommentPublic(tenantId, commentId, unblockParams, ssoToken);
const unblockResultNoSso: UnblockSuccess = await unBlockCommentPublic(tenantId, commentId, unblockParams);

checkedCommentsForBlocked

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentIds	string	Oui
sso	string	Non

Réponse

Renvoie : CheckBlockedCommentsResponse

Exemple

Exemple checkedCommentsForBlocked

Copy

(async () => {
    const tenantId: string = "tenant_12345";
    const commentIds: string = "cmt_9876,cmt_5432";
    const ssoToken: string = "sso_user_abc123";
    const responseWithSso: CheckBlockedCommentsResponse = await checkedCommentsForBlocked(tenantId, commentIds, ssoToken);
    const responseWithoutSso: CheckBlockedCommentsResponse = await checkedCommentsForBlocked(tenantId, commentIds);
})();

blockUserFromComment

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
blockFromCommentParams	BlockFromCommentParams	Oui
userId	string	Non
anonUserId	string	Non

Réponse

Renvoie : BlockSuccess

Exemple

Exemple blockUserFromComment

Copy

async function demo() {
  const tenantId: string = "tenant-123e4567-e89b-12d3-a456-426614174000";
  const commentId: string = "cmt-9876543210";
  const blockParams: BlockFromCommentParams = {
    reason: "spam",
    durationHours: 24
  };
  const userId: string = "user-abc123";
  const anonUserId: string = "anon-xyz789";
  const result: BlockSuccess = await blockUserFromComment(tenantId, commentId, blockParams, userId, anonUserId);
  console.log(result);
}
demo();

createCommentPublic

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
urlId	string	Oui
broadcastId	string	Oui
commentData	CommentData	Oui
sessionId	string	Non
sso	string	Non

Réponse

Renvoie : SaveCommentsResponseWithPresence

Exemple

Exemple createCommentPublic

Copy

async function runExample() {
  const tenantId: string = "tenant-456";
  const urlId: string = "url-789";
  const broadcastId: string = "broadcast-101112";
  const commentData: CommentData = { text: "This is a comment", userId: "user-123" };
  const sessionId: string = "session-131415";
  const sso: string = "sso-token-xyz";
  const result: SaveCommentsResponseWithPresence = await createCommentPublic(tenantId, urlId, broadcastId, commentData, sessionId, sso);
  const resultNoOpt: SaveCommentsResponseWithPresence = await createCommentPublic(tenantId, urlId, broadcastId, commentData);
}

deleteComment

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
contextUserId	string	Non
isLive	boolean	Non

Réponse

Renvoie : DeleteCommentResult

Exemple

Exemple deleteComment

Copy

async function removeComment(): Promise<void> {
    const tenantId: string = "tenant_12345";
    const commentId: string = "comment_9876";
    const contextUserId: string = "user_42";
    const result: DeleteCommentResult = await deleteComment(tenantId, commentId, contextUserId, true);
    console.log(result);
}
removeComment();

deleteCommentPublic

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
broadcastId	string	Oui
editKey	string	Non
sso	string	Non

Réponse

Renvoie : PublicAPIDeleteCommentResponse

Exemple

Exemple deleteCommentPublic

Copy

(async () => {
  const tenantId: string = "tenant_12345";
  const commentId: string = "cmt_9876";
  const broadcastId: string = "brd_5555";
  const editKey: string = "edit_abc123";
  const sso: string = "sso_token_xyz";
  const resultWithoutOptional: PublicAPIDeleteCommentResponse = await deleteCommentPublic(tenantId, commentId, broadcastId);
  const resultWithOptional: PublicAPIDeleteCommentResponse = await deleteCommentPublic(tenantId, commentId, broadcastId, editKey, sso);
})();

deleteCommentVote

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
commentId	string	Yes
voteId	string	Yes
urlId	string	Yes
broadcastId	string	Yes
editKey	string	No
sso	string	No

Réponse

Retourne : VoteDeleteResponse

Exemple

Exemple deleteCommentVote

Copy

const tenantId: string = "tenant_12345";
const commentId: string = "cmt_9876";
const voteId: string = "vote_555";
const urlId: string = "url_abcde";
const broadcastId: string = "brd_2023";
const editKey: string = "edit_abc123"; // facultatif
const ssoToken: string = "sso_token_xyz"; // facultatif
// Appel avec uniquement les paramètres requis et un paramètre facultatif
const deleteResult: VoteDeleteResponse = await deleteCommentVote(
  tenantId,
  commentId,
  voteId,
  urlId,
  broadcastId,
  editKey
);
// Appel avec les deux paramètres facultatifs
const deleteResultWithSSO: VoteDeleteResponse = await deleteCommentVote(
  tenantId,
  commentId,
  voteId,
  urlId,
  broadcastId,
  editKey,
  ssoToken
);

flagComment

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
userId	string	Non
anonUserId	string	Non

Réponse

Renvoie : FlagCommentResponse

Exemple

flagComment Exemple

Copy

(async () => {
  const tenantId: string = "acme-corp";
  const commentId: string = "comment-20230915-001";
  const userId: string = "user-42";
  const anonUserId: string = "anon-abc123";
  const response: FlagCommentResponse = await flagComment(tenantId, commentId, userId, anonUserId);
  console.log(response);
})();

getComment

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Retourne : APIGetCommentResponse

Exemple

Exemple getComment

Copy

async function fetchComment(): Promise<void> {
  const tenantId: string = "acme-corp";
  const commentId: string = "cmt_1234567890";
  const response: APIGetCommentResponse = await getComment(tenantId, commentId);
  const comment: APIComment | undefined = response.comment;
  // Démonstration des champs optionnels
  const badgeInfo: CommentUserBadgeInfo | undefined = comment?.user?.badge;
  const hashtags: CommentUserHashTagInfo[] | undefined = comment?.user?.hashtags;
  const mentions: CommentUserMentionInfo[] | undefined = comment?.user?.mentions;
  const meta: APICommentBaseMeta | undefined = comment?.meta;
  console.log(comment?.id, badgeInfo?.type);
}
fetchComment();

getComments

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
page	number	Non
limit	number	Non
skip	number	Non
asTree	boolean	Non
skipChildren	number	Non
limitChildren	number	Non
maxTreeDepth	number	Non
urlId	string	Non
userId	string	Non
anonUserId	string	Non
contextUserId	string	Non
hashTag	string	Non
parentId	string	Non
direction	SortDirections	Non
fromDate	number	Non
toDate	number	Non

Réponse

Retourne : APIGetCommentsResponse

Exemple

Exemple getComments

Copy

async function loadComments(): Promise<void> {
  const tenantId: string = "acme-corp";
  const page: number = 1;
  const limit: number = 50;
  const asTree: boolean = false;
  const direction: SortDirections = "asc";
  const fromDate: number = Date.now() - 30 * 24 * 60 * 60 * 1000; // il y a 30 jours
  const toDate: number = Date.now();
  const commentsResponse: APIGetCommentsResponse = await getComments(
    tenantId,
    page,
    limit,
    undefined,
    asTree,
    undefined,
    undefined,
    undefined,
    undefined,
    undefined,
    undefined,
    undefined,
    undefined,
    undefined,
    direction,
    fromDate,
    toDate
  );
  console.log(commentsResponse);
}

getCommentsPublic

req tenantId urlId

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
urlId	string	Yes
page	number	No
direction	SortDirections	No
sso	string	No
skip	number	No
skipChildren	number	No
limit	number	No
limitChildren	number	No
countChildren	boolean	No
fetchPageForCommentId	string	No
includeConfig	boolean	No
countAll	boolean	No
includei10n	boolean	No
locale	string	No
modules	string	No
isCrawler	boolean	No
includeNotificationCount	boolean	No
asTree	boolean	No
maxTreeDepth	number	No
useFullTranslationIds	boolean	No
parentId	string	No
searchText	string	No
hashTags	Array	No
userId	string	No
customConfigStr	string	No
afterCommentId	string	No
beforeCommentId	string	No

Réponse

Retourne : GetCommentsResponseWithPresencePublicComment

Exemple

Exemple getCommentsPublic

Copy

async function loadComments(): Promise<void> {
  const tenantId: string = "tenant-42",
        urlId: string = "post-2023-09-15",
        page: number = 1,
        direction: SortDirections = "desc",
        limit: number = 30,
        includeConfig: boolean = true,
        locale: string = "en-US",
        isCrawler: boolean = false,
        asTree: boolean = true,
        maxTreeDepth: number = 2,
        searchText: string = "fastcomments",
        hashTags: string[] = ["fastcomments","typescript"],
        userId: string = "user-123";
  const result: GetCommentsResponseWithPresencePublicComment = await getCommentsPublic(
    tenantId,
    urlId,
    page,
    direction,
    undefined,
    undefined,
    undefined,
    limit,
    undefined,
    undefined,
    undefined,
    includeConfig,
    undefined,
    undefined,
    locale,
    undefined,
    isCrawler,
    undefined,
    asTree,
    maxTreeDepth,
    undefined,
    undefined,
    searchText,
    hashTags,
    userId
  );
}

getCommentText

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
commentId	string	Yes
editKey	string	No
sso	string	No

Réponse

Retourne : PublicAPIGetCommentTextResponse

Exemple

Exemple getCommentText

Copy

const tenantId: string = "acme-corp-tenant";
const commentId: string = "comment-987654321";
const editKey: string = "edit-key-abc123";
const sso: string = "sso-token-xyz789";
const commentWithEdit: PublicAPIGetCommentTextResponse = await getCommentText(
  tenantId,
  commentId,
  editKey,
  sso
);
const commentBasic: PublicAPIGetCommentTextResponse = await getCommentText(
  tenantId,
  commentId
);

getCommentVoteUserNames

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
dir	number	Oui
sso	string	Non

Réponse

Renvoie : GetCommentVoteUserNamesSuccessResponse

Exemple

Exemple getCommentVoteUserNames

Copy

async function example() {
  const tenantId: string = 'tenant-9876';
  const commentId: string = 'comment-abc123';
  const dir: number = 1;
  const ssoToken: string = 'sso-xyz789';
  const resultWithSso: GetCommentVoteUserNamesSuccessResponse = await getCommentVoteUserNames(tenantId, commentId, dir, ssoToken);
  const resultWithoutSso: GetCommentVoteUserNamesSuccessResponse = await getCommentVoteUserNames(tenantId, commentId, dir);
}

lockComment

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
broadcastId	string	Oui
sso	string	Non

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple de lockComment

Copy

async function demoLockComment() {
  const tenantId: string = "tenant_12345";
  const commentId: string = "cmt_9876";
  const broadcastId: string = "brd_5555";
  const ssoToken: string = "sso_user_abc";
  const resultWithSso: APIEmptyResponse = await lockComment(tenantId, commentId, broadcastId, ssoToken);
  const resultWithoutSso: APIEmptyResponse = await lockComment(tenantId, commentId, broadcastId);
}
demoLockComment();

pinComment

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
sso	string	No

Réponse

Retourne : ChangeCommentPinStatusResponse

Exemple

Exemple de pinComment

Copy

async function demoPinComment() {
  const tenantId: string = "tenant_12345";
  const commentId: string = "cmt_98765";
  const broadcastId: string = "brd_54321";
  const resultWithoutSso: ChangeCommentPinStatusResponse = await pinComment(tenantId, commentId, broadcastId);
  const ssoToken: string = "sso_abcde12345";
  const resultWithSso: ChangeCommentPinStatusResponse = await pinComment(tenantId, commentId, broadcastId, ssoToken);
}
demoPinComment();

saveComment

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
createCommentParams	CreateCommentParams	Oui
isLive	boolean	Non
doSpamCheck	boolean	Non
sendEmails	boolean	Non
populateNotifications	boolean	Non

Réponse

Retourne : APISaveCommentResponse

Exemple

Exemple saveComment

Copy

const tenantId: string = "tenant_12345";
const commentParams: CreateCommentParams = {
  content: "This is a comment with a mention and a hashtag.",
  userId: "user_987",
  mentions: [
    { userId: "user_123", start: 27, end: 34 }
  ] as CommentUserMentionInfo[],
  hashtags: [
    { tag: "feedback", start: 45, end: 53 }
  ] as CommentUserHashTagInfo[],
  poll: {
    question: "Do you like this feature?",
    options: ["Yes", "No"]
  } as CommentPollInput,
};
const response: APISaveCommentResponse = await saveComment(
  tenantId,
  commentParams,
  true,   // isLive
  true,   // doSpamCheck
  false,  // sendEmails
  true    // populateNotifications
);

saveCommentsBulk

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
createCommentParams	Array	Oui
isLive	boolean	Non
doSpamCheck	boolean	Non
sendEmails	boolean	Non
populateNotifications	boolean	Non

Réponse

Renvoie : Array<SaveCommentsBulkResponse

Exemple

Exemple saveCommentsBulk

Copy

const tenantId: string = "tenant_12345";
const mention1: CommentUserMentionInfo = {
  userId: "user_002",
  start: 10,
  end: 20,
};
const hashtag1: CommentUserHashTagInfo = {
  tag: "news",
  start: 30,
  end: 35,
};
const poll1: CommentPollInput = {
  question: "Did you find this helpful?",
  options: ["Yes", "No"],
};
const commentA: CreateCommentParams = {
  content: "This is a great article!",
  userId: "user_001",
  mentions: [mention1],
  hashtags: [hashtag1],
  poll: poll1,
};
const commentB: CreateCommentParams = {
  content: "I have a question about the topic.",
  userId: "user_003",
};
const createCommentParams: CreateCommentParams[] = [commentA, commentB];
const isLive: boolean = true;
const doSpamCheck: boolean = false;
const sendEmails: boolean = true;
const populateNotifications: boolean = false;
const results: SaveCommentsBulkResponse[] = await saveCommentsBulk(
  tenantId,
  createCommentParams,
  isLive,
  doSpamCheck,
  sendEmails,
  populateNotifications
);

setCommentText

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
commentTextUpdateRequest	CommentTextUpdateRequest	Yes
editKey	string	No
sso	string	No

Réponse

Renvoie : PublicAPISetCommentTextResponse

Exemple

setCommentText Exemple

Copy

(async () => {
  const tenantId: string = "tenant_12345";
  const commentId: string = "cmt_98765";
  const broadcastId: string = "brd_54321";
  const commentTextUpdateRequest: CommentTextUpdateRequest = {
    text: "Revised comment text with additional details."
  };
  const editKey: string = "edit_abc123";
  const sso: string = "sso_token_456def";
  const response: PublicAPISetCommentTextResponse = await setCommentText(
    tenantId,
    commentId,
    broadcastId,
    commentTextUpdateRequest,
    editKey,
    sso
  );
})();

unBlockUserFromComment

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
id	string	Yes
unBlockFromCommentParams	UnBlockFromCommentParams	Yes
userId	string	No
anonUserId	string	No

Réponse

Retourne : UnblockSuccess

Exemple

unBlockUserFromComment Exemple

Copy

(async () => {
  const tenantId: string = "tenant-9f8b7c6d";
  const commentId: string = "comment-4a3b2c1d";
  const params: UnBlockFromCommentParams = {
    reason: "User appealed the block",
    adminNote: "Reviewed and unblocked"
  };
  const userId: string = "user-5e6f7g8h";
  const anonUserId: string = "anon-1a2b3c4d";
  const result: UnblockSuccess = await unBlockUserFromComment(
    tenantId,
    commentId,
    params,
    userId,
    anonUserId
  );
  console.log(result);
})();

unFlagComment

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
id	string	Yes
userId	string	No
anonUserId	string	No

Réponse

Retourne : FlagCommentResponse

Exemple

Exemple de unFlagComment

Copy

async function runExample() {
  const tenantId: string = "acme-corp";
  const commentId: string = "cmt-20230915-001";
  const userId: string = "user-42";
  const unflaggedByUser: FlagCommentResponse = await unFlagComment(tenantId, commentId, userId);
  const unflaggedByAnon: FlagCommentResponse = await unFlagComment(tenantId, commentId, undefined, "anon-xyz");
  console.log(unflaggedByUser, unflaggedByAnon);
}

unLockComment

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
broadcastId	string	Oui
sso	string	Non

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple de unLockComment

Copy

async function demoUnlock() {
  const tenantId: string = "acme-corp";
  const commentId: string = "cmt_1234567890";
  const broadcastId: string = "brd_987654321";
  const ssoToken: string = "sso_abcdef123456";
  const resultWithoutSso: APIEmptyResponse = await unLockComment(tenantId, commentId, broadcastId);
  const resultWithSso: APIEmptyResponse = await unLockComment(tenantId, commentId, broadcastId, ssoToken);
}

unPinComment

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
sso	string	No

Réponse

Retourne : ChangeCommentPinStatusResponse

Exemple

Exemple de unPinComment

Copy

(async () => {
  const tenantId: string = "acme-corp";
  const commentId: string = "comment-20230915-001";
  const broadcastId: string = "broadcast-2023-09-15";
  const ssoToken: string = "sso-abc123";
  const result: ChangeCommentPinStatusResponse = await unPinComment(tenantId, commentId, broadcastId, ssoToken);
  const resultWithoutSso: ChangeCommentPinStatusResponse = await unPinComment(tenantId, commentId, broadcastId);
})();

updateComment

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
updatableCommentParams	UpdatableCommentParams	Oui
contextUserId	string	Non
doSpamCheck	boolean	Non
isLive	boolean	Non

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple de updateComment

Copy

const tenantId: string = "c1a2b3d4-5678-90ab-cdef-1234567890ab";
const commentId: string = "comment-9876543210";
const updateParams: UpdatableCommentParams = {
  content: "Edited comment content",
  isApproved: true
};
const contextUserId: string = "user-11223344";
const doSpamCheck: boolean = true;
const isLive: boolean = false;
const response: APIEmptyResponse = await updateComment(
  tenantId,
  commentId,
  updateParams,
  contextUserId,
  doSpamCheck,
  isLive
);

voteComment

Paramètres

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
urlId	string	Yes
broadcastId	string	Yes
voteBodyParams	VoteBodyParams	Yes
sessionId	string	No
sso	string	No

Réponse

Returns: VoteResponse

Exemple

Exemple voteComment

Copy

async function runVote() {
  const tenantId: string = 'tenant_001';
  const commentId: string = 'cmt_987654';
  const urlId: string = 'url_12345';
  const broadcastId: string = 'brd_56789';
  const voteBody: VoteBodyParams = { direction: 'up' };
  const sessionId: string = 'sess_abc123';
  const sso: string = 'sso_token_xyz';
  const response: VoteResponse = await voteComment(
    tenantId,
    commentId,
    urlId,
    broadcastId,
    voteBody,
    sessionId,
    sso
  );
  console.log(response);
}
runVote();

getCommentsForUser

Paramètres

Nom	Type	Obligatoire
userId	string	No
direction	SortDirections	No
repliesToUserId	string	No
page	number	No
includei10n	boolean	No
locale	string	No
isCrawler	boolean	No

Réponse

Retourne : GetCommentsForUserResponse

Exemple

Exemple getCommentsForUser

Copy

const userId: string = '550e8400-e29b-41d4-a716-446655440000';
const direction: SortDirections = SortDirections.Descending;
const page: number = 3;
const includei10n: boolean = true;
const locale: string = 'fr-FR';
const isCrawler: boolean = false;
const commentsResponse: GetCommentsForUserResponse = await getCommentsForUser(
  userId,
  direction,
  undefined,
  page,
  includei10n,
  locale,
  isCrawler
);

addDomainConfig

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Yes
addDomainConfigParams	AddDomainConfigParams	Yes

Réponse

Renvoie : AddDomainConfigResponse

Exemple

Exemple addDomainConfig

Copy

(async () => {
  const tenantId: string = 'tenant_12345';
  const config: AddDomainConfigParams = {
    domain: 'myblog.example.com',
    enabled: true,
    // la description est optionnelle et omise ici
  };
  const response: AddDomainConfigResponse = await addDomainConfig(tenantId, config);
  console.log(response);
})();

deleteDomainConfig

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
domain	string	Oui

Réponse

Retourne : DeleteDomainConfigResponse

Exemple

Exemple deleteDomainConfig

Copy

async function runExample() {
  const tenantId: string = 'acme-corp';
  const domain: string = 'blog.acme.com';
  const response: DeleteDomainConfigResponse = await deleteDomainConfig(tenantId, domain);
  console.log(response);
}
runExample();

getDomainConfig

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
domain	string	Oui

Réponse

Renvoie : GetDomainConfigResponse

Exemple

Exemple getDomainConfig

Copy

async function main() {
  const tenantId: string = "acme-corp-123";
  const domain: string = "blog.acme.com";
  const config: GetDomainConfigResponse = await getDomainConfig(tenantId, domain);
  console.log(config);
}
main();

getDomainConfigs

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Yes

Réponse

Renvoie : GetDomainConfigsResponse

Exemple

Exemple getDomainConfigs

Copy

async function fetchDomainConfigs(): Promise<void> {
  const tenantId: string = "acme-corp-567";
  const configs: GetDomainConfigsResponse = await getDomainConfigs(tenantId);
  console.log(configs);
}

patchDomainConfig

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
domainToUpdate	string	Oui
patchDomainConfigParams	PatchDomainConfigParams	Oui

Réponse

Retourne : PatchDomainConfigResponse

Exemple

Exemple patchDomainConfig

Copy

async function updateDomainConfig() {
  const tenantId: string = "tenant_98765";
  const domainToUpdate: string = "forum.mycompany.com";
  const patchParams: PatchDomainConfigParams = {
    enableComments: true,
    moderationLevel: "strict",
    allowAnonymous: false, // paramètre optionnel illustré
  };
  const response: PatchDomainConfigResponse = await patchDomainConfig(tenantId, domainToUpdate, patchParams);
  console.log(response);
}
updateDomainConfig();

putDomainConfig

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
domainToUpdate	string	Yes
updateDomainConfigParams	UpdateDomainConfigParams	Yes

Réponse

Retourne : PutDomainConfigResponse

Exemple

Exemple putDomainConfig

Copy

async function runExample() {
  const tenantId: string = 'tenant-9f8c7b1a';
  const domainToUpdate: string = 'comments.mywebsite.org';
  const updateDomainConfigParams: UpdateDomainConfigParams = {
    enableModeration: true,
    // champ facultatif omis, p. ex., maxCommentLength?: number
  };
  const result: PutDomainConfigResponse = await putDomainConfig(
    tenantId,
    domainToUpdate,
    updateDomainConfigParams,
  );
  console.log(result);
}
runExample();

createEmailTemplate

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
createEmailTemplateBody	CreateEmailTemplateBody	Oui

Réponse

Retourne : CreateEmailTemplateResponse

Exemple

Exemple createEmailTemplate

Copy

const tenantId: string = "tenant_9f8b7c6d";
const templateBody: CreateEmailTemplateBody = {
  name: "Weekly Summary",
  subject: "Your weekly activity report",
  // champ optionnel
  replyTo: "no-reply@myapp.com",
  htmlContent: "<p>Hello \{{userName}}, here is your summary...</p>"
};
const response: CreateEmailTemplateResponse = await createEmailTemplate(tenantId, templateBody);
console.log(response.template.id);

deleteEmailTemplate

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple de deleteEmailTemplate

Copy

interface APIStatus {
  code: number;
  message: string;
}
interface APIEmptyResponse {
  status?: APIStatus;
}
(async () => {
  const tenantId: string = "tenant_12345";
  const templateId: string = "template_987";
  const result: APIEmptyResponse = await deleteEmailTemplate(tenantId, templateId);
})();

deleteEmailTemplateRenderError

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
errorId	string	Oui

Réponse

Retourne : APIEmptyResponse

Exemple

deleteEmailTemplateRenderError Exemple

Copy

async function removeRenderError() {
  const tenantId: string = "acme-corp-tenant";
  const templateId: string = "welcome-email-template";
  const errorId: string = "render-err-20230915";
  const result: APIEmptyResponse = await deleteEmailTemplateRenderError(tenantId, templateId, errorId);
}

getEmailTemplate

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Retourne : GetEmailTemplateResponse

Exemple

Exemple getEmailTemplate

Copy

async function fetchTemplate() {
  const tenantId: string = "acme-corp-123";
  const templateId: string = "welcome-email-456";
  const response: GetEmailTemplateResponse = await getEmailTemplate(tenantId, templateId);
  const status: APIStatus | undefined = response.status;
  const customTemplate: CustomEmailTemplate | undefined = response.template;
}

getEmailTemplateDefinitions

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui

Réponse

Renvoie : GetEmailTemplateDefinitionsResponse

Exemple

Exemple getEmailTemplateDefinitions

Copy

async function fetchEmailTemplates() {
    const tenantId: string = "acme-corp-456";
    const result: GetEmailTemplateDefinitionsResponse = await getEmailTemplateDefinitions(tenantId);
    const status: APIStatus = result.status;
    const definitions: EmailTemplateDefinition[] = result.definitions ?? [];
    console.log(`Status: ${status.code}, Templates: ${definitions.length}`);
}

getEmailTemplateRenderErrors

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
skip	number	Non

Réponse

Renvoie : GetEmailTemplateRenderErrorsResponse

Exemple

getEmailTemplateRenderErrors Exemple

Copy

async function demo() {
  const tenantId: string = "tenant_12345";
  const templateId: string = "template_9876";
  const resultWithSkip: GetEmailTemplateRenderErrorsResponse = await getEmailTemplateRenderErrors(tenantId, templateId, 10);
  const resultWithoutSkip: GetEmailTemplateRenderErrorsResponse = await getEmailTemplateRenderErrors(tenantId, templateId);
  console.log(resultWithSkip, resultWithoutSkip);
}
demo();

getEmailTemplates

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Yes
skip	number	No

Réponse

Renvoie : GetEmailTemplatesResponse

Exemple

Exemple getEmailTemplates

Copy

async function fetchEmailTemplates() {
  const tenantId: string = "acme-corp-123";
  const skip: number = 20;
  const templatesWithSkip: GetEmailTemplatesResponse = await getEmailTemplates(tenantId, skip);
  const templatesWithoutSkip: GetEmailTemplatesResponse = await getEmailTemplates(tenantId);
}

renderEmailTemplate

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
renderEmailTemplateBody	RenderEmailTemplateBody	Oui
locale	string	Non

Réponse

Retourne : RenderEmailTemplateResponse

Exemple

Exemple renderEmailTemplate

Copy

const tenantId: string = "c1a2b3d4-5678-90ab-cdef-1234567890ab";
const templateBody: RenderEmailTemplateBody = {
  templateId: "welcome-email",
  variables: {
    userName: "Jane Doe",
    signupDate: "2024-04-01"
  }
};
const locale: string = "en-US";
(async () => {
  const rendered: RenderEmailTemplateResponse = await renderEmailTemplate(
    tenantId,
    templateBody,
    locale
  );
  console.log(rendered);
})();

updateEmailTemplate

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
updateEmailTemplateBody	UpdateEmailTemplateBody	Oui

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple de updateEmailTemplate

Copy

async function runUpdate() {
  const tenantId: string = "tenant_12345";
  const templateId: string = "template_67890";
  const updateBody: UpdateEmailTemplateBody = {
    subject: "New Comment Notification",
    // htmlContent est optionnel et omis
    status: { code: 200, message: "Active" } // APIStatus
  };
  const response: APIEmptyResponse = await updateEmailTemplate(tenantId, templateId, updateBody);
  console.log(response);
}

getEventLog

requête tenantId urlId userIdWS

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
urlId	string	Oui
userIdWS	string	Oui
startTime	number	Oui
endTime	number	Non

Réponse

Renvoie : GetEventLogResponse

Exemple

Exemple getEventLog

Copy

const tenantId: string = "tenant_12345";
const urlId: string = "url_9876";
const userIdWS: string = "user_abcde";
const startTime: number = Date.now() - 86_400_000; // il y a 24 heures
const endTime: number = Date.now();
const fullLog: GetEventLogResponse = await getEventLog(tenantId, urlId, userIdWS, startTime, endTime);
const partialLog: GetEventLogResponse = await getEventLog(tenantId, urlId, userIdWS, startTime);

getGlobalEventLog

req tenantId urlId userIdWS

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
urlId	string	Oui
userIdWS	string	Oui
startTime	number	Oui
endTime	number	Non

Réponse

Retourne : GetEventLogResponse

Exemple

Exemple de getGlobalEventLog

Copy

async function fetchEventLogs() {
  const tenantId: string = "tenant_12345";
  const urlId: string = "url_9876";
  const userIdWS: string = "user_ws_abcde";
  const startTime: number = Date.now() - 24 * 60 * 60 * 1000; // il y a 24 heures
  const endTime: number = Date.now();
  const logWithEnd: GetEventLogResponse = await getGlobalEventLog(tenantId, urlId, userIdWS, startTime, endTime);
  const logWithoutEnd: GetEventLogResponse = await getGlobalEventLog(tenantId, urlId, userIdWS, startTime);
}

createFeedPost

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
createFeedPostParams	CreateFeedPostParams	Oui
broadcastId	string	Non
isLive	boolean	Non
doSpamCheck	boolean	Non
skipDupCheck	boolean	Non

Réponse

Retourne : CreateFeedPostsResponse

Exemple

Exemple createFeedPost

Copy

(async () => {
  const tenantId: string = "c1a2b3d4-5678-90ab-cdef-1234567890ab";
  const broadcastId: string = "b1c2d3e4-5678-90ab-cdef-1234567890cd";
  const isLive: boolean = true;
  const doSpamCheck: boolean = false;
  const skipDupCheck: boolean = true;
  const mediaAsset: FeedPostMediaItemAsset = {
    url: "https://cdn.example.com/photos/sunrise.jpg",
    type: "image/jpeg"
  };
  const mediaItem: FeedPostMediaItem = {
    asset: mediaAsset,
    caption: "Sunrise over the mountains"
  };
  const linkItem: FeedPostLink = {
    url: "https://blog.example.com/tech-trends-2024",
    title: "Top Tech Trends for 2024"
  };
  const postParams: CreateFeedPostParams = {
    text: "Excited to share the latest tech trends!",
    media: [mediaItem],
    link: linkItem
  };
  const response: CreateFeedPostsResponse = await createFeedPost(
    tenantId,
    postParams,
    broadcastId,
    isLive,
    doSpamCheck,
    skipDupCheck
  );
  console.log(response);
})();

createFeedPostPublic

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
createFeedPostParams	CreateFeedPostParams	Yes
broadcastId	string	No
sso	string	No

Réponse

Renvoie : CreateFeedPostResponse

Exemple

Exemple createFeedPostPublic

Copy

const tenantId: string = "tenant_12345";
const mediaAsset: FeedPostMediaItemAsset = {
  url: "https://cdn.example.com/image.jpg",
  width: 800,
  height: 600,
  mimeType: "image/jpeg"
};
const mediaItem: FeedPostMediaItem = {
  type: "image",
  asset: mediaAsset,
  caption: "Sunset over the hills"
};
const link: FeedPostLink = {
  url: "https://example.com/blog/post",
  title: "Exciting New Features",
  description: "Read about our latest updates."
};
const createFeedPostParams: CreateFeedPostParams = {
  content: "Check out our latest blog post!",
  media: [mediaItem],
  link: link,
  visibility: "public"
};
const broadcastId: string = "broadcast_9876";
const sso: string = "sso_token_abc123";
const response: CreateFeedPostResponse = await createFeedPostPublic(
  tenantId,
  createFeedPostParams,
  broadcastId,
  sso
);

deleteFeedPostPublic

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
postId	string	Oui
broadcastId	string	Non
sso	string	Non

Réponse

Renvoie : DeleteFeedPostPublicResponse

Exemple

Exemple deleteFeedPostPublic

Copy

(async () => {
  const tenantId: string = "tenant_12345";
  const postId: string = "post_98765";
  const broadcastId: string = "broadcast_abcde";
  const sso: string = "sso_token_xyz";
  const responseWithOpts: DeleteFeedPostPublicResponse = await deleteFeedPostPublic(
    tenantId,
    postId,
    broadcastId,
    sso
  );
  const responseWithoutOpts: DeleteFeedPostPublicResponse = await deleteFeedPostPublic(
    tenantId,
    postId
  );
})();

getFeedPosts

req tenantId afterId

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
afterId	string	Non
limit	number	Non
tags	Array	Non

Réponse

Retourne : GetFeedPostsResponse

Exemple

Exemple getFeedPosts

Copy

async function loadFeed() {
  const tenantId: string = '123e4567-e89b-12d3-a456-426614174000';
  const afterId: string = 'post_987654321';
  const limit: number = 25;
  const tags: string[] = ['technology', 'innovation'];
  const response: GetFeedPostsResponse = await getFeedPosts(tenantId, afterId, limit, tags);
  console.log(response);
}
loadFeed();

getFeedPostsPublic

req tenantId afterId

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
afterId	string	Non
limit	number	Non
tags	Array	Non
sso	string	Non
isCrawler	boolean	Non
includeUserInfo	boolean	Non

Réponse

Renvoie : PublicFeedPostsResponse

Exemple

Exemple getFeedPostsPublic

Copy

const tenantId: string = "acme-corp-tenant";
const afterId: string = "post-20230915-abc123";
const limit: number = 15;
const tags: string[] = ["technology", "innovation"];
const sso: string = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VySWQiOiIxMjM0NSJ9.s3cr3tSignature";
const isCrawler: boolean = false;
const includeUserInfo: boolean = true;
const feedResponse: PublicFeedPostsResponse = await getFeedPostsPublic(
  tenantId,
  afterId,
  limit,
  tags,
  sso,
  isCrawler,
  includeUserInfo
);

getFeedPostsStats

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
postIds	Array	Oui
sso	string	Non

Réponse

Renvoie : FeedPostsStatsResponse

Exemple

getFeedPostsStats Exemple

Copy

const tenantId: string = "tenant-9f8b7c6d";
const postIds: string[] = ["post-1a2b3c", "post-4d5e6f", "post-7g8h9i"];
const ssoToken: string = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...";
const feedStats: FeedPostsStatsResponse = await getFeedPostsStats(tenantId, postIds, ssoToken);

getUserReactsPublic

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
postIds	Array	No
sso	string	No

Réponse

Retourne : UserReactsResponse

Exemple

Exemple getUserReactsPublic

Copy

const tenantId: string = "tenant_12345";
const postIds: string[] = ["post_abc", "post_def"];
const ssoToken: string = "sso_token_987";
const fullResponse: UserReactsResponse = await getUserReactsPublic(tenantId, postIds, ssoToken);
const minimalResponse: UserReactsResponse = await getUserReactsPublic(tenantId);

reactFeedPostPublic

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
postId	string	Oui
reactBodyParams	ReactBodyParams	Oui
isUndo	boolean	Non
broadcastId	string	Non
sso	string	Non

Réponse

Renvoie : ReactFeedPostResponse

Exemple

Exemple reactFeedPostPublic

Copy

async function demoReact() {
  const tenantId: string = "tenant_12345";
  const postId: string = "post_98765";
  const reactBodyParams: ReactBodyParams = {
    type: "like",
    userId: "user_abcde"
  };
  const response: ReactFeedPostResponse = await reactFeedPostPublic(
    tenantId,
    postId,
    reactBodyParams,
    true,
    "broadcast_001",
    "sso_token_xyz"
  );
}

updateFeedPost

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
feedPost	FeedPost	Oui

Réponse

Renvoie: APIEmptyResponse

Exemple

Exemple de updateFeedPost

Copy

async function runUpdate() {
  const tenantId: string = "tenant_12345";
  const postId: string = "post_98765";
  const mediaAsset: FeedPostMediaItemAsset = {
    url: "https://cdn.example.com/image.jpg",
    width: 800,
    height: 600,
    mimeType: "image/jpeg"
  };
  const mediaItem: FeedPostMediaItem = {
    type: "image",
    asset: mediaAsset,
    caption: "Sunrise over the hills"
  };
  const link: FeedPostLink = {
    url: "https://example.com/blog",
    title: "Latest Blog Post",
    description: "Insights on recent developments"
  };
  const feedPost: FeedPost = {
    title: "Daily Highlights",
    content: "Check out today’s top stories.",
    mediaItems: [mediaItem], // facultatif
    links: [link] // facultatif
  };
  const response: APIEmptyResponse = await updateFeedPost(tenantId, postId, feedPost);
  console.log(response);
}
runUpdate();

updateFeedPostPublic

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
postId	string	Oui
updateFeedPostParams	UpdateFeedPostParams	Oui
broadcastId	string	Non
sso	string	Non

Réponse

Retourne : CreateFeedPostResponse

Exemple

Exemple de updateFeedPostPublic

Copy

// Définir les paramètres
const tenantId: string = "tenant_12345";
const postId: string = "post_98765";
const mediaAsset: FeedPostMediaItemAsset = {
  url: "https://cdn.example.com/image.jpg",
  width: 800,
  height: 600,
  mimeType: "image/jpeg"
};
const mediaItem: FeedPostMediaItem = {
  type: "image",
  asset: mediaAsset,
  caption: "A beautiful scenery"
};
const link: FeedPostLink = {
  url: "https://example.com/article",
  title: "Interesting Article",
  description: "An article about TypeScript best practices."
};
const updateParams: UpdateFeedPostParams = {
  content: "Updated post content with new media and link.",
  media: [mediaItem],
  link: link,
  isPublic: true
};
const broadcastId: string = "broadcast_001";
const sso: string = "sso_token_abc123";
const response: CreateFeedPostResponse = await updateFeedPostPublic(
  tenantId,
  postId,
  updateParams,
  broadcastId,
  sso
);

flagCommentPublic

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
isFlagged	boolean	Oui
sso	string	Non

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple flagCommentPublic

Copy

const tenantId: string = "tenant_42";
const commentId: string = "comment_1001";
const isFlagged: boolean = true;
const sso: string = "sso_user_5678";
const resultWithSso: APIEmptyResponse = await flagCommentPublic(tenantId, commentId, isFlagged, sso);
const resultWithoutSso: APIEmptyResponse = await flagCommentPublic(tenantId, commentId, false);

getGifLarge

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
largeInternalURLSanitized	string	Oui

Réponse

Retourne : GifGetLargeResponse

Exemple

Exemple getGifLarge

Copy

async function runExample() {
    const tenantId: string = "c1a2b3d4-5678-90ab-cdef-1234567890ab";
    const largeInternalURLSanitized: string = "https://cdn.fastcomments.com/gifs/large/abc123.gif";
    const response: GifGetLargeResponse = await getGifLarge(tenantId, largeInternalURLSanitized);
    console.log(response);
}

getGifsSearch

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
search	string	Oui
locale	string	Non
rating	string	Non
page	number	Non

Réponse

Retourne : GetGifsSearchResponse

Exemple

Exemple getGifsSearch

Copy

async function runExample() {
  const tenantId: string = "tenant_9876";
  const search: string = "celebration fireworks";
  const locale: string = "fr-FR";
  const rating: string = "g";
  const page: number = 1;
  const fullResult: GetGifsSearchResponse = await getGifsSearch(tenantId, search, locale, rating, page);
  const minimalResult: GetGifsSearchResponse = await getGifsSearch(tenantId, "dog memes");
}
runExample();

getGifsTrending

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
locale	string	Non
rating	string	Non
page	number	Non

Réponse

Retourne : GetGifsTrendingResponse

Exemple

Exemple getGifsTrending

Copy

async function runExample(): Promise<void> {
  const tenantId: string = "tenant_9f8b7c6d";
  const locale: string = "en-US";
  const rating: string = "PG-13";
  const page: number = 1;
  const trendingAll: GetGifsTrendingResponse = await getGifsTrending(tenantId, locale, rating, page);
  console.log(trendingAll);
  // Utilisation uniquement du paramètre requis
  const trendingMinimal: GetGifsTrendingResponse = await getGifsTrending(tenantId);
  console.log(trendingMinimal);
}
runExample();

addHashTag

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
createHashTagBody	CreateHashTagBody	Non

Réponse

Retourne : CreateHashTagResponse

Exemple

Exemple addHashTag

Copy

const tenantId: string = "c3f5e8b2-9d4a-4f6a-8b2c-1a2b3c4d5e6f";
const tagPayload: CreateHashTagBody = {
  tag: "typescript",
  description: "Discussions about TypeScript"
};
const responseWithBody: CreateHashTagResponse = await addHashTag(tenantId, tagPayload);
const responseWithoutBody: CreateHashTagResponse = await addHashTag(tenantId);

addHashTagsBulk

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
bulkCreateHashTagsBody	BulkCreateHashTagsBody	Non

Réponse

Renvoie : BulkCreateHashTagsResponse

Exemple

Exemple addHashTagsBulk

Copy

const tenantId: string = "tenant_9f8b7c6d";
const tags: BulkCreateHashTagsBodyTagsInner[] = [
  { name: "typescript", color: "#3178c6" },
  { name: "fastcomments", color: "#ff6600" }
];
const bulkBody: BulkCreateHashTagsBody = { tags };
const resultWithBody: BulkCreateHashTagsResponse = await addHashTagsBulk(tenantId, bulkBody);
const resultWithoutBody: BulkCreateHashTagsResponse = await addHashTagsBulk(tenantId);

deleteHashTag

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
tag	string	Yes
deleteHashTagRequestBody	DeleteHashTagRequestBody	No

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple deleteHashTag

Copy

const tenantId: string = "tenant_42";
const tag: string = "high-priority";
const requestBody: DeleteHashTagRequestBody = {
  // remplir les champs au besoin
};
const resultWithBody: APIEmptyResponse = await deleteHashTag(tenantId, tag, requestBody);
const resultWithoutBody: APIEmptyResponse = await deleteHashTag(tenantId, tag);

getHashTags

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
page	number	Non

Réponse

Renvoie : GetHashTagsResponse

Exemple

Exemple getHashTags

Copy

(async () => {
    const tenantId: string = "acme-corp-123";
    const page: number = 1;
    const result: GetHashTagsResponse = await getHashTags(tenantId, page);
    console.log(result);
})();

patchHashTag

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
tag	string	Yes
updateHashTagBody	UpdateHashTagBody	No

Réponse

Renvoie : UpdateHashTagResponse

Exemple

Exemple patchHashTag

Copy

(async () => {
  const tenantId: string = "tenant_12345";
  const tag: string = "news";
  // Appel sans corps optionnel
  const responseWithoutBody: UpdateHashTagResponse = await patchHashTag(tenantId, tag);
  // Préparer le corps pour la mise à jour
  const updateBody: UpdateHashTagBody = {
    name: "Latest News",
    description: "Tag for the most recent news articles"
  };
  const responseWithBody: UpdateHashTagResponse = await patchHashTag(tenantId, tag, updateBody);
})();

getMe

Identifie les informations d’identification en cours d’utilisation : le locataire auquel elles appartiennent et, pour les jetons OAuth, l’utilisateur qui les a autorisées.
Les intégrations utilisent cela pour tester une connexion et l’étiqueter.

Parameters

Nom	Type	Obligatoire	Description
tenantId	string	Oui

Response

Retourne : GetMeResponse

Example

Exemple getMe

Copy

(async () => {
  const tenantId: string = "acme-corp-tenant";
  const me: GetMeResponse = await getMe(tenantId);
  const authType: MeAuthType = me.auth.type;
  const scopes: OAuthScope[] = me.auth.scopes ?? [];
  const status: APIStatus = me.status;
})();

deleteModerationVote

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
voteId	string	Oui
broadcastId	string	Non
sso	string	Non

Réponse

Retourne : VoteDeleteResponse

Exemple

Exemple deleteModerationVote

Copy

async function runDeleteModerationVote(): Promise<void> {
  const tenantId: string = "tenant_9f8b7c6a";
  const commentId: string = "comment_4d3e2f1a";
  const voteId: string = "vote_12345abcde";
  const broadcastId: string | undefined = "broadcast_2023_09_15";
  const sso: string | undefined = "sso_user_7890token";
  const result: VoteDeleteResponse = await deleteModerationVote(
    tenantId,
    commentId,
    voteId,
    broadcastId,
    sso
  );
  console.log(result);
}

getApiComments

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
page	number	No
count	number	No
textSearch	string	No
byIPFromComment	string	No
filters	string	No
searchFilters	string	No
sorts	string	No
demo	boolean	No
sso	string	No

Réponse

Retourne : ModerationAPIGetCommentsResponse

Exemple

Exemple getApiComments

Copy

async function fetchComments(): Promise<void> {
  const tenantId: string = "tenant_12345";
  const page: number = 2;
  const count: number = 20;
  const textSearch: string = "typescript";
  const byIPFromComment: string = "192.168.1.100";
  const filters: string = "spam,offensive";
  const searchFilters: string = "user:john";
  const sorts: string = "date_desc";
  const demo: boolean = true;
  const sso: string = "sso_token_abc";
  const response: ModerationAPIGetCommentsResponse = await getApiComments(
    tenantId,
    page,
    count,
    textSearch,
    byIPFromComment,
    filters,
    searchFilters,
    sorts,
    demo,
    sso
  );
}
fetchComments();

getApiExportStatus

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
batchJobId	string	No
sso	string	No

Réponse

Renvoie : ModerationExportStatusResponse

Exemple

Exemple getApiExportStatus

Copy

async function run() {
  const tenantId: string = "tenant_12345";
  const batchJobId: string = "job_98765";
  const ssoToken: string = "sso_abcde12345";
  const statusOnlyTenant: ModerationExportStatusResponse = await getApiExportStatus(tenantId);
  const statusWithBatch: ModerationExportStatusResponse = await getApiExportStatus(tenantId, batchJobId);
  const statusFull: ModerationExportStatusResponse = await getApiExportStatus(tenantId, batchJobId, ssoToken);
}
run();

getApiIds

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
textSearch	string	No
byIPFromComment	string	No
filters	string	No
searchFilters	string	No
afterId	string	No
demo	boolean	No
sso	string	No

Réponse

Renvoie : ModerationAPIGetCommentIdsResponse

Exemple

Exemple getApiIds

Copy

async function run(): Promise<void> {
  const tenantId: string = "acme-corp";
  const textSearch: string = "offensive language";
  const byIPFromComment: string = "203.0.113.45";
  const filters: string = "status:unmoderated";
  const searchFilters: string = "author:alice";
  const afterId: string = "cmt_00123";
  const demo: boolean = true;
  const sso: string = "sso_9f8e7d6c";
  const fullResult: ModerationAPIGetCommentIdsResponse = await getApiIds(
    tenantId,
    textSearch,
    byIPFromComment,
    filters,
    searchFilters,
    afterId,
    demo,
    sso
  );
  const minimalResult: ModerationAPIGetCommentIdsResponse = await getApiIds(tenantId);
}

getBanUsersFromComment

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
sso	string	Non

Réponse

Retourne : GetBannedUsersFromCommentResponse

Exemple

Exemple getBanUsersFromComment

Copy

const tenantId: string = "tenant_9f8b7c";
const commentId: string = "comment_a1b2c3";
const ssoToken: string = "sso_abc123";
const bannedUsers: GetBannedUsersFromCommentResponse = await getBanUsersFromComment(tenantId, commentId, ssoToken);
const bannedUsersNoSso: GetBannedUsersFromCommentResponse = await getBanUsersFromComment(tenantId, commentId);

getCommentBanStatus

Paramètres

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
sso	string	No

Réponse

Renvoie : GetCommentBanStatusResponse

Exemple

Exemple getCommentBanStatus

Copy

(async () => {
  const tenantId: string = "tenant_12345";
  const commentId: string = "cmt_987654";
  const ssoToken: string = "sso_user_abc";
  const statusWithSso: GetCommentBanStatusResponse = await getCommentBanStatus(tenantId, commentId, ssoToken);
  const statusWithoutSso: GetCommentBanStatusResponse = await getCommentBanStatus(tenantId, commentId);
})();

getCommentChildren

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
commentId	string	Yes
sso	string	No

Réponse

Renvoie : ModerationAPIChildCommentsResponse

Exemple

Exemple getCommentChildren

Copy

async function fetchChildren() {
  const tenantId: string = "tenant_12345";
  const commentId: string = "cmt_98765";
  const ssoToken: string = "sso_user_abc123";
  const responseWithSSO: ModerationAPIChildCommentsResponse = await getCommentChildren(tenantId, commentId, ssoToken);
  const responseWithoutSSO: ModerationAPIChildCommentsResponse = await getCommentChildren(tenantId, commentId);
}
fetchChildren();

getCount

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
textSearch	string	Non
byIPFromComment	string	Non
filter	string	Non
searchFilters	string	Non
demo	boolean	Non
sso	string	Non

Réponse

Renvoie : ModerationAPICountCommentsResponse

Exemple

Exemple getCount

Copy

const tenantId: string = "tenant_12345";
const basicCount: ModerationAPICountCommentsResponse = await getCount(tenantId);
const detailedCount: ModerationAPICountCommentsResponse = await getCount(
  tenantId,
  "spam",
  "192.168.1.100",
  "status:pending",
  "user:john",
  true,
  "sso_token_abc"
);

getCounts

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
sso	string	Non

Réponse

Renvoie: GetBannedUsersCountResponse

Exemple

getCounts Exemple

Copy

async function run() {
  const tenantId: string = "tenant_9876";
  const ssoToken: string = "sso_user_42";
  const resultWithOnlyTenant: GetBannedUsersCountResponse = await getCounts(tenantId);
  const resultWithBoth: GetBannedUsersCountResponse = await getCounts(tenantId, ssoToken);
}
run();

getLogs

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
sso	string	Non

Réponse

Retourne : ModerationAPIGetLogsResponse

Exemple

Exemple getLogs

Copy

(async () => {
  const tenantId: string = "acme-corp-123";
  const commentId: string = "cmt_4567890";
  const ssoToken: string = "sso_abcdef123456";
  const logsWithSso: ModerationAPIGetLogsResponse = await getLogs(tenantId, commentId, ssoToken);
  const logsWithoutSso: ModerationAPIGetLogsResponse = await getLogs(tenantId, commentId);
})();

getManualBadges

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
sso	string	Non

Réponse

Renvoie : GetTenantManualBadgesResponse

Exemple

Exemple getManualBadges

Copy

async function fetchBadges() {
  const tenantId: string = "tenant-987654321";
  const ssoToken: string = "sso-token-abc123";
  const badgesWithSso: GetTenantManualBadgesResponse = await getManualBadges(tenantId, ssoToken);
  const badgesWithoutSso: GetTenantManualBadgesResponse = await getManualBadges(tenantId);
}

getManualBadgesForUser

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
badgesUserId	string	Non
commentId	string	Non
sso	string	Non

Réponse

Retourne : GetUserManualBadgesResponse

Exemple

Exemple getManualBadgesForUser

Copy

async () => {
  const tenantId: string = "tenant_12345";
  const badgesUserId: string | undefined = "user_98765";
  const commentId: string | undefined = "comment_abcde";
  const sso: string | undefined = "sso_token_xyz";
  const basicResponse: GetUserManualBadgesResponse = await getManualBadgesForUser(tenantId);
  const fullResponse: GetUserManualBadgesResponse = await getManualBadgesForUser(
    tenantId,
    badgesUserId,
    commentId,
    sso
  );
  console.log(basicResponse, fullResponse);
}();

getModerationComment

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
includeEmail	boolean	Non
includeIP	boolean	Non
sso	string	Non

Réponse

Retourne : ModerationAPICommentResponse

Exemple

Exemple getModerationComment

Copy

async function fetchComments() {
  const tenantId: string = "acme-corp";
  const commentId: string = "cmt_1234567890";
  // Appel avec uniquement les paramètres obligatoires
  const basicResponse: ModerationAPICommentResponse = await getModerationComment(tenantId, commentId);
  // Appel avec les paramètres optionnels
  const includeEmail: boolean = true;
  const includeIP: boolean = false;
  const sso: string = "sso-token-abc123";
  const detailedResponse: ModerationAPICommentResponse = await getModerationComment(
    tenantId,
    commentId,
    includeEmail,
    includeIP,
    sso
  );
}

getModerationCommentText

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
sso	string	Non

Réponse

Renvoie : GetCommentTextResponse

Exemple

Exemple getModerationCommentText

Copy

async function fetchComment() {
  const tenantId: string = "tenant_12345";
  const commentId: string = "cmt_98765";
  const ssoToken: string = "sso_abcde12345";
  const commentWithoutSso: GetCommentTextResponse = await getModerationCommentText(tenantId, commentId);
  const commentWithSso: GetCommentTextResponse = await getModerationCommentText(tenantId, commentId, ssoToken);
}
fetchComment();

getPreBanSummary

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
commentId	string	Yes
includeByUserIdAndEmail	boolean	No
includeByIP	boolean	No
includeByEmailDomain	boolean	No
sso	string	No

Réponse

Renvoie : PreBanSummary

Exemple

Exemple getPreBanSummary

Copy

async function fetchSummary(): Promise<void> {
  const tenantId: string = "tenant_12345";
  const commentId: string = "cmt_98765";
  const includeByUserIdAndEmail: boolean = true;
  const includeByIP: boolean = false;
  const includeByEmailDomain: boolean = true;
  const sso: string = "sso_token_abc";
  const summary: PreBanSummary = await getPreBanSummary(
    tenantId,
    commentId,
    includeByUserIdAndEmail,
    includeByIP,
    includeByEmailDomain,
    sso
  );
  console.log(summary);
}
fetchSummary();

getSearchCommentsSummary

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
value	string	No
filters	string	No
searchFilters	string	No
sso	string	No

Réponse

Renvoie : ModerationCommentSearchResponse

Exemple

Exemple getSearchCommentsSummary

Copy

async function runSearch() {
  const tenantId: string = "tenant_12345";
  const value: string = "spam";
  const filters: string = "status:pending";
  const searchFilters: string = "author:john";
  const sso: string = "sso_token_abc";
  const result: ModerationCommentSearchResponse = await getSearchCommentsSummary(
    tenantId,
    value,
    filters,
    searchFilters,
    sso
  );
  console.log(result);
}
runSearch();

getSearchPages

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
value	string	Non
sso	string	Non

Réponse

Returns: ModerationPageSearchResponse

Exemple

Exemple getSearchPages

Copy

const tenantId: string = "acme-corp-123";
const searchValue: string = "spam";
const ssoToken: string = "sso-abc123def456";
const result1: ModerationPageSearchResponse = await getSearchPages(tenantId);
const result2: ModerationPageSearchResponse = await getSearchPages(tenantId, searchValue);
const result3: ModerationPageSearchResponse = await getSearchPages(tenantId, searchValue, ssoToken);

getSearchSites

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
value	string	No
sso	string	No

Réponse

Retourne : ModerationSiteSearchResponse

Exemple

Exemple getSearchSites

Copy

async function runSearches(): Promise<void> {
  const tenantId: string = "tenant-987654";
  const query: string = "offensive content";
  const ssoToken: string = "sso-token-xyz";
  const fullResult: ModerationSiteSearchResponse = await getSearchSites(tenantId, query, ssoToken);
  const minimalResult: ModerationSiteSearchResponse = await getSearchSites(tenantId);
}
runSearches();

getSearchSuggest

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
textSearch	string	Non
sso	string	Non

Réponse

Retourne : ModerationSuggestResponse

Exemple

Exemple getSearchSuggest

Copy

(async () => {
  const tenantId: string = "tenant-9f8b7c6d";
  const textSearch: string = "harassment";
  const sso: string = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...";
  const suggestResponse: ModerationSuggestResponse = await getSearchSuggest(tenantId, textSearch, sso);
  const minimalResponse: ModerationSuggestResponse = await getSearchSuggest(tenantId);
})();

getSearchUsers

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
value	string	Non
sso	string	Non

Réponse

Renvoie : ModerationUserSearchResponse

Exemple

Exemple getSearchUsers

Copy

async function runSearch() {
  const tenantId: string = "tenant-9876";
  const emailFragment: string = "jane";
  const ssoToken: string = "sso-token-456";
  const resultWithAll: ModerationUserSearchResponse = await getSearchUsers(tenantId, emailFragment, ssoToken);
  const resultWithTenantOnly: ModerationUserSearchResponse = await getSearchUsers(tenantId);
}

getTrustFactor

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
userId	string	No
sso	string	No

Réponse

Renvoie : GetUserTrustFactorResponse

Exemple

Exemple getTrustFactor

Copy

async function demo() {
  const tenantId: string = "tenant_12345";
  const userId: string = "user_98765";
  const sso: string = "sso_token_abcde";
  const trustFactor: GetUserTrustFactorResponse = await getTrustFactor(tenantId);
  const trustFactorWithUser: GetUserTrustFactorResponse = await getTrustFactor(tenantId, userId);
  const trustFactorFull: GetUserTrustFactorResponse = await getTrustFactor(tenantId, userId, sso);
}

getUserBanPreference

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
sso	string	Non

Réponse

Retourne : APIModerateGetUserBanPreferencesResponse

Exemple

Exemple getUserBanPreference

Copy

async function demoGetUserBanPreference() {
  const tenantId: string = "tenant_987654321";
  const ssoToken: string = "sso_user_abc123xyz";
  const responseWithSso: APIModerateGetUserBanPreferencesResponse = await getUserBanPreference(tenantId, ssoToken);
  const responseWithoutSso: APIModerateGetUserBanPreferencesResponse = await getUserBanPreference(tenantId);
}

getUserInternalProfile

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Non
sso	string	Non

Réponse

Retourne : GetUserInternalProfileResponse

Exemple

Exemple getUserInternalProfile

Copy

async function demo() {
  const tenantId: string = "tenant_12345";
  const commentId: string = "cmt_9876";
  const ssoToken: string = "sso_abcde12345";
  const profileOnly: GetUserInternalProfileResponse = await getUserInternalProfile(tenantId);
  const profileWithComment: GetUserInternalProfileResponse = await getUserInternalProfile(tenantId, commentId);
  const fullProfile: GetUserInternalProfileResponse = await getUserInternalProfile(tenantId, commentId, ssoToken);
}
demo();

postAdjustCommentVotes

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
adjustCommentVotesParams	AdjustCommentVotesParams	Oui
broadcastId	string	Non
sso	string	Non

Réponse

Retourne : AdjustVotesResponse

Exemple

Exemple postAdjustCommentVotes

Copy

const tenantId: string = "acme-corp";
const commentId: string = "cmt_987654321";
const adjustParams: AdjustCommentVotesParams = { voteDelta: 1 };
const broadcastId: string = "brd_112233";
const sso: string = "sso-token-xyz";
const result: AdjustVotesResponse = await postAdjustCommentVotes(
  tenantId,
  commentId,
  adjustParams,
  broadcastId,
  sso
);

postApiExport

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
textSearch	string	Non
byIPFromComment	string	Non
filters	string	Non
searchFilters	string	Non
sorts	string	Non
sso	string	Non

Réponse

Renvoie : ModerationExportResponse

Exemple

postApiExport Exemple

Copy

async function runExport() {
  const tenantId: string = "c9f1e2b4-8a6d-4f3a-9d2e-5b6c7d8e9f0a";
  const textSearch: string = "spam";
  const byIPFromComment: string = "203.0.113.45";
  const filters: string = "status:pending";
  const searchFilters: string = "createdAt>2023-01-01";
  const sorts: string = "createdAt:desc";
  const sso: string = "sso-token-abc123";
  const fullExport: ModerationExportResponse = await postApiExport(
    tenantId,
    textSearch,
    byIPFromComment,
    filters,
    searchFilters,
    sorts,
    sso
  );
  const minimalExport: ModerationExportResponse = await postApiExport(tenantId);
  console.log(fullExport, minimalExport);
}
runExport();

postBanUserFromComment

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
banEmail	boolean	Non
banEmailDomain	boolean	Non
banIP	boolean	Non
deleteAllUsersComments	boolean	Non
bannedUntil	string	Non
isShadowBan	boolean	Non
updateId	string	Non
banReason	string	Non
sso	string	Non

Réponse

Renvoie : BanUserFromCommentResult

Exemple

Exemple postBanUserFromComment

Copy

async function banUserExample(): Promise<void> {
  const result: BanUserFromCommentResult = await postBanUserFromComment(
    "tenant_42",
    "comment_1001",
    true,                     // banEmail
    undefined,                // banEmailDomain (omise)
    true,                     // banIP
    false,                    // deleteAllUsersComments
    "2025-01-01T00:00:00Z",   // bannedUntil
    true,                     // isShadowBan
    undefined,                // updateId (omise)
    "Harassment",             // banReason
    undefined                 // sso (omise)
  );
  console.log(result);
}

postBanUserUndo

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
banUserUndoParams	BanUserUndoParams	Oui
sso	string	Non

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple postBanUserUndo

Copy

const tenantId: string = "tenant_9876";
const undoParams: BanUserUndoParams = {
  userId: "user_12345",
  // des champs requis supplémentaires peuvent être ajoutés ici
};
const resultWithoutSSO: APIEmptyResponse = await postBanUserUndo(tenantId, undoParams);
const ssoToken: string = "sso_abcdef123456";
const resultWithSSO: APIEmptyResponse = await postBanUserUndo(tenantId, undoParams, ssoToken);

postBulkPreBanSummary

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
bulkPreBanParams	BulkPreBanParams	Yes
includeByUserIdAndEmail	boolean	No
includeByIP	boolean	No
includeByEmailDomain	boolean	No
sso	string	No

Réponse

Retourne : BulkPreBanSummary

Exemple

Exemple postBulkPreBanSummary

Copy

const tenantId: string = "c1f2e3d4-5678-90ab-cdef-1234567890ab";
const bulkPreBanParams: BulkPreBanParams = {
  userIds: ["user123"],
  emails: ["spam@example.com"],
  ips: ["192.0.2.1"],
  emailDomains: ["example.com"]
};
const includeByUserIdAndEmail: boolean = true;
const includeByIP: boolean = false;
const includeByEmailDomain: boolean = true;
const sso: string = "sso-token-abc123";
const summary: BulkPreBanSummary = await postBulkPreBanSummary(
  tenantId,
  bulkPreBanParams,
  includeByUserIdAndEmail,
  includeByIP,
  includeByEmailDomain,
  sso
);

postCommentsByIds

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
commentsByIdsParams	CommentsByIdsParams	Yes
sso	string	No

Réponse

Retourne : ModerationAPIChildCommentsResponse

Exemple

Exemple postCommentsByIds

Copy

const tenantId: string = 'tenant-9f8b7c6d-1234-5678-90ab-cdef12345678';
const commentsByIdsParams: CommentsByIdsParams = {
  commentIds: ['comment-1', 'comment-2'],
  includeUserBadges: true
};
const responseWithoutSso: ModerationAPIChildCommentsResponse = await postCommentsByIds(tenantId, commentsByIdsParams);
const sso: string = 'sso-abc123def456';
const responseWithSso: ModerationAPIChildCommentsResponse = await postCommentsByIds(tenantId, commentsByIdsParams, sso);

postFlagComment

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	No
sso	string	No

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple postFlagComment

Copy

async function runExample() {
  const tenantId: string = "tenant_12345";
  const commentId: string = "cmt_98765";
  // Paramètres obligatoires uniquement
  const result1: APIEmptyResponse = await postFlagComment(tenantId, commentId);
  // Inclure les paramètres optionnels
  const broadcastId: string = "brd_54321";
  const sso: string = "user@example.com";
  const result2: APIEmptyResponse = await postFlagComment(tenantId, commentId, broadcastId, sso);
  console.log(result1, result2);
}
runExample();

postRemoveComment

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	No
sso	string	No

Réponse

Renvoie : PostRemoveCommentApiResponse

Exemple

Exemple postRemoveComment

Copy

async function removeCommentExample() {
  const tenantId: string = "tenant_12345";
  const commentId: string = "cmt_98765";
  const broadcastId: string = "brd_555";
  const sso: string = "sso_token_abc";
  const response: PostRemoveCommentApiResponse = await postRemoveComment(
    tenantId,
    commentId,
    broadcastId,
    sso
  );
  console.log(response);
}
removeCommentExample();

postRestoreDeletedComment

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	No
sso	string	No

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple postRestoreDeletedComment

Copy

const tenantId: string = "tenant_12345";
const commentId: string = "cmt_98765";
const resultRequired: APIEmptyResponse = await postRestoreDeletedComment(tenantId, commentId);
const broadcastId: string = "brd_001";
const sso: string = "sso_token_abc123";
const resultAll: APIEmptyResponse = await postRestoreDeletedComment(
  tenantId,
  commentId,
  broadcastId,
  sso
);

postSetCommentApprovalStatus

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
approved	boolean	Non
broadcastId	string	Non
sso	string	Non

Réponse

Renvoie : SetCommentApprovedResponse

Exemple

postSetCommentApprovalStatus Exemple

Copy

(async () => {
  const tenantId: string = "tenant_001";
  const commentId: string = "comment_123";
  const approved: boolean = false;
  const broadcastId: string = "broadcast_456";
  const sso: string = "sso_789";
  const result: SetCommentApprovedResponse = await postSetCommentApprovalStatus(
    tenantId,
    commentId,
    approved,
    broadcastId,
    sso
  );
  const minimalResult: SetCommentApprovedResponse = await postSetCommentApprovalStatus(
    tenantId,
    commentId
  );
})();

postSetCommentReviewStatus

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
commentId	string	Yes
reviewed	boolean	No
broadcastId	string	No
sso	string	No

Réponse

Retourne: APIEmptyResponse

Exemple

postSetCommentReviewStatus Exemple

Copy

const tenantId: string = "tenant_12345";
const commentId: string = "cmt_98765";
const reviewed: boolean = true;
const broadcastId: string = "brd_001";
const sso: string = "sso_token_abc";
const result: APIEmptyResponse = await postSetCommentReviewStatus(
  tenantId,
  commentId,
  reviewed,
  broadcastId,
  sso
);

postSetCommentSpamStatus

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
commentId	string	Yes
spam	boolean	No
permNotSpam	boolean	No
broadcastId	string	No
sso	string	No

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple postSetCommentSpamStatus

Copy

const tenantId: string = "tenant_42";
const commentId: string = "comment_1001";
const spam: boolean = true;
const permNotSpam: boolean = false;
const broadcastId: string = "broadcast_2023";
const sso: string = "sso_user_5678";
const resultFull: APIEmptyResponse = await postSetCommentSpamStatus(
  tenantId,
  commentId,
  spam,
  permNotSpam,
  broadcastId,
  sso
);
const resultMinimal: APIEmptyResponse = await postSetCommentSpamStatus(
  tenantId,
  commentId
);

postSetCommentText

Paramètres

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
setCommentTextParams	SetCommentTextParams	Yes
broadcastId	string	No
sso	string	No

Réponse

Retourne: SetCommentTextResponse

Exemple

Exemple postSetCommentText

Copy

const tenantId: string = "tenant_12345";
const commentId: string = "cmt_9876";
const setCommentTextParams: SetCommentTextParams = {
  text: "Revised comment after user edit.",
  format: "plain"
};
const broadcastId: string = "broadcast_2023_09";
const response: SetCommentTextResponse = await postSetCommentText(
  tenantId,
  commentId,
  setCommentTextParams,
  broadcastId
);
console.log(response);

postUnFlagComment

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	No
sso	string	No

Réponse

Retourne : APIEmptyResponse

Exemple

postUnFlagComment Exemple

Copy

async function runExample() {
  const tenantId: string = "tenant_12345";
  const commentId: string = "comment_98765";
  const broadcastId: string = "broadcast_55555";
  const sso: string = "sso_token_abcde";
  const result1: APIEmptyResponse = await postUnFlagComment(tenantId, commentId);
  const result2: APIEmptyResponse = await postUnFlagComment(tenantId, commentId, broadcastId, sso);
}
runExample();

postVote

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
direction	string	Non
broadcastId	string	Non
sso	string	Non

Réponse

Renvoie : VoteResponse

Exemple

Exemple postVote

Copy

async function runVoteExamples(): Promise<void> {
  const tenantId: string = "acme-corp";
  const commentId: string = "cmt_1234567890";
  // Appel avec uniquement les paramètres requis
  const simpleVote: VoteResponse = await postVote(tenantId, commentId);
  // Appel avec les paramètres optionnels
  const direction: string = "down";
  const broadcastId: string = "brd_987654321";
  const sso: string = "user-42";
  const detailedVote: VoteResponse = await postVote(tenantId, commentId, direction, broadcastId, sso);
  console.log(simpleVote, detailedVote);
}

putAwardBadge

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
badgeId	string	Yes
userId	string	No
commentId	string	No
broadcastId	string	No
sso	string	No

Réponse

Renvoie : AwardUserBadgeResponse

Exemple

putAwardBadge Exemple

Copy

async function awardBadgeExample(): Promise<void> {
  const tenantId: string = "tenant_42";
  const badgeId: string = "badge_superstar";
  const userId: string = "user_1001";
  const commentId: string = "comment_2023";
  const result: AwardUserBadgeResponse = await putAwardBadge(
    tenantId,
    badgeId,
    userId,
    commentId
  );
  console.log(result);
}

putCloseThread

Paramètres

Name	Type	Required
tenantId	string	Yes
urlId	string	Yes
sso	string	No

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple putCloseThread

Copy

(async () => {
  const tenantId: string = "my-company";
  const urlId: string = "post-2023-09-15";
  const ssoToken: string = "sso-abc123def";
  const resultWithSso: APIEmptyResponse = await putCloseThread(tenantId, urlId, ssoToken);
  const resultWithoutSso: APIEmptyResponse = await putCloseThread(tenantId, urlId);
})();

putRemoveBadge

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
badgeId	string	Oui
userId	string	Non
commentId	string	Non
broadcastId	string	Non
sso	string	Non

Réponse

Renvoie : RemoveUserBadgeResponse

Exemple

Exemple de putRemoveBadge

Copy

async function demoRemoveBadge() {
  const tenantId: string = "tenant_42";
  const badgeId: string = "badge_gold";
  const userId: string = "user_1001";
  const commentId: string = "comment_20230915";
  const broadcastId: string = "broadcast_live_01";
  const sso: string = "sso_abcdef123456";
  const result: RemoveUserBadgeResponse = await putRemoveBadge(
    tenantId,
    badgeId,
    userId,
    commentId,
    broadcastId,
    sso
  );
  console.log(result);
}

putReopenThread

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
urlId	string	Oui
sso	string	Non

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple de putReopenThread

Copy

async function reopenThreadExample() {
    const tenantId: string = "tenant_12345";
    const urlId: string = "post-9876";
    const sso: string = "user-abc123";
    const responseWithoutSso: APIEmptyResponse = await putReopenThread(tenantId, urlId);
    const responseWithSso: APIEmptyResponse = await putReopenThread(tenantId, urlId, sso);
}
reopenThreadExample();

setTrustFactor

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
userId	string	No
trustFactor	string	No
sso	string	No

Réponse

Retourne : SetUserTrustFactorResponse

Exemple

setTrustFactor Exemple

Copy

async function demoSetTrustFactor() {
  const tenantId: string = "acme-corp";
  const userId: string = "user-9876";
  const trustFactor: string = "high";
  const sso: string = "sso-token-xyz";
  const fullResponse: SetUserTrustFactorResponse = await setTrustFactor(
    tenantId,
    userId,
    trustFactor,
    sso
  );
  const minimalResponse: SetUserTrustFactorResponse = await setTrustFactor(tenantId);
}

createModerator

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
createModeratorBody	CreateModeratorBody	Oui

Réponse

Renvoie : CreateModeratorResponse

Exemple

Exemple createModerator

Copy

const tenantId: string = "tenant_12345";
const moderatorPayload: CreateModeratorBody = {
  userId: "user_9876",
  // champ optionnel ; peut être omis si non nécessaire
  notes: "Temporary moderator for event"
};
const response: CreateModeratorResponse = await createModerator(tenantId, moderatorPayload);

deleteModerator

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
id	string	Yes
sendEmail	string	No

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple de deleteModerator

Copy

(async () => {
  const tenantId: string = "tenant_12345";
  const moderatorId: string = "mod_9876";
  const notifyEmail: string = "admin@company.com";
  const resultWithEmail: APIEmptyResponse = await deleteModerator(tenantId, moderatorId, notifyEmail);
  const resultWithoutEmail: APIEmptyResponse = await deleteModerator(tenantId, moderatorId);
})();

getModerator

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Renvoie : GetModeratorResponse

Exemple

Exemple getModerator

Copy

async function fetchModerator() {
  const tenantId: string = "c9f1e2b3-4d5a-6f78-90ab-cdef12345678";
  const moderatorId: string = "mod-987654";
  const response: GetModeratorResponse = await getModerator(tenantId, moderatorId);
  const isActive: boolean | undefined = response.moderator?.isActive;
  const statusCode: number | undefined = response.status?.code;
}

getModerators

Paramètres

Name	Type	Required	Description
tenantId	string	Yes
skip	number	No

Réponse

Renvoie : GetModeratorsResponse

Exemple

Exemple getModerators

Copy

const tenantId: string = "tenant_987654321";
const moderators: GetModeratorsResponse = await getModerators(tenantId);
const skip: number = 20;
const moreModerators: GetModeratorsResponse = await getModerators(tenantId, skip);

sendInvite

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
fromName	string	Oui

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple sendInvite

Copy

const tenantId: string = "tenant-987654321";
const id: string = "user-123456789";
const fromName: string = "Alice Johnson";
const result: APIEmptyResponse = await sendInvite(tenantId, id, fromName);
console.log(result);

updateModerator

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
updateModeratorBody	UpdateModeratorBody	Oui

Réponse

Retourne: APIEmptyResponse

Exemple

Exemple de updateModerator

Copy

const tenantId: string = "tenant_9f8b7c6d";
const moderatorId: string = "mod_12345";
const updateBody: UpdateModeratorBody = {
  isActive: true,
  // role?: string est optionnel et omis ici
};
const result: APIEmptyResponse = await updateModerator(tenantId, moderatorId, updateBody);

deleteNotificationCount

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple de deleteNotificationCount

Copy

let tenantId: string = "tenant-42f9b8c1";
let notificationId: string = "notif-7e3a9d4f";
const result: APIEmptyResponse = await deleteNotificationCount(tenantId, notificationId);

getCachedNotificationCount

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Retourne : GetCachedNotificationCountResponse

Exemple

Exemple getCachedNotificationCount

Copy

(async () => {
  const tenantId: string = "tenant_12345";
  const id: string = "user_9876";
  const response: GetCachedNotificationCountResponse = await getCachedNotificationCount(tenantId, id);
})();

getNotificationCount

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
userId	string	No
urlId	string	No
fromCommentId	string	No
viewed	boolean	No
type	string	No

Réponse

Retourne : GetNotificationCountResponse

Exemple

Exemple getNotificationCount

Copy

const tenantId: string = "acme-corp";
const userId: string = "user-12345";
const urlId: string = "https://app.example.com/dashboard";
const fromCommentId: string = "cmt-9876";
const viewed: boolean = false;
const type: string = "reply";
const notificationCount: GetNotificationCountResponse = await getNotificationCount(
  tenantId,
  userId,
  urlId,
  fromCommentId,
  viewed,
  type
);

getNotifications

Paramètres

Name	Type	Required
tenantId	string	Oui
userId	string	Non
urlId	string	Non
fromCommentId	string	Non
viewed	boolean	Non
type	string	Non
skip	number	Non

Réponse

Retourne : GetNotificationsResponse

Exemple

Exemple getNotifications

Copy

async function fetchNotifications(): Promise<void> {
  const tenantId: string = "tenant_42";
  const userId: string = "user_1001";
  const urlId: string = "url_2023";
  const viewed: boolean = true;
  const skip: number = 0;
  const notifications: GetNotificationsResponse = await getNotifications(
    tenantId,
    userId,
    urlId,
    undefined,
    viewed,
    undefined,
    skip
  );
  console.log(notifications);
}

updateNotification

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
id	string	Yes
updateNotificationBody	UpdateNotificationBody	Yes
userId	string	No

Réponse

Retourne : APIEmptyResponse

Exemple

updateNotification Exemple

Copy

async function main(): Promise<void> {
  const tenantId: string = "tenant-abc123";
  const notificationId: string = "notif-9876";
  const updateBody: UpdateNotificationBody = {
    title: "System Maintenance",
    message: "Scheduled maintenance at 02:00 UTC.",
    enabled: true
  };
  const userId: string = "user-42";
  const resultWithoutUser: APIEmptyResponse = await updateNotification(tenantId, notificationId, updateBody);
  const resultWithUser: APIEmptyResponse = await updateNotification(tenantId, notificationId, updateBody, userId);
}

createV1PageReact

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
urlId	string	Yes
title	string	No
sso	string	No

Réponse

Retourne : CreateV1PageReact

Exemple

Exemple createV1PageReact

Copy

const tenantId: string = "my-tenant-123";
const urlId: string = "article-456";
const pageTitle: string = "Understanding TypeScript Generics";
const ssoToken: string = "user-789-token";
const fullResult: CreateV1PageReact = await createV1PageReact(tenantId, urlId, pageTitle, ssoToken);
const minimalResult: CreateV1PageReact = await createV1PageReact(tenantId, urlId);

createV2PageReact

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
urlId	string	Oui
id	string	Oui
title	string	Non
sso	string	Non

Réponse

Retourne : CreateV1PageReact

Exemple

Exemple createV2PageReact

Copy

async function run() {
  const tenantId: string = "acme-corp";
  const urlId: string = "product-page-123";
  const pageId: string = "page-456";
  const pageTitle: string = "Product Overview";
  const ssoToken: string = "jwt-token-abc123";
  const pageFull: CreateV1PageReact = await createV2PageReact(tenantId, urlId, pageId, pageTitle, ssoToken);
  const pageTitleOnly: CreateV1PageReact = await createV2PageReact(tenantId, urlId, pageId, pageTitle);
  const pageMinimal: CreateV1PageReact = await createV2PageReact(tenantId, urlId, pageId);
}
run();

deleteV1PageReact

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
urlId	string	Oui
sso	string	Non

Réponse

Retourne : CreateV1PageReact

Exemple

Exemple deleteV1PageReact

Copy

async function runExamples() {
  const tenantId: string = "tenant_9f8b7c6d";
  const urlId: string = "blog/post-2024-06-15";
  const ssoToken: string = "sso_user_42";
  const resultWithSso: CreateV1PageReact = await deleteV1PageReact(tenantId, urlId, ssoToken);
  const resultWithoutSso: CreateV1PageReact = await deleteV1PageReact(tenantId, urlId);
}

deleteV2PageReact

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
urlId	string	Oui
id	string	Oui
sso	string	Non

Réponse

Retourne : CreateV1PageReact

Exemple

Exemple deleteV2PageReact

Copy

async function runDeleteExamples() {
  const tenantId: string = "tenant_12345";
  const urlId: string = "page_98765";
  const commentId: string = "comment_abcde";
  // Appel sans sso optionnel
  const resultWithoutSso: CreateV1PageReact = await deleteV2PageReact(tenantId, urlId, commentId);
  // Appel avec sso optionnel
  const ssoToken: string = "sso_token_xyz";
  const resultWithSso: CreateV1PageReact = await deleteV2PageReact(tenantId, urlId, commentId, ssoToken);
}

getV1PageLikes

Paramètres

Name	Type	Required
tenantId	string	Oui
urlId	string	Oui
sso	string	Non

Réponse

Retourne : GetV1PageLikes

Exemple

Exemple getV1PageLikes

Copy

(async () => {
  const tenantId: string = "tenant_12345";
  const urlId: string = "https://myblog.com/post/42";
  const ssoToken: string = "sso_user_987";
  const likesWithSSO: GetV1PageLikes = await getV1PageLikes(tenantId, urlId, ssoToken);
  const likesWithoutSSO: GetV1PageLikes = await getV1PageLikes(tenantId, urlId);
})();

getV2PageReacts

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
urlId	string	Oui
sso	string	Non

Réponse

Retourne : GetV2PageReacts

Exemple

Exemple getV2PageReacts

Copy

const tenantId: string = "tenant-42";
const urlId: string = "article-9876";
const ssoToken: string = "sso-abc123";
const reactsWithSso: GetV2PageReacts = await getV2PageReacts(tenantId, urlId, ssoToken);
const reactsWithoutSso: GetV2PageReacts = await getV2PageReacts(tenantId, urlId);

getV2PageReactUsers

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
urlId	string	Yes
id	string	Yes
sso	string	No

Réponse

Renvoie : GetV2PageReactUsersResponse

Exemple

Exemple getV2PageReactUsers

Copy

async function demoGetUsers() {
  const tenantId: string = "d4e5f6a7-89ab-4cde-f012-3456789abcde";
  const urlId: string = "blog/2024/06/fastcomments-typescript";
  const userId: string = "user_123456789";
  const ssoToken: string = "sso_token_abcdef123456";
  const responseWithSso: GetV2PageReactUsersResponse = await getV2PageReactUsers(tenantId, urlId, userId, ssoToken);
  const responseWithoutSso: GetV2PageReactUsersResponse = await getV2PageReactUsers(tenantId, urlId, userId);
}

addPage

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
createAPIPageData	CreateAPIPageData	Oui

Réponse

Retourne : AddPageAPIResponse

Exemple

Exemple addPage

Copy

const tenantId: string = "tenant_9f8432b1-4c2e-4f9d-8a5d-7bc9e2f6d9a0";
const pageData: CreateAPIPageData = {
    url: "https://example.com/articles/fastcomments-intro",
    title: "FastComments Introduction",
    description: "An introductory guide to FastComments API usage.",
    tags: ["fastcomments", "api", "tutorial"],
    metadata: {
        author: "Jane Doe",
        publishedAt: "2024-03-15T08:00:00Z"
    }
};
const response: AddPageAPIResponse = await addPage(tenantId, pageData);

deletePage

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Retourne : DeletePageAPIResponse

Exemple

Exemple deletePage

Copy

async function example() {
    const tenantId: string = "acme-corp-001";
    const pageId: string = "page-987654321";
    const result: DeletePageAPIResponse = await deletePage(tenantId, pageId);
    console.log(result);
}
example();

getOfflineUsers

Past commenters on the page who are NOT currently online. Sorted by displayName.
Use this after exhausting /users/online to render a "Members" section.
Cursor pagination on commenterName: server walks the partial {tenantId, urlId, commenterName}
index from afterName forward via $gt, no $skip cost.

Parameters

Nom	Type	Obligatoire
tenantId	string	Oui
urlId	string	Oui
afterName	string	Non
afterUserId	string	Non

Response

Returns: PageUsersOfflineResponse

Example

Exemple getOfflineUsers

Copy

async function fetchOfflineUsers(): Promise<void> {
  const tenantId: string = "tenant_12345";
  const urlId: string = "page_9876";
  const afterName: string = "John Doe";
  const afterUserId: string = "user_abc123";
  const offlineResponse: PageUsersOfflineResponse = await getOfflineUsers(
    tenantId,
    urlId,
    afterName,
    afterUserId
  );
  console.log(offlineResponse);
}

getOnlineUsers

Visionneurs actuellement en ligne d'une page : personnes dont la session websocket est abonnée à la page en ce moment.
Retourne anonCount + totalCount (abonnés à la salle, y compris les visionneurs anonymes que nous n'énumérons pas).

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
urlId	string	Oui
afterName	string	Non
afterUserId	string	Non

Réponse

Retourne : PageUsersOnlineResponse

Exemple

Exemple getOnlineUsers

Copy

async function fetchOnlineUsers() {
  const tenantId: string = "tenant_12345";
  const urlId: string = "article-9876";
  const afterName: string | undefined = "john_doe";
  const afterUserId: string | undefined = "user_456";
  const onlineUsers: PageUsersOnlineResponse = await getOnlineUsers(
    tenantId,
    urlId,
    afterName,
    afterUserId
  );
  console.log(onlineUsers);
}
fetchOnlineUsers();

getPageByURLId

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Yes
urlId	string	Yes

Réponse

Retourne : GetPageByURLIdAPIResponse

Exemple

Exemple getPageByURLId

Copy

(async () => {
  const tenantId: string = "tenant_12345";
  const urlId: string = "url_9876";
  const response: GetPageByURLIdAPIResponse = await getPageByURLId(tenantId, urlId);
  const page: APIPage | undefined = response.page;
})();

getPages

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui

Réponse

Renvoie : GetPagesAPIResponse

Exemple

Exemple getPages

Copy

const tenantId: string = "tenant_12345";
(async () => {
  const response: GetPagesAPIResponse = await getPages(tenantId);
  const firstPage: APIPage | undefined = response.pages?.[0];
  console.log(firstPage?.title);
})();

getPagesPublic

Liste les pages d'un locataire. Utilisé par le client de bureau FChat pour remplir sa liste de salles. Nécessite que enableFChat soit vrai dans la configuration personnalisée résolue pour chaque page. Les pages qui nécessitent SSO sont filtrées en fonction de l'accès aux groupes de l'utilisateur demandeur.

Parameters

Nom	Type	Obligatoire
tenantId	string	Oui
cursor	string	Non
limit	number	Non
q	string	Non
sortBy	PagesSortBy	Non
hasComments	boolean	Non

Réponse

Renvoie : GetPublicPagesResponse

Exemple

Exemple getPagesPublic

Copy

async function fetchPublicPages() {
  const tenantId: string = "tenant_12345";
  const cursor: string = "page_5";
  const limit: number = 20;
  const query: string = "support";
  const hasComments: boolean = true;
  const response: GetPublicPagesResponse = await getPagesPublic(
    tenantId,
    cursor,
    limit,
    query,
    undefined,
    hasComments
  );
  console.log(response);
}

getUsersInfo

Bulk user info for a tenant. Given userIds, return display info from User / SSOUser.
Utilisé par le widget de commentaires pour enrichir les utilisateurs qui viennent d'apparaître via un événement de présence.
Pas de contexte de page : la confidentialité est appliquée uniformément (les profils privés sont masqués).

Parameters

Nom	Type	Obligatoire	Description
tenantId	string	Oui
ids	string	Oui

Response

Returns: PageUsersInfoResponse

Example

Exemple getUsersInfo

Copy

async function fetchUsersInfo(): Promise<void> {
  const tenantId: string = "tenant_12345";
  const ids: string = "user_001,user_002";
  const response: PageUsersInfoResponse = await getUsersInfo(tenantId, ids);
  console.log(response);
}
fetchUsersInfo();

patchPage

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
updateAPIPageData	UpdateAPIPageData	Oui

Réponse

Retourne : PatchPageAPIResponse

Exemple

Exemple patchPage

Copy

(async () => {
  const tenantId: string = "tenant_12345";
  const pageId: string = "page_98765";
  const updateData: UpdateAPIPageData = {
    title: "Updated FAQ Page"
    // description?: string peut être omis
  };
  const response: PatchPageAPIResponse = await patchPage(tenantId, pageId, updateData);
})();

deletePendingWebhookEvent

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple de deletePendingWebhookEvent

Copy

async function runDeletion() {
  const tenantId: string = "tenant-42f7b9c2";
  const eventId: string = "webhook-event-8a7d6c5b";
  const result: APIEmptyResponse = await deletePendingWebhookEvent(tenantId, eventId);
  console.log(result);
}

getPendingWebhookEventCount

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
commentId	string	No
externalId	string	No
eventType	string	No
type	string	No
domain	string	No
attemptCountGT	number	No

Réponse

Renvoie : GetPendingWebhookEventCountResponse

Exemple

Exemple getPendingWebhookEventCount

Copy

async function runExample() {
  const tenantId: string = "tenant_42";
  const commentId: string = "comment_1001";
  const eventType: string = "comment.deleted";
  const domain: string = "myblog.com";
  const result: GetPendingWebhookEventCountResponse = await getPendingWebhookEventCount(
    tenantId,
    commentId,
    undefined,
    eventType,
    undefined,
    domain
  );
  console.log(result);
}
runExample();

getPendingWebhookEvents

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Non
externalId	string	Non
eventType	string	Non
type	string	Non
domain	string	Non
attemptCountGT	number	Non
skip	number	Non

Réponse

Renvoie : GetPendingWebhookEventsResponse

Exemple

Exemple getPendingWebhookEvents

Copy

const tenantId: string = "123e4567-e89b-12d3-a456-426614174000";
const commentId: string = "cmt_987654321";
const externalId: string = "ext_abc123";
const eventType: string = "comment_created";
const type: string = "outbound";
const domain: string = "myblog.com";
const attemptCountGT: number = 2;
const skip: number = 10;
const pendingEvents: GetPendingWebhookEventsResponse = await getPendingWebhookEvents(
  tenantId,
  commentId,
  externalId,
  eventType,
  type,
  domain,
  attemptCountGT,
  skip
);

createPollVote

Enregistrez un vote sur un sondage, ou déplacez un vote existant vers une autre option. Un électeur ne peut avoir qu’un seul vote par sondage, donc appeler cette fonction à nouveau pour le même électeur déplace son vote plutôt que d’en ajouter un.

Cela respecte les paramètres de sondage du site : si le vote est limité aux utilisateurs connectés, un vote avec uniquement un anonUserId est rejeté, et les votes anonymes sont limités en fréquence par IP et par sondage.

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Yes
createPollVoteBody	CreatePollVoteBody	Yes

Réponse

Retourne : CreatePollVoteResponse

Exemple

Exemple createPollVote

Copy

(async () => {
  const tenantId: string = "acme-corp-tenant";
  const vote: CreatePollVoteBody = {
    pollId: "poll-2024-09",
    optionId: "option-A"
    // userId est optionnel et omis ici
  };
  const result: CreatePollVoteResponse = await createPollVote(tenantId, vote);
  console.log(result);
})();

deletePollVote

Retirer un vote. L'option sur laquelle il a été exprimé récupère son total.

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Retourne : DeletePollVoteResponse

Exemple

deletePollVote Exemple

Copy

async function runDeletePollVoteExample(): Promise<void> {
  const tenantId: string = "tenant_42abc";
  const pollId: string = "poll_7f9e2d";
  const result: DeletePollVoteResponse = await deletePollVote(tenantId, pollId);
  console.log(result);
}

getPollVote

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Renvoie : GetPollVoteResponse

Exemple

Exemple getPollVote

Copy

async function fetchPollVote(): Promise<void> {
  const tenantId: string = "acme-corp-tenant";
  const pollId: string = "poll-2024-05";
  const result: GetPollVoteResponse = await getPollVote(tenantId, pollId);
  const status: APIStatus = result.status;
  const vote: PublicPollVote | undefined = result.vote;
}

getPollVotes

Les votes individuels derrière le décompte d'un sondage, du plus ancien au plus récent.

Un sondage appartient à un commentaire, donc les votes sont toujours lus un sondage à la fois - commentId est requis. Cela maintient chaque requête sur les index déjà présents dans la collection.

Respecte la confidentialité du sondage : les votes d'un sondage anonyme ne peuvent pas être lus (poll-anonymous), ici ou par identifiant.

Parameters

Nom	Type	Obligatoire
tenantId	string	Yes
commentId	string	Yes
voterId	string	No
optionId	string	No
skip	number	No

Response

Returns: GetPollVotesResponse

Example

Exemple getPollVotes

Copy

const tenantId: string = "tenant_12345";
const commentId: string = "cmt_98765";
const voterId: string = "user_abc";
const optionId: string = "opt_1";
const skip: number = 20;
const pollResult: GetPollVotesResponse = await getPollVotes(
  tenantId,
  commentId,
  voterId,
  optionId,
  skip
);
console.log(pollResult);

deletePoll

Supprimez un sondage de son commentaire, ainsi que tous les votes qui y ont été castés. Le commentaire lui‑même reste inchangé.

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Yes
commentId	string	Yes

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple deletePoll

Copy

async function runDeletePoll(): Promise<void> {
  const tenantId: string = "tenant_9f8b7c6d";
  const commentId: string = "comment_a1b2c3d4";
  const result: APIEmptyResponse = await deletePoll(tenantId, commentId);
  console.log(result);
}

getPoll

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
commentId	string	Oui

Réponse

Retourne : GetPollResponse

Exemple

Exemple getPoll

Copy

const tenantId: string = "c9f1e2b4-8a3d-4f6a-9d2e-7b5c1a2f3e4d";
const commentId: string = "a1b2c3d4e5f6g7h8i9j0";
const pollResponse: GetPollResponse = await getPoll(tenantId, commentId);
const poll: CommentPoll | undefined = pollResponse.poll;
const privacy: PollPrivacy | undefined = poll?.privacy;
const options: CommentPollOption[] | undefined = poll?.options;

patchPoll

Modifiez un sondage sur place, en conservant ses résultats : changez la question, renommez une option, fermez‑ou rouvrez‑le, ou modifiez qui peut voir les votants. Les options sont identifiées par leur id — pour les ajouter, les supprimer ou les réordonner, effectuez un PUT de la liste complète.

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
commentPollPatch	CommentPollPatch	Oui

Réponse

Retourne : SavePollResponse

Exemple

Exemple de patchPoll

Copy

(async () => {
  const tenantId: string = "acme-corp";
  const commentId: string = "cmt_9876543210";
  const pollPatch: CommentPollPatch = {
    question: "Which new feature would you like to see?",
    options: [
      { id: "opt-1", label: "Dark Mode" },
      { id: "opt-2", label: "Multi-language Support" }
    ]
  };
  const response: SavePollResponse = await patchPoll(tenantId, commentId, pollPatch);
  console.log(response);
})();

putPoll

Attachez un sondage à un commentaire, ou définissez l'état complet du sondage qu'il possède déjà.

Les options sont appariées par identifiant : une option envoyée avec l'identifiant d'une option existante conserve ses votes (et prend le nouveau libellé et la nouvelle position), une option envoyée sans identifiant est ajoutée, et les options existantes omises de la liste sont supprimées ainsi que les votes qui leur ont été attribués.

Ne conserver aucun identifiant d'option existant sur un sondage qui possède des votes supprime toutes les options, il faut donc que replaceVotes=true.

Parameters

Nom	Type	Obligatoire
tenantId	string	Oui
commentId	string	Oui
commentPollPutInput	CommentPollPutInput	Oui
replaceVotes	boolean	Non

Response

Returns: SavePollResponse

Example

Exemple putPoll

Copy

const tenantId: string = "c1a2b3d4-5678-90ab-cdef-1234567890ab";
const commentId: string = "9876543210";
const optionA: CommentPollOptionInput = { text: "Dark mode" };
const optionB: CommentPollOptionInput = { text: "Light mode" };
const pollInput: CommentPollPutInput = {
  question: "Which UI theme do you prefer?",
  options: [optionA, optionB],
};
const replaceVotes: boolean = true;
const result: SavePollResponse = await putPoll(tenantId, commentId, pollInput, replaceVotes);

createQuestionConfig

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Yes
createQuestionConfigBody	CreateQuestionConfigBody	Yes

Réponse

Retourne : CreateQuestionConfigResponse

Exemple

Exemple createQuestionConfig

Copy

async function runExample() {
  const tenantId: string = "acme-corp-123";
  const customOption: QuestionConfigCustomOptionsInner = {
    key: "maxLength",
    value: 500,
  };
  const createQuestionConfigBody: CreateQuestionConfigBody = {
    name: "User Feedback",
    description: "Collect user feedback after purchase",
    enabled: true,
    customOptions: [customOption],
    // champ optionnel
    tags: ["feedback", "post-purchase"],
  };
  const response: CreateQuestionConfigResponse = await createQuestionConfig(
    tenantId,
    createQuestionConfigBody
  );
  console.log(response);
}

deleteQuestionConfig

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Renvoie : APIEmptyResponse

Exemple

deleteQuestionConfig Exemple

Copy

async function executeDeletion() {
  const tenantId: string = "tenant_12345";
  const configId: string = "config_9876";
  const result: APIEmptyResponse = await deleteQuestionConfig(tenantId, configId);
  console.log(result);
}
executeDeletion();

getQuestionConfig

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Yes
id	string	Yes

Réponse

Retourne: GetQuestionConfigResponse

Exemple

Exemple getQuestionConfig

Copy

const tenantId: string = "acme-corp-tenant";
const questionId: string = "q-987654321";
const configResponse: GetQuestionConfigResponse = await getQuestionConfig(tenantId, questionId);
const status: APIStatus = configResponse.status;
const questionConfig?: QuestionConfig = configResponse.question;
const firstOption?: QuestionConfigCustomOptionsInner = questionConfig?.customOptions?.[0];

getQuestionConfigs

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
skip	number	Non

Réponse

Retourne : GetQuestionConfigsResponse

Exemple

Exemple getQuestionConfigs

Copy

async function fetchConfigs() {
  const tenantId: string = "tenant_12345";
  const firstPage: GetQuestionConfigsResponse = await getQuestionConfigs(tenantId);
  const secondPage: GetQuestionConfigsResponse = await getQuestionConfigs(tenantId, 20);
}

updateQuestionConfig

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
updateQuestionConfigBody	UpdateQuestionConfigBody	Oui

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple de updateQuestionConfig

Copy

(async () => {
  const tenantId: string = "acme-corp-tenant";
  const questionId: string = "question-42";
  const updateBody: UpdateQuestionConfigBody = {
    title: "Revised FAQ Question"
    // isActive, customOptions, etc. sont optionnels et omis
  };
  const response: APIEmptyResponse = await updateQuestionConfig(tenantId, questionId, updateBody);
  console.log(response);
})();

createQuestionResult

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
createQuestionResultBody	CreateQuestionResultBody	Oui

Réponse

Retourne : CreateQuestionResultResponse

Exemple

createQuestionResult Exemple

Copy

const tenantId: string = "tenant_12345";
const createQuestionResultBody: CreateQuestionResultBody = {
  questionId: "q_9876",
  answer: "Yes",
  score: 5,
  meta: [
    { key: "source", value: "survey" }
  ]
};
const result: CreateQuestionResultResponse = await createQuestionResult(tenantId, createQuestionResultBody);

deleteQuestionResult

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple de deleteQuestionResult

Copy

async function runDelete() {
  const tenantId: string = "tenant_12345";
  const resultId: string = "qr_98765";
  const response: APIEmptyResponse = await deleteQuestionResult(tenantId, resultId);
  console.log(response);
}

getQuestionResult

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Retourne : GetQuestionResultResponse

Exemple

Exemple getQuestionResult

Copy

const tenantId: string = "tenant_12345";
const questionId: string = "question_98765";
const response: GetQuestionResultResponse = await getQuestionResult(tenantId, questionId);
const status: APIStatus | undefined = response.status;
const firstResult: QuestionResult | undefined = response.results?.[0];
const firstMeta: MetaItem | undefined = response.meta?.[0];
console.log(response);

getQuestionResults

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
urlId	string	Non
userId	string	Non
startDate	string	Non
questionId	string	Non
questionIds	string	Non
skip	number	Non

Réponse

Renvoie : GetQuestionResultsResponse

Exemple

Exemple getQuestionResults

Copy

async function fetchResults() {
  const tenantId: string = 'c1a2b3d4-5678-90ab-cdef-1234567890ab';
  const urlId: string = 'blog-post-789';
  const startDate: string = '2023-01-01T00:00:00Z';
  const questionIds: string = 'q-abc123,q-def456';
  const response: GetQuestionResultsResponse = await getQuestionResults(
    tenantId,
    urlId,
    undefined,
    startDate,
    undefined,
    questionIds
  );
  console.log(response);
}

updateQuestionResult

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
updateQuestionResultBody	UpdateQuestionResultBody	Oui

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple de updateQuestionResult

Copy

const tenantId: string = "c1f5e8b2-9a4d-4f3a-8d2e-6b7c9d0e1f2a";
const questionId: string = "qstn_1234567890";
const updateBody: UpdateQuestionResultBody = {
  score: 85,
  comment: "Adjusted based on new criteria",
  meta: [
    { key: "reviewer", value: "john.doe@example.com" },
    { key: "timestamp", value: new Date().toISOString() }
  ]
};
const response: APIEmptyResponse = await updateQuestionResult(tenantId, questionId, updateBody);

aggregateQuestionResults

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
questionId	string	No
questionIds	Array	No
urlId	string	No
timeBucket	AggregateTimeBucket	No
startDate	Date	No
forceRecalculate	boolean	No

Réponse

Retourne : AggregateQuestionResultsResponse

Exemple

aggregateQuestionResults Exemple

Copy

async function runAggregation() {
  const tenantId: string = '123e4567-e89b-12d3-a456-426614174000';
  const questionId: string = 'question-9f8e7d6c5b4a3';
  const questionIds: string[] = ['question-1a2b3c', 'question-4d5e6f'];
  const urlId: string = 'blog-post-2023-08-15';
  const startDate: Date = new Date('2023-01-01T00:00:00Z');
  const forceRecalculate: boolean = true;
  const result: AggregateQuestionResultsResponse = await aggregateQuestionResults(
    tenantId,
    questionId,
    questionIds,
    urlId,
    undefined,
    startDate,
    forceRecalculate
  );
}

bulkAggregateQuestionResults

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
bulkAggregateQuestionResultsRequest	BulkAggregateQuestionResultsRequest	Yes
forceRecalculate	boolean	No

Réponse

Retourne : BulkAggregateQuestionResultsResponse

Exemple

bulkAggregateQuestionResults Exemple

Copy

const tenantId: string = "tenant_12345";
const request: BulkAggregateQuestionResultsRequest = {
  items: [
    {
      questionId: "q_9876",
      startDate: "2023-01-01T00:00:00Z",
      endDate: "2023-01-31T23:59:59Z",
      timeBucket: "day"
    }
  ]
};
const response: BulkAggregateQuestionResultsResponse = await bulkAggregateQuestionResults(tenantId, request, true);

combineCommentsWithQuestionResults

Paramètres

Name	Type	Required
tenantId	string	Oui
questionId	string	Non
questionIds	Array	Non
urlId	string	Non
startDate	Date	Non
forceRecalculate	boolean	Non
minValue	number	Non
maxValue	number	Non
limit	number	Non

Réponse

Retourne : CombineQuestionResultsWithCommentsResponse

Exemple

combineCommentsWithQuestionResults Exemple

Copy

async function runExample() {
  const tenantId: string = "tenant_12345";
  const questionId: string | undefined = "q_987";
  const questionIds: string[] = ["q_001", "q_002"];
  const urlId: string | undefined = "url_abc";
  const startDate: Date = new Date("2023-01-01T00:00:00Z");
  const forceRecalculate: boolean = true;
  const minValue: number = 0;
  const maxValue: number = 100;
  const limit: number = 50;
  const result: CombineQuestionResultsWithCommentsResponse = await combineCommentsWithQuestionResults(
    tenantId,
    questionId,
    questionIds,
    urlId,
    startDate,
    forceRecalculate,
    minValue,
    maxValue,
    limit
  );
  console.log(result);
}
runExample();

addSSOUser

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
createAPISSOUserData	CreateAPISSOUserData	Oui

Réponse

Renvoie : AddSSOUserAPIResponse

Exemple

Exemple addSSOUser

Copy

const tenantId: string = "tenant_12345";
const newUser: CreateAPISSOUserData = {
  userId: "sso_user_987",
  name: "Jane Doe",
  email: "jane.doe@example.com",
  // champ optionnel
  avatarUrl: "https://example.com/avatars/jane.jpg",
};
const result: AddSSOUserAPIResponse = await addSSOUser(tenantId, newUser);

deleteSSOUser

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
deleteComments	boolean	Non
commentDeleteMode	string	Non

Réponse

Retourne : DeleteSSOUserAPIResponse

Exemple

Exemple deleteSSOUser

Copy

const tenantId: string = "acme-corp-tenant";
const userId: string = "sso-user-42";
const deleteComments: boolean = true;
const commentDeleteMode: string = "hard";
const detailedResult: DeleteSSOUserAPIResponse = await deleteSSOUser(
  tenantId,
  userId,
  deleteComments,
  commentDeleteMode
);
const simpleResult: DeleteSSOUserAPIResponse = await deleteSSOUser(
  tenantId,
  userId
);

getSSOUserByEmail

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
email	string	Oui

Réponse

Renvoie : GetSSOUserByEmailAPIResponse

Exemple

Exemple getSSOUserByEmail

Copy

async function fetchSSOUser() {
  const tenantId: string = "tenant_12345";
  const email: string = "john.doe@example.com";
  const result: GetSSOUserByEmailAPIResponse = await getSSOUserByEmail(tenantId, email);
  const user: APISSOUser | undefined = result?.user;
}

getSSOUserById

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Retourne : GetSSOUserByIdAPIResponse

Exemple

Exemple getSSOUserById

Copy

async function fetchUser() {
  const tenantId: string = "tenant-987654321";
  const userId: string = "sso-user-abc123";
  const result: GetSSOUserByIdAPIResponse = await getSSOUserById(tenantId, userId);
  const ssoUser: APISSOUser = result.user;
}

getSSOUsers

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
skip	number	Non

Réponse

Retourne : GetSSOUsersResponse

Exemple

Exemple getSSOUsers

Copy

async function runExample(): Promise<void> {
    const tenantId: string = "tenant_12345";
    // Appel sans l'optionnel `skip`
    const firstPage: GetSSOUsersResponse = await getSSOUsers(tenantId);
    // Appel avec l'optionnel `skip`
    const secondPage: GetSSOUsersResponse = await getSSOUsers(tenantId, 100);
    console.log(firstPage, secondPage);
}
runExample();

patchSSOUser

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
updateAPISSOUserData	UpdateAPISSOUserData	Oui
updateComments	boolean	Non

Réponse

Renvoie : PatchSSOUserAPIResponse

Exemple

Exemple patchSSOUser

Copy

const tenantId: string = "c1f2a3b4-5678-90ab-cdef-1234567890ab";
const userId: string = "user-987654321";
const updateData: UpdateAPISSOUserData = {
  email: "jane.smith@enterprise.com",
  displayName: "Jane Smith",
  role: "editor"
};
const responseWithComments: PatchSSOUserAPIResponse = await patchSSOUser(
  tenantId,
  userId,
  updateData,
  true
);
const responseWithoutComments: PatchSSOUserAPIResponse = await patchSSOUser(
  tenantId,
  userId,
  updateData
);

putSSOUser

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
updateAPISSOUserData	UpdateAPISSOUserData	Oui
updateComments	boolean	Non

Réponse

Renvoie : PutSSOUserAPIResponse

Exemple

Exemple putSSOUser

Copy

(async () => {
  const tenantId: string = "tenant_abc123";
  const userId: string = "user_456def";
  const updateData: UpdateAPISSOUserData = {
    email: "jane.doe@example.com",
    displayName: "Jane Doe",
    isActive: true,
  };
  const response: PutSSOUserAPIResponse = await putSSOUser(tenantId, userId, updateData, true);
})();

createSubscription

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Yes
createAPIUserSubscriptionData	CreateAPIUserSubscriptionData	Yes

Réponse

Retourne : CreateSubscriptionAPIResponse

Exemple

createSubscription Exemple

Copy

(async () => {
    const tenantId: string = "acme-corp-123";
    const subscriptionData: CreateAPIUserSubscriptionData = {
        userId: "user-456",
        planId: "premium-monthly",
        startDate: new Date(),
        trialPeriodDays: 14 // champ optionnel
    };
    const result: CreateSubscriptionAPIResponse = await createSubscription(tenantId, subscriptionData);
    console.log(result);
})();

deleteSubscription

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
userId	string	Non

Réponse

Retourne : DeleteSubscriptionAPIResponse

Exemple

Exemple deleteSubscription

Copy

(async () => {
  const tenantId: string = "tenant_9876";
  const subscriptionId: string = "sub_54321";
  const userId: string = "user_abc123";
  // With optional userId
  const responseWithUser: DeleteSubscriptionAPIResponse = await deleteSubscription(tenantId, subscriptionId, userId);
  // Without optional userId
  const responseWithoutUser: DeleteSubscriptionAPIResponse = await deleteSubscription(tenantId, subscriptionId);
})();

getSubscriptions

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Yes
userId	string	No

Réponse

Retourne : GetSubscriptionsAPIResponse

Exemple

Exemple getSubscriptions

Copy

(async () => {
    const tenantId: string = "acme-corp-123";
    const userId: string = "user-789";
    const responseWithUser: GetSubscriptionsAPIResponse = await getSubscriptions(tenantId, userId);
    const responseWithoutUser: GetSubscriptionsAPIResponse = await getSubscriptions(tenantId);
})();

updateSubscription

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
updateAPIUserSubscriptionData	UpdateAPIUserSubscriptionData	Oui
userId	string	Non

Réponse

Renvoie : UpdateSubscriptionAPIResponse

Exemple

Exemple updateSubscription

Copy

const tenantId: string = "tenant_12345";
const subscriptionId: string = "sub_98765";
const updateData: UpdateAPIUserSubscriptionData = {
  planId: "premium_plan",
  status: "active",
  renewalDate: "2024-12-31",
};
const userId: string = "user_abcde";
const response: UpdateSubscriptionAPIResponse = await updateSubscription(
  tenantId,
  subscriptionId,
  updateData,
  userId
);

getTenantDailyUsages

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
yearNumber	number	Non
monthNumber	number	Non
dayNumber	number	Non
skip	number	Non

Réponse

Renvoie : GetTenantDailyUsagesResponse

Exemple

Exemple getTenantDailyUsages

Copy

async function demoGetTenantDailyUsages() {
  const tenantId: string = "tenant_9876";
  const yearNumber: number = 2024;
  const monthNumber: number = 2;
  const dayNumber: number = 28;
  const skip: number = 10;
  const fullResult: GetTenantDailyUsagesResponse = await getTenantDailyUsages(
    tenantId,
    yearNumber,
    monthNumber,
    dayNumber,
    skip
  );
  const partialResult: GetTenantDailyUsagesResponse = await getTenantDailyUsages(
    tenantId,
    yearNumber
  );
}

createTenantPackage

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
createTenantPackageBody	CreateTenantPackageBody	Oui

Réponse

Retourne : CreateTenantPackageResponse

Exemple

Exemple createTenantPackage

Copy

async function runExample() {
  const tenantId: string = "tenant_9f8b7c6d";
  const createTenantPackageBody: CreateTenantPackageBody = {
    name: "Enterprise Package",
    priceCents: 49999,
    // champ optionnel
    description: "Full suite of enterprise features"
  };
  const result: CreateTenantPackageResponse = await createTenantPackage(tenantId, createTenantPackageBody);
  console.log(result);
}
runExample();

deleteTenantPackage

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple de deleteTenantPackage

Copy

let tenantId: string = "tenant_12345";
let packageId: string = "pkg_98765";
const result: APIEmptyResponse = await deleteTenantPackage(tenantId, packageId);

getTenantPackage

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Renvoie : GetTenantPackageResponse

Exemple

Exemple getTenantPackage

Copy

function fetchPackage(tenantId?: string, id?: string): Promise<GetTenantPackageResponse> {
    const tid: string = tenantId ?? "acme-corp-001";
    const pid: string = id ?? "premium-plan-2024";
    return getTenantPackage(tid, pid);
}
async function runExample(): Promise<void> {
    const response: GetTenantPackageResponse = await fetchPackage();
    const status: APIStatus | undefined = response.status;
    const pkg: TenantPackage | undefined = response.package;
}

getTenantPackages

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
skip	number	Non

Réponse

Retourne : GetTenantPackagesResponse

Exemple

getTenantPackages Exemple

Copy

async function fetchPackages() {
  const tenantId: string = "acme-corp-001";
  const skip: number = 15;
  const resultWithSkip: GetTenantPackagesResponse = await getTenantPackages(tenantId, skip);
  const resultWithoutSkip: GetTenantPackagesResponse = await getTenantPackages(tenantId);
}

replaceTenantPackage

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
replaceTenantPackageBody	ReplaceTenantPackageBody	Oui

Réponse

Retourne : APIEmptyResponse

Exemple

replaceTenantPackage Exemple

Copy

async function replacePackageDemo(): Promise<void> {
  const tenantId: string = "acme-corp-001";
  const packageId: string = "basic-plan-2023";
  const replaceBody: ReplaceTenantPackageBody = {
    newPackageId: "enterprise-plan-2024"
    // les champs optionnels peuvent être ajoutés ici si nécessaire
  };
  const response: APIEmptyResponse = await replaceTenantPackage(tenantId, packageId, replaceBody);
  console.log(response);
}

updateTenantPackage

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
updateTenantPackageBody	UpdateTenantPackageBody	Oui

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple de updateTenantPackage

Copy

const tenantId: string = "tenant_9f8b7c6d";
const packageId: string = "pkg_3a2b1c";
const updateBody: UpdateTenantPackageBody = {
  // les champs optionnels peuvent être omis ou inclus selon les besoins
  // newPackageName?: string;
  // renewalDate?: string;
};
const result: APIEmptyResponse = await updateTenantPackage(tenantId, packageId, updateBody);

createTenantUser

Paramètres

Name	Type	Required	Description
tenantId	string	Yes
createTenantUserBody	CreateTenantUserBody	Yes

Réponse

Renvoie : CreateTenantUserResponse

Exemple

Exemple createTenantUser

Copy

async function addTenantUser() {
  const tenantId: string = '123e4567-e89b-12d3-a456-426614174000';
  const digestFreq: DigestEmailFrequency = 'daily';
  const body: CreateTenantUserBody = {
    email: 'jane.doe@example.com',
    firstName: 'Jane',
    lastName: 'Doe',
    role: 'admin',
    digestEmailFrequency: digestFreq,
    phoneNumber: '+15551234567' // optionnel
  };
  const response: CreateTenantUserResponse = await createTenantUser(tenantId, body);
  console.log(response);
}
addTenantUser();

deleteTenantUser

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
id	string	Yes
deleteComments	string	No
commentDeleteMode	string	No

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple deleteTenantUser

Copy

(async () => {
  const tenantId: string = "acme-corp";
  const userId: string = "u-112233";
  const result1: APIEmptyResponse = await deleteTenantUser(tenantId, userId);
  const result2: APIEmptyResponse = await deleteTenantUser(tenantId, userId, "true", "hard");
  console.log(result1, result2);
})();

getTenantUser

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Yes
id	string	Yes

Réponse

Renvoie : GetTenantUserResponse

Exemple

Exemple getTenantUser

Copy

(async () => {
    const tenantId: string = "acme-tenant-001";
    const userId: string = "user-12345";
    const response: GetTenantUserResponse = await getTenantUser(tenantId, userId);
    console.log(response);
})();

getTenantUsers

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
skip	number	Non

Réponse

Retourne : GetTenantUsersResponse

Exemple

Exemple getTenantUsers

Copy

const tenantId: string = "tenant_12345";
const skip: number = 20;
const firstPage: GetTenantUsersResponse = await getTenantUsers(tenantId);
const secondPage: GetTenantUsersResponse = await getTenantUsers(tenantId, skip);

replaceTenantUser

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
id	string	Yes
replaceTenantUserBody	ReplaceTenantUserBody	Yes
updateComments	string	No

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple replaceTenantUser

Copy

const tenantId: string = "c1a2b3d4-5678-90ab-cdef-1234567890ab";
const userId: string = "user-987654321";
const replaceBody: ReplaceTenantUserBody = {
  email: "newuser@example.com",
  name: "New User",
  role: "admin"
};
const response: APIEmptyResponse = await replaceTenantUser(
  tenantId,
  userId,
  replaceBody,
  "Migrated user to new tenant"
);

sendLoginLink

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
id	string	Yes
redirectURL	string	No

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple de sendLoginLink

Copy

interface APIStatus {
  // champs d'état
}
interface APIEmptyResponse {
  status: APIStatus;
}
(async () => {
  const tenantId: string = "acme-corp";
  const userId: string = "user-98765";
  const redirectURL: string = "https://app.example.com/welcome";
  const responseWithRedirect: APIEmptyResponse = await sendLoginLink(tenantId, userId, redirectURL);
  const responseWithoutRedirect: APIEmptyResponse = await sendLoginLink(tenantId, userId);
})();

updateTenantUser

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
updateTenantUserBody	UpdateTenantUserBody	Oui
updateComments	string	Non

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple de updateTenantUser

Copy

async function runUpdate() {
  const tenantId: string = "tenant_12345";
  const userId: string = "user_987";
  const updateBody: UpdateTenantUserBody = {
    email: "new.email@example.com",
    role: "admin",
    isActive: true
  };
  const comment: string = "Promoted to admin role";
  const result: APIEmptyResponse = await updateTenantUser(tenantId, userId, updateBody, comment);
  console.log(result);
}
runUpdate();

createTenant

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Yes
createTenantBody	CreateTenantBody	Yes

Réponse

Retourne : CreateTenantResponse

Exemple

Exemple createTenant

Copy

async function run() {
  const tenantId: string = "acme-corp-2024";
  const createTenantBody: CreateTenantBody = {
    name: "Acme Corp",
    domainConfiguration: { domain: "comments.acme.com", sslEnabled: true },
    importedSite: { siteId: "site-123", source: "wordpress" },
    billingInfo: { plan: "enterprise", renewalDate: "2025-01-01" },
    description: "Tenant for Acme Corp's production environment", // optionnel
  };
  const response: CreateTenantResponse = await createTenant(tenantId, createTenantBody);
}
run();

deleteTenant

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
sure	string	Non

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple deleteTenant

Copy

async function main(): Promise<void> {
  const tenantId: string = "tenant_12345";
  const userId: string = "user_9876";
  const resultWithoutSure: APIEmptyResponse = await deleteTenant(tenantId, userId);
  const resultWithSure: APIEmptyResponse = await deleteTenant(tenantId, userId, "confirm");
}
main();

getTenant

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Retourne : GetTenantResponse

Exemple

getTenant Exemple

Copy

async function fetchTenant(): Promise<void> {
    const tenantId: string = "tenant_12345";
    const id: string = "tenant_12345";
    const tenantResponse: GetTenantResponse = await getTenant(tenantId, id);
    // Champs optionnels dans la réponse
    const billing: BillingInfo | undefined = tenantResponse.billingInfo;
    const domainConfig: APIDomainConfiguration | undefined = tenantResponse.domainConfiguration;
}

getTenants

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
meta	string	Non
skip	number	Non

Réponse

Retourne : GetTenantsResponse

Exemple

Exemple getTenants

Copy

async function runExample() {
    const tenantId: string = "c3f5e9b2-4d1a-4f2b-9a6e-1234567890ab";
    const meta: string = "includeBilling";
    const skip: number = 10;
    const result: GetTenantsResponse = await getTenants(tenantId, meta, skip);
    console.log(result);
}
runExample();

updateTenant

Paramètres

Name	Type	Required
tenantId	string	Yes
id	string	Yes
updateTenantBody	UpdateTenantBody	Yes

Réponse

Renvoie : APIEmptyResponse

Exemple

Exemple updateTenant

Copy

async function runUpdateTenant() {
  const tenantId: string = "tenant-abc123";
  const id: string = "config-456def";
  const updateTenantBody: UpdateTenantBody = {
    // champ requis
    name: "Acme International",
    // les champs optionnels peuvent être omis, par ex., billingInfo, domainConfiguration
  };
  const response: APIEmptyResponse = await updateTenant(tenantId, id, updateTenantBody);
  console.log(response);
}

changeTicketState

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
userId	string	Oui
id	string	Oui
changeTicketStateBody	ChangeTicketStateBody	Oui

Réponse

Renvoie : ChangeTicketStateResponse

Exemple

Exemple changeTicketState

Copy

(async () => {
  const tenantId: string = "acme-corp";
  const userId: string = "john.doe";
  const ticketId: string = "ticket-20230915-001";
  const changeTicketStateBody: ChangeTicketStateBody = {
    // exemple de champ optionnel
    note: "Resolved after investigation"
  };
  const response: ChangeTicketStateResponse = await changeTicketState(
    tenantId,
    userId,
    ticketId,
    changeTicketStateBody
  );
  console.log(response);
})();

createTicket

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
userId	string	Yes
createTicketBody	CreateTicketBody	Yes

Réponse

Retourne : CreateTicketResponse

Exemple

Exemple createTicket

Copy

async function submitTicket() {
  const tenantId: string = "acme-corp";
  const userId: string = "user-9876";
  const ticketBody: CreateTicketBody = {
    subject: "Login issues after password reset",
    description: "User reports being unable to log in despite using the new password.",
    priority: "medium",
    // champ optionnel dans CreateTicketBody
    tags: ["login", "password-reset"]
  };
  const response: CreateTicketResponse = await createTicket(tenantId, userId, ticketBody);
  console.log(response);
}
submitTicket();

getTicket

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
id	string	Yes
userId	string	No

Réponse

Retourne : GetTicketResponse

Exemple

Exemple getTicket

Copy

async function fetchTickets() {
  const tenantId: string = "acme-corp";
  const ticketId: string = "ticket-12345";
  const userId: string = "user-9876";
  const ticketWithUser: GetTicketResponse = await getTicket(tenantId, ticketId, userId);
  const ticketWithoutUser: GetTicketResponse = await getTicket(tenantId, ticketId);
}

getTickets

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
userId	string	Non
state	number	Non
skip	number	Non
limit	number	Non

Réponse

Renvoie : GetTicketsResponse

Exemple

Exemple getTickets

Copy

(async () => {
  const tenantId: string = "tenant_12345";
  const ticketsSimple: GetTicketsResponse = await getTickets(tenantId);
  const userId: string = "user_9876";
  const state: number = 1; // par ex., ouvert
  const skip: number = 0;
  const limit: number = 20;
  const ticketsFull: GetTicketsResponse = await getTickets(
    tenantId,
    userId,
    state,
    skip,
    limit
  );
})();

getTranslations

Paramètres

Nom	Type	Obligatoire
namespace	string	Yes
component	string	Yes
locale	string	No
useFullTranslationIds	boolean	No

Réponse

Retourne : GetTranslationsResponse

Exemple

Exemple getTranslations

Copy

async function fetchTranslations() {
  const adminDashboard: GetTranslationsResponse = await getTranslations('admin', 'dashboard');
  const userProfileFr: GetTranslationsResponse = await getTranslations('user', 'profile', 'fr-FR', true);
}

uploadImage

Upload and resize an image

Parameters

Nom	Type	Obligatoire
tenantId	string	Yes
file	Blob	Yes
sizePreset	SizePreset	No
urlId	string	No

Response

Renvoie : UploadImageResponse

Example

Exemple uploadImage

Copy

const tenantId: string = "acme-tenant-01";
const imageBlob: Blob = new Blob([new Uint8Array([137,80,78,71])], { type: "image/png" });
const uploadResult1: UploadImageResponse = await uploadImage(tenantId, imageBlob);
const sizePreset: SizePreset = { presetName: "medium" };
const urlId: string = "article-9876";
const uploadResult2: UploadImageResponse = await uploadImage(tenantId, imageBlob, sizePreset, urlId);

getUserBadgeProgressById

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Retourne : APIGetUserBadgeProgressResponse

Exemple

Exemple getUserBadgeProgressById

Copy

const tenantId: string = "acme-corp-tenant";
const badgeId: string = "badge-2024-07";
const result: APIGetUserBadgeProgressResponse = await getUserBadgeProgressById(tenantId, badgeId);
const progress: UserBadgeProgress | undefined = result?.progress;
const status: APIStatus | undefined = result?.status;

getUserBadgeProgressByUserId

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Yes
userId	string	Yes

Réponse

Retourne : APIGetUserBadgeProgressResponse

Exemple

Exemple getUserBadgeProgressByUserId

Copy

const tenantId: string = "acme-corp";
const userId: string = "user-42";
const badgeProgress: APIGetUserBadgeProgressResponse = await getUserBadgeProgressByUserId(tenantId, userId);
if (badgeProgress.status?.code !== undefined) {
  const statusCode: number = badgeProgress.status.code;
}
if (badgeProgress.progress?.length) {
  const firstProgress: UserBadgeProgress = badgeProgress.progress[0];
}

getUserBadgeProgressList

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
userId	string	No
limit	number	No
skip	number	No

Réponse

Retourne : APIGetUserBadgeProgressListResponse

Exemple

Exemple getUserBadgeProgressList

Copy

(async () => {
  const tenantId: string = "tenant-9f8b7c6d";
  const userId: string = "user-123e4567-e89b-12d3-a456-426614174000";
  const limit: number = 10;
  const skip: number = 0;
  const response: APIGetUserBadgeProgressListResponse = await getUserBadgeProgressList(tenantId, userId, limit, skip);
  const status: APIStatus = response.status;
  const badges: UserBadgeProgress[] = response.badges;
})();

createUserBadge

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
createUserBadgeParams	CreateUserBadgeParams	Oui

Réponse

Renvoie : APICreateUserBadgeResponse

Exemple

Exemple createUserBadge

Copy

async function main(): Promise<void> {
  const tenantId: string = "tenant_9f8b7c";
  const badgeParams: CreateUserBadgeParams = {
    name: "Community Helper",
    iconUrl: "https://cdn.example.com/badges/helper.png"
  };
  const response: APICreateUserBadgeResponse = await createUserBadge(tenantId, badgeParams);
}
main();

deleteUserBadge

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Yes
id	string	Yes

Réponse

Retourne : APIEmptySuccessResponse

Exemple

deleteUserBadge Exemple

Copy

(async () => {
  const tenantId: string = "acme-corp";
  const badgeId: string = "moderator-badge";
  const result: APIEmptySuccessResponse = await deleteUserBadge(tenantId, badgeId);
  console.log(result);
})();

getUserBadge

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
id	string	Oui

Réponse

Retourne : APIGetUserBadgeResponse

Exemple

Exemple getUserBadge

Copy

async function demoGetUserBadge() {
    const tenantId: string = "tenant-9f8b7c6d";
    const userId: string = "user-123456";
    const badgeResponse: APIGetUserBadgeResponse = await getUserBadge(tenantId, userId);
}

getUserBadges

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
userId	string	Non
badgeId	string	Non
type	number	Non
displayedOnComments	boolean	Non
limit	number	Non
skip	number	Non

Réponse

Retourne : APIGetUserBadgesResponse

Exemple

Exemple getUserBadges

Copy

(async () => {
  const tenantId: string = "acme-corp";
  // Tous les paramètres fournis
  const fullResponse: APIGetUserBadgesResponse = await getUserBadges(
    tenantId,
    "user-42",
    "badge-premium",
    1,
    true,
    10,
    0
  );
  // Seulement les paramètres obligatoires et un paramètre optionnel (limit)
  const limitedResponse: APIGetUserBadgesResponse = await getUserBadges(
    tenantId,
    undefined,
    undefined,
    undefined,
    undefined,
    5
  );
  console.log(fullResponse, limitedResponse);
})();

updateUserBadge

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
id	string	Oui
updateUserBadgeParams	UpdateUserBadgeParams	Oui

Réponse

Retourne : APIEmptySuccessResponse

Exemple

Exemple de updateUserBadge

Copy

const tenantId: string = "tenant-9f8b7c6d";
const id: string = "user-4a3b2c1d";
const updateParams: UpdateUserBadgeParams = {
  badgeId: "badge-premium",
  // champ optionnel
  expiresAt: new Date("2025-12-31T23:59:59Z")
};
const result: APIEmptySuccessResponse = await updateUserBadge(tenantId, id, updateParams);

getUserNotificationCount

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
sso	string	Non

Réponse

Retourne : GetUserNotificationCountResponse

Exemple

Exemple getUserNotificationCount

Copy

async function demo(): Promise<void> {
  const tenantId: string = "acme-corp-001";
  const ssoToken: string = "sso-token-xyz789";
  const countWithoutSso: GetUserNotificationCountResponse = await getUserNotificationCount(tenantId);
  const countWithSso: GetUserNotificationCountResponse = await getUserNotificationCount(tenantId, ssoToken);
}
demo();

getUserNotifications

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
urlId	string	Non
pageSize	number	Non
afterId	string	Non
includeContext	boolean	Non
afterCreatedAt	number	Non
unreadOnly	boolean	Non
dmOnly	boolean	Non
noDm	boolean	Non
includeTranslations	boolean	Non
includeTenantNotifications	boolean	Non
sso	string	Non

Réponse

Renvoie : GetMyNotificationsResponse

Exemple

Exemple getUserNotifications

Copy

async function fetchNotifications(): Promise<void> {
  const tenantId: string = "acme-corp";
  const urlId: string = "article-42";
  const pageSize: number = 20;
  const includeContext: boolean = true;
  const unreadOnly: boolean = true;
  const notifications: GetMyNotificationsResponse = await getUserNotifications(
    tenantId,
    urlId,
    pageSize,
    undefined,
    includeContext,
    undefined,
    unreadOnly
  );
  console.log(notifications);
}

resetUserNotificationCount

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Oui
sso	string	Non

Réponse

Retourne : ResetUserNotificationsResponse

Exemple

resetUserNotificationCount Exemple

Copy

async function demoReset() {
  const tenantId: string = "tenant_12345";
  const ssoToken: string = "sso_abcdef123456";
  const resultWithSso: ResetUserNotificationsResponse = await resetUserNotificationCount(tenantId, ssoToken);
  const resultWithoutSso: ResetUserNotificationsResponse = await resetUserNotificationCount(tenantId);
}
demoReset();

resetUserNotifications

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
afterId	string	Non
afterCreatedAt	number	Non
unreadOnly	boolean	Non
dmOnly	boolean	Non
noDm	boolean	Non
sso	string	Non

Réponse

Renvoie : ResetUserNotificationsResponse

Exemple

resetUserNotifications Exemple

Copy

(async () => {
  const tenantId: string = "acme-corp";
  const afterId: string = "notif-2023-09-01";
  const afterCreatedAt: number = 1693526400; // horodatage Unix
  const unreadOnly: boolean = true;
  const dmOnly: boolean = false;
  const response: ResetUserNotificationsResponse = await resetUserNotifications(
    tenantId,
    afterId,
    afterCreatedAt,
    unreadOnly,
    dmOnly
  );
  console.log(response);
})();

updateUserNotificationCommentSubscriptionStatus

Activer ou désactiver les notifications pour un commentaire spécifique.

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
notificationId	string	Yes
optedInOrOut	UpdateUserNotificationCommentSubscriptionStatusOptedInOrOutEnum	Yes
commentId	string	Yes
sso	string	No

Réponse

Retourne : UpdateUserNotificationCommentSubscriptionStatusResponse

Exemple

Exemple de updateUserNotificationCommentSubscriptionStatus

Copy

async function runExample(): Promise<void> {
  const tenantId: string = "tenant_12345";
  const notificationId: string = "notif_9876";
  const commentId: string = "comment_abc123";
  const optedInOrOut: UpdateUserNotificationCommentSubscriptionStatusOptedInOrOutEnum =
    UpdateUserNotificationCommentSubscriptionStatusOptedInOrOutEnum.OptIn;
  const sso: string = "sso_token_456";
  const resultWithSso: UpdateUserNotificationCommentSubscriptionStatusResponse = await updateUserNotificationCommentSubscriptionStatus(
    tenantId,
    notificationId,
    optedInOrOut,
    commentId,
    sso
  );
  const resultWithoutSso: UpdateUserNotificationCommentSubscriptionStatusResponse = await updateUserNotificationCommentSubscriptionStatus(
    tenantId,
    notificationId,
    optedInOrOut,
    commentId
  );
}

updateUserNotificationPageSubscriptionStatus

Enable ou désactiver les notifications pour une page. Lorsque les utilisateurs sont abonnés à une page, des notifications sont créées pour les nouveaux commentaires racine, et également

Parameters

Nom	Type	Obligatoire
tenantId	string	Yes
urlId	string	Yes
url	string	Yes
pageTitle	string	Yes
subscribedOrUnsubscribed	UpdateUserNotificationPageSubscriptionStatusSubscribedOrUnsubscribedEnum	Yes
sso	string	No

Response

Retourne : UpdateUserNotificationPageSubscriptionStatusResponse

Example

Exemple de updateUserNotificationPageSubscriptionStatus

Copy

async function runExample() {
  const tenantId: string = "tenant_12345";
  const urlId: string = "url_9876";
  const url: string = "https://example.com/articles/awesome-article";
  const pageTitle: string = "Awesome Article";
  const subscribedOrUnsubscribed: UpdateUserNotificationPageSubscriptionStatusSubscribedOrUnsubscribedEnum =
    UpdateUserNotificationPageSubscriptionStatusSubscribedOrUnsubscribedEnum.Subscribed;
  const sso: string = "sso_token_abc";
  const response: UpdateUserNotificationPageSubscriptionStatusResponse = await updateUserNotificationPageSubscriptionStatus(
    tenantId,
    urlId,
    url,
    pageTitle,
    subscribedOrUnsubscribed,
    sso
  );
  console.log(response);
}
runExample();

updateUserNotificationStatus

Paramètres

Name	Type	Required
tenantId	string	Yes
notificationId	string	Yes
newStatus	UpdateUserNotificationStatusNewStatusEnum	Yes
sso	string	No

Réponse

Retourne : UpdateUserNotificationStatusResponse

Exemple

Exemple de updateUserNotificationStatus

Copy

const tenantId: string = "tenant_12345";
const notificationId: string = "notif_9876";
const newStatus: UpdateUserNotificationStatusNewStatusEnum = UpdateUserNotificationStatusNewStatusEnum.READ;
const ssoToken: string = "sso_token_abc";
const responseWithSso: UpdateUserNotificationStatusResponse = await updateUserNotificationStatus(
  tenantId,
  notificationId,
  newStatus,
  ssoToken
);
const responseWithoutSso: UpdateUserNotificationStatusResponse = await updateUserNotificationStatus(
  tenantId,
  notificationId,
  newStatus
);

getUserPresenceStatuses

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
urlIdWS	string	Oui
userIds	string	Oui

Réponse

Renvoie : GetUserPresenceStatusesResponse

Exemple

Exemple getUserPresenceStatuses

Copy

(async () => {
  const tenantId: string = "my-tenant-42";
  const urlIdWS: string = "post-9876";
  const userIds: string = "alice,bob,carol";
  const presence: GetUserPresenceStatusesResponse = await getUserPresenceStatuses(tenantId, urlIdWS, userIds);
  console.log(presence);
})();

searchUsers

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
urlId	string	Oui
usernameStartsWith	string	Non
mentionGroupIds	Array	Non
sso	string	Non
searchSection	SearchUsersSearchSectionEnum	Non

Réponse

Renvoie : SearchUsersResult

Exemple

Exemple searchUsers

Copy

async function example() {
  const tenantId: string = "tenant_12345";
  const urlId: string = "article-9876";
  const usernameStartsWith: string = "john";
  const mentionGroupIds: string[] = ["group1", "group2"];
  const sso: string = "sso_token_abc";
  const searchSection: SearchUsersSearchSectionEnum = SearchUsersSearchSectionEnum.MENTIONS;
  const result: SearchUsersResult = await searchUsers(
    tenantId,
    urlId,
    usernameStartsWith,
    mentionGroupIds,
    sso,
    searchSection
  );
  console.log(result);
}

getUser

Paramètres

Name	Type	Required	Description
tenantId	string	Oui
id	string	Oui

Réponse

Renvoie : GetUserResponse

Exemple

Exemple getUser

Copy

async function main(): Promise<void> {
  const tenantId: string = "tenant_12345";
  const id: string = "user_98765";
  const response: GetUserResponse = await getUser(tenantId, id);
  const { user }: { user?: User } = response;
}
main();

createVote

Paramètres

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
direction	CreateVoteDirectionEnum	Yes
userId	string	No
anonUserId	string	No

Réponse

Returns: VoteResponse

Exemple

createVote Exemple

Copy

const tenantId: string = "tenant_12345";
const commentId: string = "comment_67890";
const direction: CreateVoteDirectionEnum = CreateVoteDirectionEnum.UP;
const userId: string = "user_abcde";
const voteResult: VoteResponse = await createVote(tenantId, commentId, direction, userId);
const anonUserId: string = "anon_zyxwv";
const anonVoteResult: VoteResponse = await createVote(tenantId, commentId, direction, undefined, anonUserId);

deleteVote

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
id	string	Yes
editKey	string	No

Réponse

Retourne : VoteDeleteResponse

Exemple

Exemple deleteVote

Copy

async function run() {
  const tenantId: string = "tenant_12345";
  const commentId: string = "comment_98765";
  const editKey: string = "edit_abcde";
  const responseWithKey: VoteDeleteResponse = await deleteVote(tenantId, commentId, editKey);
  const responseWithoutKey: VoteDeleteResponse = await deleteVote(tenantId, commentId);
}
run();

getVotes

Paramètres

Name	Type	Required	Description
tenantId	string	Yes
urlId	string	Yes

Réponse

Retourne : GetVotesResponse

Exemple

Exemple getVotes

Copy

const tenantId: string = "tenant_12345";
const urlId: string = "article-67890";
(async () => {
  const votesResponse: GetVotesResponse = await getVotes(tenantId, urlId);
  // Exemple d'accès à une propriété optionnelle de la réponse
  const firstVote: PublicVote | undefined = votesResponse.votes?.[0];
})();

getVotesForUser

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
urlId	string	Oui
userId	string	Non
anonUserId	string	Non

Réponse

Retourne : GetVotesForUserResponse

Exemple

Exemple getVotesForUser

Copy

async function demo() {
  const tenantId: string = "tenant_12345";
  const urlId: string = "post_9876";
  const userId: string = "user_abcde";
  const anonUserId: string = "anon_5678";
  const responseWithUser: GetVotesForUserResponse = await getVotesForUser(tenantId, urlId, userId);
  const responseWithAnon: GetVotesForUserResponse = await getVotesForUser(tenantId, urlId, undefined, anonUserId);
}
demo();

createWebhook

Abonne une URL à un événement de commentaire (abonnement REST hook). S'abonner la même URL au même
événement et domaine à nouveau renvoie l'abonnement existant. Les livraisons sont signées HMAC, voir le
guide des webhooks ; l'en‑tête token hérité n'est jamais envoyé aux abonnements API.

Parameters

Nom	Type	Obligatoire	Description
tenantId	string	Oui
createWebhookParams	CreateWebhookParams	Oui

Response

Returns: CreateWebhookResponse

Example

Exemple createWebhook

Copy

const tenantId: string = "tenant_9f8b7c6d";
const webhookParams: CreateWebhookParams = {
  event: "comment.created" as WebhookEventName,
  method: "POST" as WebhookHTTPMethod,
  url: "https://myapp.example.com/webhook",
  source: "comment" as WebhookSource,
  // secret optionnel pour la vérification de la charge utile
  secret: "s3cr3tK3y123",
};
const result: CreateWebhookResponse = await createWebhook(tenantId, webhookParams);
const webhookId: string = result.webhook.id;

deleteWebhook

Désabonnements (REST hook unsubscribe). Seules les souscriptions créées via cette API peuvent être supprimées ici ; les webhooks gérés depuis le tableau de bord sont modifiés dans le tableau de bord.

Paramètres

Nom	Type	Obligatoire	Description
tenantId	string	Yes
id	string	Yes

Réponse

Retourne : APIEmptyResponse

Exemple

Exemple deleteWebhook

Copy

const tenantId: string = "tenant_12345";
const webhookId: string = "wh_98765";
const result: APIEmptyResponse = await deleteWebhook(tenantId, webhookId);

getWebhooks

Répertorie les webhooks configurés pour le locataire, à la fois les lignes gérées via le tableau de bord et les abonnements API.

Paramètres

Nom	Type	Obligatoire
tenantId	string	Oui
event	WebhookEventName	Non
domain	string	Non
source	WebhookSource	Non
skip	number	Non

Réponse

Renvoie : GetWebhooksResponse

Exemple

Exemple getWebhooks

Copy

(async () => {
  const tenantId: string = 'tenant_42';
  const event: WebhookEventName = 'comment.created';
  const domain: string = 'forum.example.org';
  const source: WebhookSource = 'admin';
  const skip: number = 0;
  const fullResponse: GetWebhooksResponse = await getWebhooks(tenantId, event, domain, source, skip);
  const minimalResponse: GetWebhooksResponse = await getWebhooks(tenantId);
})();

getWebhookSamplePayloads

Commentaires récents dans exactement la forme utilisée par les livraisons de webhook, pour créer des intégrations (par exemple les données d'exemple Zapier). Chaque événement délivre le même objet commentaire, de sorte que event n'a besoin d'être que valide.

Paramètres

Nom	Type	Obligatoire
tenantId	string	Yes
event	WebhookEventName	No
limit	number	No

Réponse

Retourne : GetWebhookSamplePayloadsResponse

Exemple

Exemple getWebhookSamplePayloads

Copy

const tenantId: string = "c1a2b3d4-5678-90ab-cdef-1234567890ab";
const responseAll: GetWebhookSamplePayloadsResponse = await getWebhookSamplePayloads(
  tenantId,
  "comment.created",
  10
);
const responseWithEvent: GetWebhookSamplePayloadsResponse = await getWebhookSamplePayloads(
  tenantId,
  "comment.created"
);
const responseBasic: GetWebhookSamplePayloadsResponse = await getWebhookSamplePayloads(
  tenantId
);

Besoin d'aide ?

Si vous rencontrez des problèmes ou avez des questions concernant le SDK JavaScript/TypeScript, veuillez :

Contribuer

Les contributions sont les bienvenues ! Veuillez consulter le dépôt GitHub pour les consignes de contribution.

Langue 🇫🇷 Français (France)

Documentation

Commencer

Référence API

Utilisation

Locataires d'agent

Agrégation

Journaux d'audit

Blocage depuis le commentaire

Vérifier les commentaires bloqués

Commentaires

Commentaires pour l'utilisateur

Configurations de domaine

Modèles d'email

Journal d'événements

Publications du fil

Signaler le commentaire

GIFs

Hashtags

Moi

Modération

Modérateurs

Nombre de notifications

Notifications

Réactions de page

Pages

Événements webhook en attente

Votes de sondage

Sondages

Configurations de question

Résultats de question

Agrégation des résultats de question

Utilisateurs SSO

Abonnements

Utilisation quotidienne du locataire

Forfaits de locataire

Utilisateurs du locataire

Locataires

Tickets

Traductions

Télécharger une image

Progression du badge utilisateur

Badges utilisateur

Notifications utilisateur

Statut de présence utilisateur

Recherche d'utilisateurs

Utilisateurs

Votes

Webhooks

SDK FastComments JavaScript/TypeScript

Dépôt

Agents de codage IA

Installation

Documentation de l'API

Référence complète de l'API: docs/api/README.md

Compatibilité Navigateur vs Serveur

Utilisation

Utilisation dans le navigateur (côté client)

Utilisation côté serveur (Node.js)

Import de types uniquement

Utilisation des classes d'API individuelles

Environnement navigateur

Environnement serveur

APIs Publiques vs Sécurisées

Exemple : Utilisation de l'API publique (compatible navigateur)

Exemple : Utilisation de l'API Default (côté serveur uniquement)

Exemple : Utilisation de l'API de modération

Intégration SSO (Authentification Unique)

SSO simple (côté serveur uniquement)

SSO sécurisé (côté serveur, recommandé)

Utiliser le SSO depuis le navigateur (avec un jeton généré par le serveur)

SSO avec création de commentaire

Cas d'utilisation courants

Récupérer les commentaires d'une page

Créer un commentaire

Voter sur un commentaire

Gestion des utilisateurs (Nécessite une clé API)

Événements en direct (Mises à jour en temps réel)

Événements au niveau de la page

S'abonner aux événements utilisateur