Skill UI

This module provides essential, standardized abstractions and hooks for managing navigation within a web administration panel. It includes components like LinkComponent and RouteLinkComponent, along with hooks such as useRouter and useRoute, allowing developers to easily structure routes, handle redirection, and manage client-side navigation state efficiently.

This catalog provides core abstractions and hooks for robust security management in administrative applications. It includes essential tools for handling identity context, user authentication flows (login/logout), and granular authorization checks. Developers can use these components to build secure, feature-rich administrative panels with reliable access control.

This catalog provides essential TypeScript abstractions, types, and hooks for implementing robust multi-tenancy features in administrative interfaces. It helps developers manage the current tenant context, check tenant roles (e.g., root vs. non-root), and handle tenant state changes (enable/disable) across various modules. It is crucial for building scalable, secure, and multi-tenant SaaS platforms.

A comprehensive skill for developers needing to deeply customize the Webiny Admin UI. Features include white-labeling (changing logos, themes, and titles), adding custom columns to content entry lists, and developing custom forms for Website Builder page types. It covers advanced React components like AdminConfig, ContentEntryListConfig, and custom form validation.

This SDK provides a comprehensive set of abstractions and utilities for programmatically controlling the behavior and structure of an admin-side website builder. Developers can use these functions to create, delete, select, query, and update elements, manage input states, and interact with the editor's state management system, making it ideal for extending the core website editing functionality.

This catalog details essential, foundational API abstractions for the Webiny framework. It provides standardized components for handling build parameters, managing domain events, utilizing key-value storage (tenant and global), structured logging, and robust result handling (Result type). Developers should use these abstractions to ensure their applications are modular, scalable, and architecturally sound.

This catalog provides comprehensive API abstractions for a Headless Content Management System (CMS). It covers core functionalities including content entry definition (CmsEntry), model management (CmsModel), content group handling, and advanced use cases like creating entries, cloning models, and complex data validation. It supports GraphQL integration, sorting, and mapping, enabling developers to build robust, data-driven backend content applications.

This skill guides developers on creating and managing Headless CMS content models programmatically using the ModelFactory pattern. It covers defining complex data structures, including various field types (text, richText, file, ref), implementing validators (required, unique), configuring layouts, and establishing relationships between models. It is essential for advanced, code-driven CMS customization and API integration.

A collection of core helper classes and abstractions designed for building robust and type-safe GraphQL APIs. These utilities standardize common response patterns (e.g., success, list, error, not found, unauthorized) and provide tools to define custom GraphQL schemas. Utilizing these abstractions ensures consistency, improves developer experience, and simplifies comprehensive error management across your backend services.

This API provides key-value store abstractions, enabling developers to manage persistent or temporary data within their web services. It offers two distinct scopes: a global (non-tenant-scoped) store and a tenant-scoped store. This is essential for applications requiring structured data management, such as application settings, caching mechanisms, or session data, while maintaining clear data isolation.

This catalog provides core API abstractions for managing language data within the webiny ecosystem. It defines standardized, type-safe use cases for common language operations, such as retrieving a single language entry by its unique code (GetLanguageByCodeUseCase) and listing all available language entries (ListLanguagesUseCase). Developers should utilize these pre-built patterns to ensure consistent, robust, and modular language handling across the application.

This module provides the core `Logger` abstraction for structured logging within the Webiny API context. It supports multiple logging levels (e.g., debug, info, warn, error), ensuring that developers can record application events and operational data systematically. Using this abstraction helps in centralized logging, which is crucial for debugging, monitoring, and maintaining system health.