Skill UI

This catalog provides comprehensive abstractions and use cases for robust file and asset management. It covers the entire file lifecycle, including asset delivery, single and batch file creation, file deletion, and event handlers (e.g., post-creation, post-deletion hooks). Developers can use these components to build reliable, structured file management systems.

This module provides essential GraphQL response abstractions and helper types. It includes standardized structures for handling various API outcomes, such as general success responses, list data, common errors, and specific security statuses (e.g., Not Found, Not Authorized). Using these abstractions ensures that API interactions are robust, predictable, and adhere to consistent patterns.

Provides two distinct abstractions for key-value data storage: a global store for application-wide data access, and a tenant-scoped store for multi-tenant isolation. This module is fundamental for managing various types of non-relational configuration and data in a structured manner.

This module provides core abstractions for managing and retrieving language data using defined use case patterns. It includes specific use cases to fetch a single language entry by its unique code, and another to list all available language entries. Developers must import the required use case and read the source files to ensure they use the exact interface and types.

This API provides a standardized, structured logging abstraction layer for modern application development. It supports multiple log levels (e.g., info, warn, error) and ensures logs are captured in a consistent, machine-readable format. It is essential for building robust applications that require detailed monitoring, debugging, and scalable operational insights.

This module provides a comprehensive set of 10 key abstractions for interacting with OpenSearch. It includes structured components for client initialization, field definition, index management, and advanced query building operators. It serves as a foundational API layer, ensuring developers can integrate with OpenSearch in a standardized and reliable manner.

A comprehensive system for managing API authorization using schema definition. It allows developers to define granular permissions for various entities, supporting scopes like 'full' and 'own'. The system provides injectable abstractions and explicit feature registration, covering schema definition, permission checking (read, write, delete), and testing scenarios.

This API provides a comprehensive set of abstractions and use cases for handling scheduled actions within an application. It covers functionalities such as scheduling, canceling, listing, and executing actions at predefined intervals or specific future times. Ideal for building robust automated workflows and managing background processes.

A comprehensive collection of abstractions for managing API security and authentication across the application lifecycle. This includes hooks for authentication handlers, full lifecycle management for API keys (create, update, delete), and core utilities for user, role, and permission authorization. Essential for building highly secure and robust backend APIs.

This module provides essential API abstractions for managing core system functionality and lifecycles. It includes the `InstallSystemUseCase` for executing system-wide installation routines and the `SystemInstalledEventHandler` for hooking into the system lifecycle immediately after successful installation. It is crucial for developers building robust, modular systems that require proper setup and event-driven logic.

This module provides essential abstractions for managing long-running background tasks within an API context. It includes `TaskDefinition` for defining the complete lifecycle and logic of a background job, and `TaskService` for triggering, initiating, and managing these tasks programmatically. It is crucial for implementing reliable, asynchronous workflows in web applications.

This comprehensive API provides a structured set of abstractions for managing the entire lifecycle of tenants within a multi-tenant application. It includes dedicated use cases (e.g., CreateTenantUseCase, DeleteTenantUseCase), repositories for data persistence, and extensive event handlers (Before/After hooks) to hook into critical moments like creation, update, and deletion. It is essential for building robust, scalable, and event-driven multi-tenant systems.