DistinctCodes/ManageHub

AI Summary: This issue requires the implementation of a new React component, `LazyImage`, that supports lazy loading of images. It should display a blurred placeholder while the main image is loading and transition smoothly to the full image using CSS animations. The component needs to handle cases where a blur placeholder is not provided by using a fallback shimmer effect and should be a drop-in replacement for standard `<img>` tags.

AI Summary: This issue requires the creation of a new admin API endpoint to export the full member list as a CSV file. The endpoint should be secured to only allow administrators, support optional filtering by role, membership status, and date range, and stream the CSV data to avoid memory issues with large datasets. Specific CSV columns and response headers are also defined.

AI Summary: This issue requires building a workspace search results page with live filtering capabilities. Users will be able to search for workspaces by name and type, with results updating in real-time after a 350ms debounce. The page should also handle URL query parameters for shareable links, display loading states and empty states, and include a clear search button.

AI Summary: This issue requires the creation of custom 404 (Not Found) and 500 (Internal Server Error) pages for a Next.js application. These pages need to adhere to the ManageHub design system, be responsive, styled with Tailwind CSS, and include specific content elements like headings, messages, buttons, and illustrations. The implementation will be done within the `frontend/sandbox/` directory.

AI Summary: This issue requires the implementation of a secure password change endpoint for authenticated users. The endpoint will verify the current password, enforce new password complexity rules, hash the new password, and invalidate existing refresh tokens upon successful change. The implementation should be placed within the `backend/sandbox/` directory.

AI Summary: This issue involves creating placeholder "skeleton" components for loading states on a dashboard. The goal is to implement three specific skeleton components for stat cards, activity feeds, and table rows, ensuring they visually mimic the final components with a pulsing gray animation. A demo page will be used to showcase these skeletons alongside the actual components.

AI Summary: This issue requires the development of a frontend component to visualize workspace occupancy data as a heatmap. The component should display a 7x24 grid representing days of the week and hours, with cell colors indicating occupancy intensity. It needs to include tooltips for exact counts and a color scale legend, and will be implemented in the `frontend/sandbox/` directory.

AI Summary: This issue involves creating a public member profile page in the frontend sandbox. The page should display the member's profile photo, name, join date, activity statistics (check-ins, streak), and earned badges. It needs to handle cases where a member is not found and utilize mock data if an API is not yet available.

AI Summary: This issue involves adding a new backend endpoint to retrieve a user's resource credit balance from a Soroban smart contract. The implementation will use the Stellar SDK, read the contract address from an environment variable, and ensure the endpoint is JWT-protected. It also requires handling network unreachability.

AI Summary: This issue requires writing a comprehensive test suite for the `referral` smart contract. The tests should cover various scenarios including code registration, referral code usage, self-referral prevention, duplicate referral prevention, reward payment, and ensuring rewards are not paid twice. All tests must pass successfully.

AI Summary: This issue requires the implementation of two administrative functions within the `revenue_distribution` contract. The `set_beneficiaries` function will allow an administrator to register beneficiaries with their respective share percentages, ensuring the total shares sum to 100%. The `deposit_revenue` function will enable users to deposit payment tokens into the contract, with validation for non-zero amounts. Both functions need to emit appropriate events.

AI Summary: This issue requires the implementation of a function to distribute referral rewards to users who successfully refer others. The function should be admin-triggered, handle cases where a referral record doesn't exist, transfer the reward amount, mark the reward as paid, and emit an event. Additionally, an admin function to set the reward amount needs to be implemented.

AI Summary: This issue involves adding a new backend endpoint to handle image uploads for workspaces. The endpoint will be restricted to administrators, upload images to Cloudinary, and return the image URL. It also requires validation for file type and size.

AI Summary: This issue requires the implementation of two new admin-only API endpoints for deactivating and reactivating workspaces. Deactivated workspaces should be hidden from public listings but existing bookings should remain unaffected. The implementation will be located within the `backend/sandbox/` directory.

AI Summary: This issue requests the creation of a Makefile and a shell script to automate the building, testing, and deployment of all sandbox Soroban contracts to the Stellar testnet. The goal is to simplify the end-to-end testing process for contributors by consolidating these actions into a single command.

AI Summary: This issue involves building a new admin page to display audit logs. The page will feature a table with specific columns, filtering capabilities by action type and date range, pagination, and a modal for viewing detailed JSON data. It also requires implementing loading and empty states, and using mock data if an API is not yet available.

AI Summary: This issue involves creating a React component for connecting to the Freighter Stellar wallet. The component should detect if Freighter is installed, offer an installation link if not, and display a truncated wallet address upon successful connection. It also needs to handle disconnection and persist the wallet address in local storage.

AI Summary: This issue requires the implementation of a global HTTP request logging middleware in the NestJS backend. The middleware should capture and log details like HTTP method, URL, status code, response time, and requester IP for each request. Specific paths like authentication endpoints should have their request bodies excluded from logs, and health check requests should be suppressed entirely. The logging should utilize the NestJS Logger service and adhere to a specific one-line format.

AI Summary: This issue requires writing end-to-end integration tests for the core booking flow in the backend. The tests should cover happy paths, rejection scenarios, and authentication guards, using Supertest and a real test database. All tests must pass when executed with the `npm run test:e2e` command.

AI Summary: This issue requires writing unit tests for the core logic of the bookings service using Jest. The tests should cover creating, cancelling, and confirming bookings, as well as verifying seat availability and status transition validations. The database layer needs to be mocked using Jest functions, and all tests must pass when run from the backend directory.

AI Summary: This issue requires the implementation of a new backend endpoint to allow members to update their profile information. The endpoint needs to handle specific fields, enforce uniqueness for usernames, validate Nigerian phone number formats, and recalculate profile completeness. It will be protected by JWT authentication.

AI Summary: This issue requires the implementation of a new backend endpoint for unsubscribing users from a newsletter. The endpoint will accept a signed JWT token containing the subscriber's email, mark them as unsubscribed in the database, and return a simple HTML confirmation page. It needs to handle invalid or expired tokens gracefully and be publicly accessible.

AI Summary: This issue requires the implementation of a `register_code` function within the `contracts/sandbox/referral/` directory. The function should allow members to create a unique referral code linked to their address, with checks for code uniqueness, address ownership, and the emission of a registration event.

AI Summary: This issue requires adding a new API endpoint to the backend that provides daily workspace availability within a specified date range. The endpoint should calculate available seats by considering existing bookings and enforce a maximum date range of 60 days, returning a 404 for non-existent workspaces and being publicly accessible.

AI Summary: This issue requires implementing Swagger/OpenAPI documentation for all API endpoints within the `backend/sandbox/` directory using the NestJS Swagger module. The goal is to ensure comprehensive documentation for these endpoints, including tags, authentication, operation descriptions, response codes, and DTO properties, while maintaining the integrity of existing Swagger documentation.

AI Summary: This issue involves adding several read-only query functions to the `revenue_distribution` smart contract. These functions will allow external entities to retrieve information about beneficiaries, distribution records, all distribution IDs, claim status, and the contract's token balance. The work is to be done within the `contracts/sandbox/revenue_distribution/` directory.

AI Summary: This issue requires writing a comprehensive test suite for the `revenue_distribution` smart contract. The tests should cover various functionalities including setting beneficiaries, depositing revenue, creating distributions, claiming allocations, and access control for administrative functions. All tests must pass successfully.

AI Summary: This issue involves creating the foundational structure for a referral smart contract on Soroban. It requires defining data types for referrals and rewards, setting up error handling, and establishing key identifiers for contract data. The goal is to prepare the contract for tracking member referrals and reward distribution.

AI Summary: This issue proposes creating a new shared Rust library crate named `common_types` within the `contracts/sandbox/` directory. This crate will house common data structures and helper functions, such as `TimestampRange` and `bps_to_amount`, to be used by multiple sandbox contracts, thereby reducing code duplication. The goal is to have at least two sandbox contracts successfully import and utilize this new crate.

AI Summary: This issue requests the addition of several read-only query functions to a smart contract. These functions will allow users to retrieve information about referral codes, who referred a specific address, and the current reward amount. The work is to be done within the `contracts/sandbox/referral/` directory.

AI Summary: This issue involves implementing a feature for members to request extensions on existing bookings. The backend implementation will include creating a new entity for extension requests, defining API endpoints for submitting, approving, and rejecting requests, and ensuring email notifications are sent to users. The core logic will focus on validating workspace availability during the requested extension period.

AI Summary: This issue requires the implementation of new backend endpoints to support member referral functionality. It involves creating a new database entity for referrals, endpoints for users to get their referral code and view their referral statistics, and an admin endpoint to view all referral records. The referral code will also need to be integrated into the user registration process.

AI Summary: This issue requires the implementation of two smart contract functions: `create_distribution` to calculate and store proportional allocations for beneficiaries based on their share, and `claim` to allow beneficiaries to withdraw their calculated share. The implementation needs to handle edge cases like no beneficiaries or no tokens to distribute, and ensure proper event emission and access control.

AI Summary: This issue requires adding search and filtering functionality to an existing invoice listing endpoint. The implementation should support filtering by status, date range, and amount, with specific handling for currency conversion and pagination. Access control for regular users versus administrators is also a key requirement.

AI Summary: This issue requires the implementation of seat-level booking functionality for workspaces. Developers need to create a new `SeatBooking` entity, a POST endpoint for creating bookings, and a GET endpoint to check seat availability for a given date. The implementation should include validation for seat numbers and handle conflicts for already booked seats.

AI Summary: This issue requires the creation of a new backend API endpoint to provide workspace usage data for a heatmap visualization. The endpoint should group check-in counts by day of the week and hour, sourced from existing `workspace_logs.checkedInAt` data. It needs to support optional date range filters and be accessible only to administrators, with appropriate error handling for non-existent workspaces.

AI Summary: This issue requires the implementation of a new backend endpoint to retrieve a member's check-in/check-out history. The endpoint should support pagination and filtering by date, workspace, and user (for admins). The response should include details like workspace name, check-in/out times, and duration, sorted by check-in time.

AI Summary: This issue requires the implementation of a new function `use_referral_code` within the `contracts/sandbox/referral/` directory. This function will allow new members to register using a referral code, linking them to the referrer. It includes several validation checks and state updates, such as ensuring the code exists, preventing self-referrals and duplicate usage, and tracking referral usage.

AI Summary: This issue involves creating a new backend endpoint to track the onboarding progress of new members. The endpoint will return the status of various checklist items such as profile completion, first booking, and check-in, along with an overall completion percentage. It needs to be JWT-protected and implemented within the `backend/sandbox/` directory.

AI Summary: This issue involves implementing a rating and review system for workspaces. It requires creating a new `WorkspaceReview` entity, defining API endpoints for creating and retrieving reviews, and enforcing business logic such as ensuring users have completed bookings before reviewing and limiting reviews per booking. The system should also provide aggregated rating information.

AI Summary: This issue requires building a contact page with a form that includes name, email, subject, and message fields. The form needs client-side validation using `react-hook-form` and Zod, with inline error messages. Upon submission, a spinner should be displayed, followed by either a success message or an error banner if the API call fails, along with a rate limit notice.

AI Summary: This issue requires the implementation of a new backend endpoint for administrators to search for members. The endpoint should support various filtering options like role, membership status, and date ranges, along with pagination and case-insensitive search on member names and emails. The response should be paginated and exclude sensitive user data.

AI Summary: This issue involves implementing a contact form submission endpoint that accepts user data, validates it, and sends two emails: one to an administrator and an auto-reply to the user. The endpoint should be publicly accessible and rate-limited to prevent abuse.

AI Summary: This issue requires the implementation of a daily scheduled job that sends an email summary to administrators. The email should detail the previous day's check-ins, check-outs, and active members, including the busiest workspace. The job needs to be configured to run at 7:00 AM daily and handle cases with no activity.

AI Summary: This issue requires the implementation of a new backend endpoint, `PATCH /sandbox/notifications/read-all`, that will mark all unread notifications for the currently authenticated user as read. The endpoint should return the count of updated notifications and emit a WebSocket event to inform the client. It is protected by JWT authentication.

AI Summary: This issue requires the implementation of a scheduled background job to automatically cancel bookings that have been in a 'pending' state for over 24 hours without payment. The job should run hourly, identify these stale bookings, update their status to 'cancelled', send a cancellation email to the user, and log the number of cancellations. All backend implementation should reside within the `backend/sandbox/` directory.

AI Summary: This issue requires the implementation of an audit log system for sensitive administrative actions within the backend sandbox. It involves creating a new `AuditLog` entity, a reusable `AuditLogService` for logging actions, and a new API endpoint to retrieve these logs with filtering and pagination capabilities. The goal is to track who performed specific sensitive operations and when.

AI Summary: This issue requires the development of a user onboarding checklist component for new platform members. The component should guide users through initial steps with checkboxes, labels, and navigation links, visually indicating progress and completed items. It also needs a dismissible/collapsible feature and a demo page for layout testing.

AI Summary: This issue requires building a new admin UI component for managing workspace images. It will include features like drag-and-drop uploading, image previews with deletion, progress bars, and file validation. The component will be located in `frontend/sandbox/components/WorkspaceImageManager.tsx` and a demo page will be created.

AI Summary: This issue requires the development of a two-factor authentication (2FA) setup page within the frontend sandbox. The page will guide users through enabling TOTP by displaying a QR code, accepting a verification code, and providing backup codes. It also needs to handle a success state and a disable 2FA option, with the ability to use mock data if an API is not yet available.

AI Summary: This issue requires implementing infinite scrolling for the notifications list on the frontend. The existing pagination will be replaced with a mechanism that loads more notifications automatically as the user scrolls down, using IntersectionObserver. The implementation should also include visual indicators for loading, completion, and unread status, along with the functionality to mark notifications as read.

AI Summary: This issue requires the creation of a print-friendly invoice template component in the frontend sandbox. The component should display specific invoice details, be styled for printing using media queries, and include a button to trigger the browser's print functionality. A demo page will be created to showcase the template with mock data.

AI Summary: This issue requires the development of a chronological activity feed component for a dashboard. The component should display a user's recent platform actions with distinct icons for different activity types and show timestamps in a relative format. It also needs to handle loading more items and an empty state, with a demo page for testing.

AI Summary: This issue requires the creation of a reusable 'StatCard' component for a dashboard. The component should display a label, a numerical value that animates from zero on mount, an optional unit, an icon within a colored circle, and a trend indicator with a percentage. It also needs to be responsive and have a demo page showcasing its functionality.

AI Summary: This issue involves implementing a toast notification system within the frontend sandbox. The system should display success, error, and info messages triggered by API actions, appearing in the top-right corner with auto-dismissal and manual closing options. The implementation requires a ToastProvider component and a useToast hook, with a demo page to showcase its functionality.

AI Summary: This issue involves implementing client-side form validation for a new booking form using Zod and React Hook Form. The validation needs to cover required fields, date logic, and seat count, with inline error messages and a disabled submit button when errors are present. The work is to be done within the `frontend/sandbox/` directory.

AI Summary: This issue requires the development of a new frontend component to display workspace amenities. The component should render amenities as icon-label chips, with specific icons for common amenities and a fallback for unknown ones. It needs to be responsive and include a demo page for testing.

AI Summary: This issue requires the development of a new settings page in the frontend sandbox environment. Users will be able to configure their notification preferences, choosing to enable or disable email and in-app notifications for various event types. The page should load existing preferences, save changes automatically, and display a saving indicator.

AI Summary: This issue requires the creation of a responsive mobile navigation drawer component. It should slide in from the left when a hamburger icon in the navbar is clicked, contain specific navigation links, highlight the active link, and close when an overlay is clicked. The implementation should be placed in `frontend/sandbox/components/MobileNavDrawer.tsx` and demonstrated on a mock mobile page.

AI Summary: This issue involves building a form for administrators to create and edit workspaces. The form will include various fields like name, type, seats, rate, description, amenities, and an active toggle, all with comprehensive validation. The form should also handle success messages and utilize a mock handler if an API is not yet available.

AI Summary: This issue requires the implementation of reusable 'empty state' components for list pages within the frontend sandbox. These components will display a message and an optional action when a list has no data, with specific presets for bookings, notifications, invoices, and workspaces. A demo page will showcase all implemented presets.

AI Summary: This issue requires the implementation of administrative functions within the `event_ticketing` smart contract. These functions will allow administrators to create new events, update their availability, and close them. The implementation must include input validation, error handling for existing events, and event emission for status changes.

AI Summary: This issue requires writing a comprehensive test suite for the `event_ticketing` smart contract. The tests should cover various scenarios including event creation, ticket purchasing, ticket transfers, event cancellation, and access control for administrative functions. All tests must pass successfully.

AI Summary: This issue involves creating the foundational scaffolding for a new Soroban smart contract named `revenue_distribution`. The contract will manage hub revenue collection and proportional distribution to registered beneficiaries. Key tasks include setting up the project structure, defining essential data types for beneficiaries and distributions, and establishing error types and data keys.

AI Summary: This issue involves setting up the foundational structure for a new Soroban smart contract called `resource_credits`. It requires creating the project files, defining core data types, error codes, and storage keys, mirroring existing contract patterns. The goal is to have a compilable stub for the contract.

AI Summary: This issue involves setting up the foundational structure for a Soroban governance contract. It requires creating the necessary Rust files, defining data structures for proposals and votes, and establishing error types and data keys. The goal is to prepare the contract for future implementation of voting logic.

AI Summary: This issue requires the implementation of a ticket cancellation feature for an event ticketing smart contract. The functionality should allow either the ticket owner or an administrator to cancel a ticket before the event starts, triggering a full refund and updating the ticket's status. The implementation needs to handle cases where the ticket doesn't exist or the event has already begun.

AI Summary: This issue requires the implementation of a `create_proposal` function within the governance smart contract. The function should allow authorized users to submit new governance proposals, ensuring proper validation of input parameters, storage of the proposal with an 'Active' status, and emission of a creation event. The implementation needs to be done within the `contracts/sandbox/governance/` directory.

AI Summary: This issue requires the implementation of a `cast_vote` function within a smart contract. The function should allow members to vote 'Yes', 'No', or 'Abstain' on active proposals, with various error conditions to be handled, such as non-existent or inactive proposals, expired voting periods, and duplicate votes. The implementation must also track votes, store records, and emit an event.

AI Summary: This issue requires implementing a `finalize_proposal` function within the governance smart contract. This function will allow an administrator to close a proposal's voting period, tally the votes, and mark the proposal as either 'Passed' or 'Rejected' based on the outcome. It also needs to emit an event reflecting the finalization.

AI Summary: This issue requires implementing a new function for administrators to cancel active proposals within the governance smart contract. The function needs to be protected by admin permissions and handle cases where the proposal is not found or is no longer active, ensuring the proposal status is updated to 'Cancelled' and a corresponding event is emitted.

AI Summary: This issue involves adding several read-only query functions to a smart contract for managing events and tickets. The functions will allow retrieval of specific event and ticket details, lists of all events, tickets associated with an event, tickets owned by an address, and checking event ticket availability. The work is confined to a specific directory within the project.

AI Summary: This issue requires the implementation of an admin-only function `mint_credits` within the `resource_credits` contract. The function should allow an administrator to issue resource credits to a specified recipient, updating their balance and the total supply, while also emitting an event and handling specific error conditions for invalid amounts or unauthorized callers.

AI Summary: This issue requires the implementation of a `transfer_credits` function within the `resource_credits` smart contract. The function should allow members to send resource credits to other addresses, with checks for sender authorization, sufficient balance, and a valid transfer amount. The operation must be atomic, and a transfer event should be emitted upon successful execution.

AI Summary: This issue requires the implementation of a `spend_credits` function within the `resource_credits` module. This function will deduct credits from a member's balance when they consume a resource, thereby reducing the total supply. Key requirements include authorization checks, handling insufficient balance and invalid amounts, and emitting a spend event.

AI Summary: This issue involves adding read-only query functions to the `resource_credits` contract. The goal is to enable frontend and backend access to a member's credit balance and the total supply of credits in circulation. The implementation should be within the `contracts/sandbox/resource_credits/` directory and adhere to specific acceptance criteria for each function.

AI Summary: This issue proposes adding an optional expiry mechanism to minted credits. When creating credits, an administrator can set a timestamp after which these credits become invalid and cannot be transferred or spent. The implementation involves modifying existing data structures and functions to handle this new expiry logic.

AI Summary: This issue requires writing a comprehensive test suite for the `resource_credits` smart contract. The tests should cover initialization, minting, transferring, and spending of credits, including various error conditions and edge cases like expired credits. The goal is to ensure all functions behave as expected and all error paths are handled correctly.

AI Summary: This issue involves setting up the foundational structure for a new Soroban smart contract for event ticketing. It requires creating the necessary files, defining data structures for events and tickets, and establishing error types, following the pattern of existing contracts.

AI Summary: This issue requires the implementation of a `buy_ticket` function within the event ticketing smart contract. The function should allow members to purchase tickets using a payment token, handling various error conditions like non-existent or inactive events, and sold-out events. It needs to record the purchase, update event capacity, and emit an event upon successful transaction.

AI Summary: This issue requires the implementation of a ticket transfer functionality within an event ticketing smart contract. The owner of a ticket should be able to transfer it to another address before the event begins, with specific error handling for non-existent tickets, unauthorized transfers, and transfers after the event has started. The implementation should update ownership in storage, re-index the ticket, and emit a transfer event.

AI Summary: This issue requests the addition of several read-only query functions to a smart contract's governance module. These functions will allow external parties to retrieve information about proposals, votes, and voting status without altering the contract's state. The implementation should be placed within the `contracts/sandbox/governance/` directory.

AI Summary: This issue requires writing a comprehensive test suite for the `governance` contract. The tests should cover various scenarios including proposal creation, voting, finalization, cancellation, and access control for administrative functions. All tests must pass successfully.

AI Summary: This issue requests the creation of a foundational Soroban smart contract for managing verifiable on-chain badges. It involves setting up the contract's directory, defining core data structures for badges and credentials, establishing error types, and outlining data keys for storage. The goal is to scaffold the `credential_badge` contract, preparing it for future implementation.

AI Summary: This issue involves implementing a new function `register_badge_type` within the `contracts/sandbox/credential_badge/` directory. This function will allow administrators to define new badge categories, ensuring that each badge type ID is unique and emitting an event upon successful registration. The implementation needs to be secure, only accessible by administrators.

AI Summary: This issue requires implementing a smart contract function `issue_credential` that allows an admin to award a specific badge type to a member's address. The implementation needs to handle cases where the badge type doesn't exist or the member already possesses the badge, and it must emit an event upon successful issuance.

AI Summary: This issue requires the implementation of a `revoke_credential` function within the `contracts/sandbox/credential_badge/` directory. This function should allow administrators to revoke previously issued badges, with specific error handling for non-existent or already revoked credentials. It also needs to update the credential's status and emit a revocation event.

AI Summary: This issue involves implementing a new smart contract function, `verify_credential`, within the `contracts/sandbox/credential_badge/` directory. The function should allow users to check if a given address possesses a valid, non-revoked badge. Additionally, related functions to retrieve credential and badge type details need to be implemented.

AI Summary: This issue requires writing a comprehensive test suite for the `credential_badge` smart contract. The tests should cover various functionalities including registering badge types, issuing and revoking credentials, verifying credential status, retrieving holder credentials, and ensuring proper access control for non-admin users. All tests must pass successfully.

AI Summary: This issue involves adding two new query functions to a smart contract. The first function will list all credential badge types a specific member holds, and the second will list all registered badge types. Both functions should return an empty vector if no data is found and the code must compile.

AI Summary: This issue involves building a new admin analytics dashboard page within the frontend sandbox. The page will display two charts: one showing monthly revenue over the last 12 months and another showing booking counts by workspace type. It also requires implementing a date range picker, responsive charts, loading skeletons, and using mock data if an API isn't yet connected.

AI Summary: This issue requires the creation of a frontend calendar component that visually displays workspace availability. The component should navigate between months, color-code dates based on availability (green for available, red for booked), highlight the current day, and respond to date clicks by triggering a callback. It needs to be mobile-friendly and include a demo page with mock data.

AI Summary: This issue involves creating a React component for a profile completeness progress bar. The component should visually represent the user's profile completion percentage and list individual profile completion steps, indicating whether each step is complete or providing a link to complete it. A demo page will be created to showcase the component with mock data.

AI Summary: This issue requires the implementation of a frontend component that visually represents the different stages of a booking's lifecycle. The component should display these stages in a vertical timeline, with distinct styling for completed, current, and future stages, including timestamps for completed ones. A demo page will be needed to showcase the component's functionality with various booking statuses.

AI Summary: This issue requires the development of a new React component, `CheckInModal`, for a frontend application. The modal will be used to confirm user check-in or check-out actions, displaying relevant details like workspace name and time, and handling confirmation or cancellation callbacks. It also needs to include a loading spinner and be demonstrated on a dedicated page.

AI Summary: This issue requires the implementation of a booking cancellation feature on the frontend. It involves creating a new component with a two-step flow: a confirmation dialog showing booking details and a success screen with refund information. The implementation should also handle loading and error states, and include a demo page.

AI Summary: This issue involves creating a detailed workspace page in the frontend sandbox. The page should display comprehensive workspace information, including an image gallery with a lightbox feature, a booking button, an availability calendar, and user ratings. It needs to be fully responsive and use mock data if an API is not yet available.

AI Summary: This issue involves building a new admin page to manage members. The page will feature a table displaying member details, with functionalities for searching by name/email, filtering by role/status, and paginating the results. It also requires implementing row navigation to a detail view and action buttons for suspending/activating members.

AI Summary: This issue involves creating a new invoice list page in the frontend. The page should display a table of the current user's invoices with specific columns and a status badge. It also requires a PDF download button for each invoice, pagination, an empty state, and a loading skeleton, utilizing mock data if the API is not yet connected.

AI Summary: This issue requires the implementation of a dark mode toggle component within the `frontend/sandbox` directory. The toggle should allow users to switch between light and dark themes, persist their preference using `next-themes` or `localStorage`, and apply the `dark` class to the `<html>` element. The component needs to respect system preferences on initial load and animate smoothly, with a demo page showcasing its functionality in a settings card.