Skill UI

This guide explains the universal Dependency Injection (DI) pattern used across all Webiny extensions (API, Admin, CLI, Infrastructure). It details how to correctly implement constructor injection using the `dependencies` array to access core services like Logger, BuildParams, CMS use-cases, and IdentityContext. Mastering this pattern is crucial for building maintainable, type-safe, and cohesive Webiny extensions.

This module provides essential architectural abstractions for structuring complex applications using the Webiny framework. It defines core types for various system components, including Admin panels, APIs, Command Line Interfaces (CLI), Infrastructure management, and Project logic. Developers must utilize these imported abstractions to ensure strict type safety and clear separation of concerns in their code.

Provides a standardized and robust skeleton for developing full-stack extensions that integrate both a backend API service and a frontend Admin UI. This pattern enforces clear separation of concerns, utilizing shared domain layers for data consistency while ensuring that API and Admin code are correctly registered using specific entry points. Ideal for complex applications requiring unified management interfaces and robust backend logic.

This skill provides a robust mechanism for extending an existing API gateway by adding custom, non-GraphQL HTTP endpoints (GET, POST, PUT, etc.). Developers can implement the Route.Interface and register it using the <Api.Route> component. It supports full Dependency Injection (DI), providing framework-agnostic Request and Reply objects, making it ideal for integrating complex business logic directly into the API structure.

This catalog provides comprehensive infrastructure abstractions and hooks for the Webiny ecosystem. It includes standardized lifecycle hooks (Before/After Build/Deploy/Watch) and specialized services (Logger, UI, AWS interactions) for various modules (Admin, API, Core). Use these standardized interfaces to seamlessly integrate custom logic into your build and deployment pipelines, ensuring modularity and consistency.

A comprehensive guide for developers on deploying, developing locally, and managing environments for Webiny serverless platform on AWS. Learn how to use `yarn webiny deploy` for multi-environment releases (dev, staging, prod), and how to leverage `yarn webiny watch` for local API (Lambda stubs) and Admin (React HMR) development, ensuring full-stack debugging capabilities.

This guide details the complete architecture and organizational principles of a Webiny project. It covers the core concepts of the flat folder structure, the role of the central `webiny.config.tsx` file, and how to register various types of extensions (API, Admin UI, Infrastructure, and CLI Commands) using declarative JSX components. Use this when developers need to understand where custom code belongs and how to integrate different functional components into the platform.

This guide details the UseCase pattern, an architectural pattern used to encapsulate specific business operations within the Webiny framework. Learn how to define UseCases as injectable dependencies, manage input and output using the structured Result<T, E> type, and implement robust, domain-specific error handling. Mastering this pattern is crucial for building highly modular, testable, and maintainable backend APIs.

Provides comprehensive guidelines for integrating the Wispr Flow voice-to-text API into development environments. This skill covers both low-latency WebSocket streaming and simpler REST endpoint usage. It is essential for building voice-powered applications, including real-time dictation, command-line interactions, and context-aware code transcription across multiple platforms (Mac, Windows, iOS).

This guide provides comprehensive troubleshooting and error handling documentation for integrating the Wispr Flow voice-to-text API. It covers common issues across WebSocket streaming, REST API calls, and general dictation workflows. Users will learn how to address errors like 'Unauthorized' keys, network disconnections, and poor accuracy by utilizing best practices for context setting and API reconnection strategies.

This workflow provides comprehensive guidance for integrating the Wispr Flow voice-to-text API. It supports both low-latency WebSocket streaming and simpler REST API calls. It is essential for developers building sophisticated, voice-powered applications, including real-time dictation, transcribing content, and integrating voice inputs into core development tools.

This core workflow provides comprehensive guidance for integrating the Wispr Flow voice-to-text API. It supports both low-latency WebSocket streaming and standard REST API calls. Use this when building voice-powered applications, real-time dictation tools, or systems that require high accuracy in transcribing complex content like code, CLI commands, and technical jargon.