API Console

L’API Console vous permet d’effectuer des tâches administratives d’un blog. C’est la même API que nous utilisons en interne dans la Console. Vous pouvez l’utiliser pour automatiser certaines tâches ou même créer une mini-console entièrement nouvelle par vous-même.

Appeler l'API

  • Chemin de base de l’API : https://blogs.hyvor.com/api/console/v0/blog/{subdomain}
  • Créez une clé d’API Console depuis la Console et envoyez-la en tant qu’en-tête X-API-KEY.
  • Les points de terminaison de l’API Console utilisent les méthodes HTTP suivantes.
    • GET - pour obtenir des données, généralement un tableau de ressources
    • POST - pour créer une ressource
    • PATCH - pour mettre à jour partiellement ou complètement une ressource
    • DELETE - pour supprimer une ressource
  • Tout comme notre API Data, l’API Console renvoie toujours un objet ou un tableau d’objets, au format JSON
  • Les paramètres de requête peuvent être définis en JSON (recommandé) ou comme des paramètres de requête habituels (dans la chaîne de requête ou le corps HTTP)
  • Dans cette documentation, les objets, paramètres de requête et réponses sont écrits comme des interfaces Typescript afin de rendre les déclarations de type concises.

Catégories

L’API Console dispose de nombreux points de terminaison et est classée selon la “ressource” à laquelle vous souhaitez accéder ou que vous souhaitez gérer. La plupart des catégories disposent d’opérations CRUD, mais certaines peuvent avoir davantage de points de terminaison pour des tâches spécifiques. Ces objets sont définis au sein de la catégorie. Notez également que les objets de l’API Console sont différents des objets de l’API Data.

Accédez directement à chaque catégorie :

Blog

Points de terminaison :

  • GET /blog - Obtenir les données du blog
  • PATCH /blog - Mettre à jour les données du blog
  • POST /blog/variant - Créer une variante de blog
  • PATCH /blog/variant - Mettre à jour une variante de blog

Objets :

Obtenir les données du blog

GET /blog

type Request = {};
type Response = Blog;

Mettre à jour les données du blog

PATCH /blog

type Request = Partial<Blog>; // sauf id et variants
type Response = Blog;

Créer une variante de blog

POST /blog/variant

type Request = {
	language_id: number;
};
type Response = BlogVariant;

Mettre à jour une variante de blog

PATCH /blog/variant

type Request = {
	language_id: number;
	name?: string;
	description?: string;
};
type Response = BlogVariant;

Articles & Pages

Points de terminaison :

  • GET /posts - Obtenir les articles
  • GET /pages - Obtenir les pages
  • POST /post - Créer un article/une page
  • GET /post/{id} - Obtenir un article/une page
  • PATCH /post/{id} - Mettre à jour un article/une page
  • DELETE /post/{id} - Supprimer un article/une page
  • POST /post/{id}/variant - Créer une variante d’article
  • PATCH /post/{id}/variant - Mettre à jour une variante d’article
  • POST /post/{id}/variant/publish - Publier une variante d’article
  • POST /post/{id}/variant/unpublish - Dépublier une variante d’article
  • DELETE /post/{id}/variant - Supprimer une variante d’article
  • PATCH /post/{id}/tags - Mettre à jour les tags d’un article
  • PATCH /post/{id}/authors - Mettre à jour les auteurs d’un article

Objets :

Obtenir les articles

Obtient les articles avec filtrage. Les paramètres de filtrage sont similaires à ceux de la Console. Renvoie un objet PostListItem léger par article, plutôt que l’objet complet Post - récupérez GET /post/{id} pour obtenir l’article complet.

GET /posts

type Request = {
	status?: 'featured' | 'published' | 'draft' | 'scheduled';
	author_id?: number;
	tag_id?: number;
	start_timestamp?: number; // horodatage unix
	end_timestamp?: number; // horodatage unix
	search?: string;
	language_id?: number; // par défaut la langue principale du blog
	limit?: number; // par défaut 50, max 100
	offset?: number;
};
type Response = PostListItem[];

Obtenir les pages

Même forme légère PostListItem que GET /posts.

GET /pages

type Request = {};
type Response = PostListItem[];

Créer un article/une page

Crée un article brouillon vide. Une variante d’article sera créée à partir de la langue principale du blog.

POST /post

type Request = {
	is_page?: boolean; // par défaut false
};
type Response = Post;

Obtenir un article/une page

GET /post/{id}

type Request = {};
type Response = Post;

Mettre à jour un article/une page

PATCH /post/{id}

type Request = {
	is_featured?: boolean;
	featured_image_url?: string | null;
	canonical_url?: string | null;
	code_head?: string | null;
	code_foot?: string | null;
	published_at?: number | null; // horodatage unix
};
type Response = Post;

Supprimer un article/une page

DELETE /post/{id}

type Request = {};
type Response = {};

Créer une variante d'article

POST /post/{id}/variant

type Request = {
	language_id: number;
};
type Response = PostVariant;

Mettre à jour une variante d'article

PATCH /post/{id}/variant

type Request = {
	language_id: number;
	slug?: string; // max 255 caractères
	content?: string | null;
	content_unsaved?: string | null;
	title?: string | null; // max 255 caractères
	description?: string | null; // max 255 caractères
};
type Response = PostVariant;

content et content_unsaved doivent être au format JSON ProseMirror. Consultez le point de terminaison Obtenir le JSON ProseMirror pour convertir du HTML en JSON ProseMirror.

Publier une variante d'article

POST /post/{id}/variant/publish

type Request = {
	language_id: number;
};
type Response = PostVariant;

Publie une variante d’article. Si la variante n’a pas de slug, un slug est automatiquement généré à partir du titre. Si l’article n’a pas d’heure published_at, elle est définie sur maintenant. Nécessite la portée posts.publish.own.

Dépublier une variante d'article

POST /post/{id}/variant/unpublish

type Request = {
	language_id: number;
};
type Response = PostVariant;

Remet le statut de la variante à draft. Fonctionne aussi bien sur les variantes publiées que programmées. Nécessite la portée posts.publish.own.

Supprimer une variante d'article

DELETE /post/{id}/variant

type Request = {
	language_id: number;
};
type Response = {};

Mettre à jour les tags d'un article

PATCH /post/{id}/tags

type Request = {
	ids: number[]; // IDs des tags
};
type Response = {};

Mettre à jour les auteurs d'un article

PATCH /post/{id}/authors

type Request = {
	ids: number[]; // IDs des auteurs (utilisateurs)
};
type Response = {};

Tags

Points de terminaison :

  • GET /tags - Obtenir ou rechercher des tags
  • POST /tag - Créer un tag
  • PATCH /tag/{id} - Mettre à jour un tag
  • DELETE /tag/{id} - Supprimer un tag
  • POST /tag/{id}/variant - Créer une variante de tag
  • PATCH /tag/{id}/variant - Mettre à jour une variante de tag
  • DELETE /tag/{id}/variant - Supprimer une variante de tag

Objets :

Obtenir ou rechercher des tags

Liste les tags, avec une recherche optionnelle par nom (langue principale).

GET /tags

type Request = {
	limit?: number; // par défaut 50, max 100
	offset?: number;
	search?: string; // filtre les tags par nom (langue principale)
};
type Response = Tag[];

Créer un tag

POST /tag

type Request = {
	name: string; // nom pour la variante de langue principale
	is_private: boolean; // par défaut false
};
type Response = Tag;

Mettre à jour un tag

PATCH /tag/{id}

type Request = {
	is_private?: boolean;
	slug?: string;
	code_head?: string | null;
	code_foot?: string | null;
};
type Response = Tag;

Supprimer un tag

DELETE /tag/{id}

type Request = {};
type Response = {};

Créer une variante de tag

POST /tag/{id}/variant

type Request = {
	language_id: number;
};

Mettre à jour une variante de tag

PATCH /tag/{id}/variant

type Request = {
	language_id: number;
	name?: string;
	description?: string | null;
};

Supprimer une variante de tag

DELETE /tag/{id}/variant

type Request = {
	language_id: number;
};

Utilisateurs

Points de terminaison :

  • GET /users - Obtenir les utilisateurs
  • GET /users/search - Rechercher des utilisateurs
  • POST /user - Créer un utilisateur
  • POST /user/guest - Créer un utilisateur invité
  • PATCH /user/{id} - Mettre à jour un utilisateur
  • DELETE /user/{id} - Supprimer un utilisateur
  • POST /user/{id}/variant - Créer une variante d’utilisateur
  • PATCH /user/{id}/variant - Mettre à jour une variante d’utilisateur
  • DELETE /user/{id}/variant - Supprimer une variante d’utilisateur

Objets :

Obtenir les utilisateurs

GET /users

type Request = {
	offset?: number;
};
type Response = User[];

Rechercher des utilisateurs

Recherche des utilisateurs par nom.

GET /users/search

type Request = {
	search: string;
};
type Response = User[];

Créer un utilisateur

POST /user

type Request = {
	username_or_email: string;
	role: 'owner' | 'admin' | 'editor' | 'writer' | 'contributor';
};
type Response = User;

Créer un utilisateur invité

POST /user/guest

type Request = {
	name: string;
};
type Response = User;

Mettre à jour un utilisateur

PATCH /user/{id}

type Request = {
	hyvor_user_id?: number;
	role?: 'owner' | 'admin' | 'editor' | 'writer' | 'contributor';
	status: 'active' | 'blocked';
	slug: string;
	email?: string;
	website_url?: string;
	picture_url?: string;
	social_facebook?: string;
	social_twitter?: string;
	social_linkedin?: string;
	social_youtube?: string;
	social_tiktok?: string;
	social_instagram?: string;
	social_github?: string;
};
type Response = User;

Supprimer un utilisateur

DELETE /user/{id}

type Request = {};
type Response = {};

Créer une variante d'utilisateur

POST /user/{id}/variant

type Request = {};
type Response = UserVariant;

Mettre à jour une variante d'utilisateur

PATCH /user/{id}/variant

type Request = {
	name?: string;
	bio?: string;
	location?: string;
};
type Response = UserVariant;

Supprimer une variante d'utilisateur

DELETE /user/{id}/variant

type Request = {};
type Response = {};

Médias

Points de terminaison :

  • GET /media - Obtenir les médias
  • POST /media - Créer un média
  • POST /media/from-url - Créer un média à partir d’une URL
  • DELETE /media/{id} - Supprimer une navigation
  • GET /media/unsplash/search - Obtenir des médias depuis unsplash
  • PATCH /media - Modifier un média

Objets :

Obtenir les médias

GET /media

type Request = {
	limit: number;
	offset: number;
	search?: string;
	extensions?: string[];
	type?: string;
};
type Response = Media[];

Créer un média

POST /media

type Request = {
	file: File;
	post_id: number;
};
type Response = Media;

Créer un média à partir d'une URL

POST /media/from-url

type Request = {
	url: string;
	post_id?: number;
};
type Response = Media;

Supprimer un média

DELETE /media/{id}

type Request = {};
type Response = {};

Modifier un média

PATCH /media/{id}

type Request = Partial<Media>;
type Response = Media;

Points de terminaison :

  • GET /navigations - Obtenir les navigations
  • PATCH /navigations/sort - Mettre à jour l’ordre des navigations
  • POST /navigation - Créer une navigation
  • PATCH /navigation/{id} - Mettre à jour une navigation
  • DELETE /navigation/{id} - Supprimer une navigation
  • POST /navigation/{id}/variant - Créer une variante de navigation
  • PATCH /navigation/{id}/variant - Mettre à jour une variante de navigation
  • DELETE /navigation/{id}/variant - Supprimer une variante de navigation

Objets :

Obtenir les navigations

GET /navigations

type Request = {};
type Response = Navigation[];

Mettre à jour l'ordre des navigations

PATCH /navigations/sort

type Request = {
	ids?: number[];
};
type Response = {};

Créer une navigation

POST /navigation

type Request = {
	url: string;
	name: string;
	type: 'header' | 'footer';
};
type Response = Navigation;

Mettre à jour une navigation

PATCH /navigation/{id}

type Request = {
	url: string;
	type: 'header' | 'footer';
};
type Response = Navigation;

Supprimer une navigation

DELETE /navigation/{id}

type Request = {};
type Response = {};

Créer une variante de navigation

POST /navigation/{id}/variant

type Request = {
	language_id: number;
	name?: string;
};
type Response = NavigationVariant;

Mettre à jour une variante de navigation

PATCH /navigation/{id}/variant

type Request = {
	language_id: number;
	name: string;
};
type Response = NavigationVariant;

Supprimer une variante de navigation

DELETE /navigation/{id}/variant

type Request = {
	language_id: number;
};
type Response = {};

Langue

Points de terminaison :

  • GET /languages - Obtenir les langues
  • POST /language - Créer une langue
  • PATCH /language/{id} - Mettre à jour une langue
  • DELETE /language/{id} - Supprimer une langue

Objets :

Obtenir les langues

GET /languages

type Request = {};
type Response = Languages[];

Créer une langue

POST /language

type Request = {
	code: string; // max 12 caractères
	name: string; // max 255 caractères
	direction: 'ltr' | 'rtl';
};
type Response = Language;

Mettre à jour une langue

PATCH /language/{id}

type Request = {
	code: string; // max 12 caractères
	name: string; // max 255 caractères
	direction: 'ltr' | 'rtl';
};
type Response = Language;

Supprimer une langue

DELETE /language/{id}

type Request = {};
type Response = {};

Redirection

Points de terminaison :

  • GET /redirects - Obtenir les redirections
  • POST /redirect - Créer une redirection
  • PATCH /redirect/{id} - Mettre à jour une redirection
  • DELETE /redirect/{id} - Supprimer une redirection

Objets :

Obtenir les redirections

GET /redirects

type Request = {
	search?: string;
	limit?: number;
	offset?: number;
};
type Response = Redirect[];

Créer une redirection

POST /redirect

type Request = {
	dynamic: boolean;
	path: string;
	to: string;
	type: 'temporary' | 'permanent';
};
type Response = Redirect;

Mettre à jour une redirection

PATCH /redirect/{id}

type Request = {
	path?: string;
	to?: string;
	type?: 'temporary' | 'permanent';
};
type Response = Redirect;

Supprimer une redirection

DELETE /redirect/{id}

type Request = {};
type Response = {};

Webhook

Points de terminaison :

  • GET /webhooks - Obtenir les webhooks
  • POST /webhook - Créer un webhook
  • PATCH /webhook/{id} - Mettre à jour un webhook
  • DELETE /webhook/{id} - Supprimer un webhook

Objets :

Obtenir les webhooks

GET /webhooks

type Request = {};
type Response = Webhook[];

Créer un webhook

POST /webhook

type Request = {
	url: string;
	events: 'cache.single' | 'cache.templates' | 'cache.all'[];
};
type Response = Webhook;

Mettre à jour un webhook

PATCH /webhook/{id}

type Request = {
	url?: string;
	events?: 'cache.single' | 'cache.templates' | 'cache.all'[];
};
type Response = Webhook;

Supprimer un webhook

DELETE /webhook/{id}

type Request = {};
type Response = {};

Fichiers du thème

Points de terminaison :

  • GET /theme/files - Obtenir les fichiers du thème
  • POST /theme/file - Créer un fichier de thème
  • PATCH /theme/file/{id} - Mettre à jour un fichier de thème
  • DELETE /theme/file/{id} - Supprimer un fichier de thème

Objets :

Obtenir les fichiers du thème

GET /theme/files

type Request = {};
type Response = FileObject[];

Créer un fichier de thème

POST /theme/file

type Request = {
	folder: 'templates' | 'assets' | 'styles' | 'lang';
	name: string;
	content?: string;
	file: File;
};
type Response = FileObject;

Mettre à jour un fichier de thème

PATCH /theme/file/{id}

type Request = {
	name?: string;
	content?: string;
};
type Response = FileObject;

Supprimer un fichier de thème

DELETE /theme/file/{id}

type Request = {};
type Response = {};

Export

Points de terminaison :

  • GET /exports - Obtenir les exports
  • POST /export - Créer un export

Objets :

Obtenir les exports

GET /exports

type Request = {};
type Response = ExportObject[];

Créer un export

POST /export

type Request = {};
type Response = ExportObject;

Points de terminaison :

  • POST /link-analysis/check-urls - Vérifier un lien de variante d’article
  • PATCH /link-analysis/ignore-link - Ignorer un lien
  • GET /link-analysis/stats - Obtenir les statistiques des liens
  • GET /link-analysis/links - Obtenir les liens
  • GET /link-analysis/checks - Obtenir les vérifications
  • POST /link-analysis/check - Créer une vérification

Objets :

Vérifier un lien de variante d'article

POST /link-analysis/check-urls

type Request = {
	post_variant_id: number;
	urls: string[];
	force?: boolean;
};
type Response = LinkObject[];

PATCH /link-analysis/ignore-link

type Request = {
	post_variant_id: number;
	urls: string[];
	status: boolean;
};
type Response = LinkObject;

GET /link-analysis/stats

type Request = {};
type Response = {
	counts: number;
};

GET /link-analysis/links

type Request = {
	type?: 'ok' | 'broken' | 'ignored' | 'redirected';
	limit?: number;
	offset?: number;
};
type Response = LinkObject[];

Obtenir les vérifications

GET /link-analysis/checks

type Request = {
	limit?: number;
	offset?: number;
};
type Response = CheckObject[];

Créer une vérification

POST /link-analysis/check

type Request = {};
type Response = CheckObject;

Route

Points de terminaison :

  • GET /routes - Obtenir les routes
  • POST /route - Créer une route
  • PATCH /route/{id} - Mettre à jour une route
  • DELETE /route/{id} - Supprimer une route

Objets :

Obtenir les routes

GET /routes

type Request = {};
type Response = Route[];

Créer une route

POST /route

type Request = {
	name: string;
	match: string;
	template: string;
	post_filter?: string;
	content_type?: string;
};
type Response = Route;

Mettre à jour une route

PATCH /route/{id}

type Request = {
	name: string;
	match: string;
	template: string;
	post_filter?: string;
	content_type?: string;
};
type Response = Route;

Supprimer une route

DELETE /route/{id}

type Request = {};
type Response = {};

Divers

Points de terminaison :

  • GET /misc/themes - Obtenir tous les thèmes
  • GET /misc/prosemirror/json - Obtenir le json prosemirror
  • DELETE /blog/cache - Supprimer le cache du blog
  • DELETE /blog - Supprimer le blog

Obtenir tous les thèmes

GET /misc/themes

type Request = {};
type Response = Theme[];

Obtenir le JSON prosemirror à partir du HTML

GET /misc/prosemirror/json

type Request = {
	html: string;
};
type Response = {
	json: string;
};

Supprimer le cache du blog

DELETE /blog/cache

type Request = {
	type: 'all' | 'template' | 'paths';
	paths?: string[];
};
type Response = {};

Supprimer le blog

Supprime le blog de manière réversible (soft-delete). Le blog et ses données sont définitivement supprimés 30 jours plus tard. Nécessite la portée blog.delete.

DELETE /blog

type Request = {};
type Response = {};

Objets

Objet Blog

interface Blog {
	id: number;
	created_at: number;
	is_blocked: boolean;
	subdomain: string;
	type: 'default' | 'dev';
	hosting_at: 'subdomain' | 'domain' | 'self';
	hosting_domain: string | null;
	hosting_url: string | null;

	embeddable: boolean;
	embedding_domains: string | null;

	logo_url: string | null;
	cover_url: string | null;

	social_facebook: string | null;
	social_twitter: string | null;
	social_linkedin: string | null;
	social_youtube: string | null;
	social_tiktok: string | null;
	social_instagram: string | null;
	social_github: string | null;

	code_head: string | null;
	code_foot: string | null;

	seo_indexing: boolean;
	seo_robots_txt: string | null;
	seo_external_links_follow: 'follow' | 'nofollow';
	comments_code: string | null;
	newsletter_code: string | null;

	color_modes: 'light' | 'dark' | 'both';
	color_mode_default: 'light' | 'dark' | 'os';

	syntax_on: boolean;
	syntax_line_numbers: boolean;
	syntax_theme: string | null;

	flashload: boolean;
	variants: BlogVariant[];
}

Objet BlogVariant

interface BlogVariant {
	language_id: number;
	name: string | null;
	description: string | null;
}

Objet Post

interface Post {
	id: number;
	preview_id: string;
	created_at: number;
	updated_at: number;
	published_at: number | null;

	is_featured: boolean;
	is_page: boolean;

	featured_image_url: string | null;
	canonical_url: string | null;
	code_head: string | null;
	code_foot: string | null;

	variant_statuses: {
		id: number;
		language_id: number;
		status: 'draft' | 'published' | 'scheduled';
	}[];

	tags: Tag[];
	authors: User[];
}

variant_statuses vous indique uniquement quelles langues un article possède et leur statut. Récupérez GET /post/{id}?variant_language_code=... pour obtenir l’objet complet PostVariant (contenu, titre, champs SEO, etc.) pour une seule langue.

Objet PostVariant

interface PostVariant {
	language_id: number;

	slug: string | null;
	status: 'draft' | 'published' | 'scheduled';
	url: string;

	content: string | null;
	content_unsaved: string | null;
	title: string | null;
	description: string | null;
}

Objet PostListItem

Renvoyé par GET /posts et GET /pages. Un résumé léger par article : slug, url, title, et link_analysis reflètent la variante de la langue demandée (ou la langue principale du blog), et tags/authors sont uniquement leurs noms dans la langue principale. Récupérez GET /post/{id} pour obtenir l’objet complet Post, incluant les tags et les auteurs.

interface PostListItem {
	id: number;
	created_at: number;
	updated_at: number;
	published_at: number | null;

	is_featured: boolean;
	is_page: boolean;

	slug: string | null;
	url: string | null;
	title: string | null;
	link_analysis: Record<string, number>;

	variant_statuses: {
		language_id: number;
		status: 'draft' | 'published' | 'scheduled';
	}[];

	tags: string[]; // noms des tags, langue principale
	authors: string[]; // noms des auteurs, langue principale
}

Objet Tag

interface Tag {
	id: number;
	created_at: number;
	updated_at: number;
	is_private: boolean;
	slug: string;
	posts_count: number;
	code_head: string | null;
	code_foot: string | null;

	variants: TagVariant[];
}

Objet TagVariant

interface TagVariant {
	language_id: number;
	url: string | null;
	name: string | null;
	description: string | null;
}

Objet User

interface User {
	id: number;
	created_at: number;
	updated_at: number;

	hyvor_user_id: number | null;

	status: 'invited' | 'active' | 'blocked';
	role: 'owner' | 'admin' | 'editor' | 'writer' | 'contributor';
	slug: string;
	posts_count: number;
	email: string;

	picture_url: string | null;
	website_url: string | null;

	social_facebook: string | null;
	social_twitter: string | null;
	social_linkedin: string | null;
	social_youtube: string | null;
	social_tiktok: string | null;
	social_instagram: string | null;
	social_github: string | null;

	variants: UserVariant[];
}

Objet UserVariant

interface UserVariant {
	language_id: number;
	url: string;
	name: string | null;
	bio: string | null;
	location: string | null;
}

Objet Media

interface Media {
	id: number;
	uploaded_at: number;
	name: string;
	url: string;
	original_name: string;
	extension: string;
}
interface Navigation {
	id: number;
	created_at: number;
	url: string;
	type: NavigationType;
	sort: number;
	variants: NavigationVariant[];
}
interface NavigationVariant {
	language_id: number;
	name: string | null;
}

Objet Language

interface Language {
	id: number;
	code: string;
	name: string;
	is_primary: boolean;
}

Objet Redirect

interface Redirect {
	id: number;
	created_at: number;
	path: string;
	to: string;
	type: 'temporary' | 'permanent';
}

Objet Webhook

interface Webhook {
	id: number;
	url: string;
	events: string[];
	secret: string;
}

Objet Route

interface Route {
	id: number;
	created_at: number;
	name: string;
	match: string;
	template: string;
	posts_filter: string | null;
	content_type: string | null;
	is_enabled: boolean;
}

Objet File

interface FileObject {
	id: number;
	name: string;
	content: string | null;
	folder: 'templates' | 'assets' | 'styles' | 'lang';
}

Objet Export

interface Export {
	id: number;
	createdf_at: number;
	format: 'hyvor_blogs' | 'wordpress';
	status: 'pending' | 'completed' | 'failed';
	url: string | null;
	error?: string;
}

Objet Theme

interface Theme {
	id: number;
	type: 'original' | 'ported';
	name: string;
}
interface LinkObject {
	id: number;
	url: string;
	full_url: string;
	status_code: number;
	status_type: 'ok' | 'broken' | 'redirect' | 'ignored';
	ignored: boolean;
	post_id: number;
	post_variant_id: number;
	post_variant_language_id: number;
	post_variant_title: string;
}

Objet Check

interface CheckObject {
	id: number;
	created_at: number;
	status: 'pending' | 'completed' | 'failed';
	error: string | null;
	post_count: number;
	post_variants_count: number;
	page_count: number;
	page_variants_count: number;
	links_total_count: number;
	links_ok_count: number;
	links_broken_count: number;
	links_redirect_count: number;
	links_ignored_count: number;
}
Hyvor Blogs Logo