LateWiz

https://github.com/zernio-dev/latewiz
Admin
LateWiz is a social media scheduling wizard that allows users to schedule posts across 13 platforms...
Tokens:10,179
Snippets:86
Trust Score:6.2
License:MIT
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install Dependencies and Run Development Server

Source: https://github.com/zernio-dev/latewiz/blob/main/README.md

Commands to install project dependencies and start the development server for contributing to LateWiz.

```bash
# Install dependencies
npm install

# Run development server
npm run dev
```

--------------------------------

### Clone and Run LateWiz Locally

Source: https://github.com/zernio-dev/latewiz/blob/main/README.md

Clone the repository, install dependencies, set up environment variables, and start the development server for local development.

```bash
git clone https://github.com/zernio-dev/latewiz.git
cd latewiz

npm install

cp .env.example .env.local

# Add your Zernio API key to .env.local
# LATE_API_KEY=sk_...

npm run dev
```

--------------------------------

### Set Up Local Environment Variables

Source: https://github.com/zernio-dev/latewiz/blob/main/CONTRIBUTING.md

Copy the example environment file to create a local configuration.

```bash
cp .env.example .env.local
```

--------------------------------

### Start Development Server

Source: https://github.com/zernio-dev/latewiz/blob/main/CONTRIBUTING.md

Start the local development server to begin working on the project.

```bash
npm run dev
```

--------------------------------

### Install Dependencies

Source: https://github.com/zernio-dev/latewiz/blob/main/CONTRIBUTING.md

Install project dependencies using npm.

```bash
npm install
```

--------------------------------

### Initialize Zernio SDK Client

Source: https://context7.com/zernio-dev/latewiz/llms.txt

Use `createLateClient` for client-side initialization with an explicit API key or `getServerClient` for a server-side singleton. The example also shows how to validate a key via a Next.js API route.

```typescript
import { createLateClient, getServerClient } from "@/lib/late-api";

// Client-side: pass the key explicitly (e.g. from user input)
const client = createLateClient("sk_your_api_key_here");

// Server-side singleton (reads process.env.LATE_API_KEY)
const serverClient = getServerClient();

// Validate key via Next.js API route
// POST /api/validate-key
const response = await fetch("/api/validate-key", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ apiKey: "sk_your_api_key_here" }),
});
const { data, error } = await response.json();
// data: { planName, limits: { uploads, profiles }, usage: { uploads, profiles } }
```

--------------------------------

### Conventional Commit Examples

Source: https://github.com/zernio-dev/latewiz/blob/main/CONTRIBUTING.md

Examples of commit messages following the Conventional Commits specification.

```git
feat: add drag-and-drop to calendar
fix: resolve timezone offset in scheduler
docs: update README with Docker instructions
```

--------------------------------

### Initiate OAuth connection flow with `useConnectAccount`

Source: https://context7.com/zernio-dev/latewiz/llms.txt

Start the OAuth connection process for a specified platform by calling `useConnectAccount`. The hook returns a redirect URL that should be used to navigate the user to the platform's authorization page.

```typescript
import { useConnectAccount } from "@/hooks";

function ConnectButton() {
  const connectAccount = useConnectAccount();

  const handleConnect = async (platform: "instagram" | "twitter" | ...) => {
    const result = await connectAccount.mutateAsync({ platform });
    // result.url is the OAuth redirect URL; navigate the user there
    if (result?.url) {
      window.location.href = result.url;
    }
    // After OAuth, the user lands on /callback
    // For platforms with entity selection (Facebook, LinkedIn, Pinterest, Google Business),
    // the callback page presents a list of pages/boards/locations to choose from.
  };

  return <button onClick={() => handleConnect("instagram")}>Connect Instagram</button>;
}
```

--------------------------------

### React Hook for SDK Client Access

Source: https://context7.com/zernio-dev/latewiz/llms.txt

Use the `useLate` hook to get a memoized `Late` SDK instance based on the stored API key, or `useLateClient` for a strict version that throws if the client is unavailable.

```APIDOC
## `useLate` / `useLateClient` — React hook to access the SDK client

`useLate` returns a memoized `Late` SDK instance built from the API key stored in the auth Zustand store, or `null` if no key is set. `useLateClient` is a strict variant that throws if the client is unavailable, for use inside authenticated pages.

```typescript
import { useLate, useLateClient } from "@/hooks";

// Nullable variant — safe to call anywhere
function MyComponent() {
  const late = useLate(); // Late | null
  if (!late) return <p>Please connect your API key.</p>;
  // use `late.posts`, `late.accounts`, etc.
}

// Throwing variant — use inside authenticated layouts
function AuthenticatedPage() {
  const late = useLateClient(); // throws if no key
  // guaranteed non-null Late instance
}
```
```

--------------------------------

### Create a New Feature Branch

Source: https://github.com/zernio-dev/latewiz/blob/main/CONTRIBUTING.md

Create a new Git branch for your feature, starting from the main branch.

```bash
git checkout -b feat/your-feature-name
```

--------------------------------

### Queue Management Hooks

Source: https://context7.com/zernio-dev/latewiz/llms.txt

Provides hooks for interacting with queue schedules. This includes listing all queues, creating new ones, updating slot times, previewing upcoming slots, getting the next available slot, and deleting or toggling queue activity.

```APIDOC
## Queue Management Hooks

### Description

These hooks provide functionality for managing queue schedules. You can list, create, update, preview, and delete queues, as well as manage their active status and default settings.

### Hooks

- **`useQueues()`**: Lists all queues for the current profile.
  - **Returns**: `{ queues: QueueSchedule[], count: number }`

- **`useCreateQueue()`**: Creates a new queue with specified name, timezone, slots, and active status.
  - **Usage Example**: `await createQueue.mutateAsync({ name: "Main Schedule", timezone: "America/Chicago", slots: [ { dayOfWeek: 1, time: "09:00" } ], active: true });`

- **`useQueuePreview(count: number)`**: Previews the next `count` upcoming slot times.
  - **Returns**: `{ slots: string[] }` (ISO strings)

- **`useNextQueueSlot()`**: Gets the very next available slot.
  - **Returns**: `{ nextSlot: string, timezone: string, queueName: string }`

- **`useUpdateQueueSlots(options)`**: Updates the slots for a queue. Accepts `reshuffleExisting` option.
  - **Parameters**: `slots` (array of slot objects), `timezone` (string), `reshuffleExisting` (boolean, optional)
  - **Usage Example**: `await updateSlots.mutateAsync({ slots: [{ dayOfWeek: 2, time: "10:00" }], timezone: "UTC", reshuffleExisting: true });`

- **`useDeleteQueue()`**: Deletes a queue by its ID.
  - **Usage Example**: `await deleteQueue.mutateAsync({ queueId: "q_abc" });`

- **`useToggleQueueActive()`**: Toggles the active status of a queue.
  - **Usage Example**: `await toggle.mutateAsync({ queueId: "q_abc", active: false });`

- **`useSetDefaultQueue()`**: Sets a queue as the default.
  - **Usage Example**: `await setDefault.mutateAsync({ queueId: "q_abc" });`

### Helper Functions

- **`formatQueueSlot(slot)`**: Formats a queue slot object into a human-readable string.
  - **Usage Example**: `console.log(formatQueueSlot({ dayOfWeek: 1, time: "09:00" })); // "Monday at 09:00"`

- **`getSlotTime(slot)`**: Retrieves the time from a slot object.
```

--------------------------------

### Clone the Repository

Source: https://github.com/zernio-dev/latewiz/blob/main/CONTRIBUTING.md

Clone your forked repository and navigate into the project directory.

```bash
git clone https://github.com/YOUR_USERNAME/latewiz.git
cd latewiz
```

--------------------------------

### API Client Initialization

Source: https://context7.com/zernio-dev/latewiz/llms.txt

Instantiate the Zernio SDK client using either an explicit API key or the `LATE_API_KEY` environment variable. `getServerClient` provides a server-side singleton.

```APIDOC
## API Client Initialization

### `createLateClient` / `getServerClient` — instantiate the Zernio SDK client

`createLateClient` creates a new `Late` SDK instance using an explicit API key or the `LATE_API_KEY` environment variable. `getServerClient` returns a module-level singleton for server-side Next.js routes.

```typescript
// src/lib/late-api/client.ts
import { createLateClient, getServerClient } from "@/lib/late-api";

// Client-side: pass the key explicitly (e.g. from user input)
const client = createLateClient("sk_your_api_key_here");

// Server-side singleton (reads process.env.LATE_API_KEY)
const serverClient = getServerClient();

// Validate key via Next.js API route
// POST /api/validate-key
const response = await fetch("/api/validate-key", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ apiKey: "sk_your_api_key_here" }),
});
const { data, error } = await response.json();
// data: { planName, limits: { uploads, profiles }, usage: { uploads, profiles } }
```
```

--------------------------------

### Manage profiles with `useProfiles`, `useCreateProfile`, and `useUpdateProfile`

Source: https://context7.com/zernio-dev/latewiz/llms.txt

Fetch all profiles using `useProfiles`, create a new profile with `useCreateProfile`, and update an existing profile's details like name and timezone using `useUpdateProfile`. `useCurrentProfileId` can retrieve the ID of the currently active profile.

```typescript
import { useProfiles, useCreateProfile, useUpdateProfile, useCurrentProfileId } from "@/hooks";

function ProfileManager() {
  const { data } = useProfiles();
  // data: { profiles: Array<{ _id, name, timezone, ... }> }

  const currentId = useCurrentProfileId(); // from store or first profile

  const createProfile = useCreateProfile();
  await createProfile.mutateAsync("My Brand");

  const updateProfile = useUpdateProfile();
  await updateProfile.mutateAsync({
    profileId: currentId!,
    name: "Updated Brand Name",
    timezone: "Europe/London",
  });
}
```

--------------------------------

### Configure LateWiz Environment Variables

Source: https://context7.com/zernio-dev/latewiz/llms.txt

Set environment variables in a .env.local file for self-hosting and customization. `LATE_API_KEY` is required for API access, while `NEXT_PUBLIC_APP_URL` and `NEXT_PUBLIC_APP_NAME` are optional for branding and OAuth configuration.

```bash
# .env.local
LATE_API_KEY=sk_live_xxxxxxxxxxxx
NEXT_PUBLIC_APP_URL=https://latewiz.example.com
NEXT_PUBLIC_APP_NAME=MyScheduler
```

--------------------------------

### Project Structure Overview

Source: https://github.com/zernio-dev/latewiz/blob/main/CONTRIBUTING.md

An overview of the main directories and their purposes within the project.

```tree
src/
├── app/                    # Next.js App Router pages
├── components/
│   ├── ui/                 # shadcn/ui base components
│   ├── composer/           # Post composer components
│   ├── calendar/           # Calendar components
│   └── shared/             # Reusable components
├── lib/
│   └── late-api/           # Zernio API client and types
└── stores/                 # Zustand state stores
```

--------------------------------

### Docker Deployment for LateWiz

Source: https://github.com/zernio-dev/latewiz/blob/main/README.md

Deploy LateWiz using Docker Compose for a managed environment or build and run manually with a specified API key.

```bash
# Using Docker Compose
docker-compose up -d

# Or build and run manually
docker build -t latewiz .
docker run -p 3000:3000 -e LATE_API_KEY=sk_... latewiz
```

--------------------------------

### Access Zernio SDK Client with React Hooks

Source: https://context7.com/zernio-dev/latewiz/llms.txt

The `useLate` hook provides a memoized SDK instance based on the auth store, returning `null` if no key is set. `useLateClient` is a stricter version that throws an error if the client is unavailable, suitable for authenticated pages.

```typescript
import { useLate, useLateClient } from "@/hooks";

// Nullable variant — safe to call anywhere
function MyComponent() {
  const late = useLate(); // Late | null
  if (!late) return <p>Please connect your API key.</p>;
  // use `late.posts`, `late.accounts`, etc.
}

// Throwing variant — use inside authenticated layouts
function AuthenticatedPage() {
  const late = useLateClient(); // throws if no key
  // guaranteed non-null Late instance
}
```

--------------------------------

### Environment Configuration

Source: https://context7.com/zernio-dev/latewiz/llms.txt

Details the environment variables required for LateWiz configuration, including API keys and application URLs.

```APIDOC
## Environment Configuration

### Description

This section details the environment variables necessary for configuring LateWiz, particularly for self-hosting and integration purposes.

### Environment Variables

| Variable             | Required | Description                                                                 |
|----------------------|----------|-----------------------------------------------------------------------------|
| `LATE_API_KEY`       | Yes*     | Zernio API key (`sk_...`). If omitted, users enter their own key in the UI. |
| `NEXT_PUBLIC_APP_URL`| No       | Public URL used as the OAuth callback base (e.g. `https://app.example.com`). |
| `NEXT_PUBLIC_APP_NAME`| No       | Custom branding name shown in the UI (default: `LateWiz`).                  |

### Example `.env.local`

```bash
LATE_API_KEY=sk_live_xxxxxxxxxxxx
NEXT_PUBLIC_APP_URL=https://latewiz.example.com
NEXT_PUBLIC_APP_NAME=MyScheduler
```
```

--------------------------------

### Manage App Preferences with `useAppStore`

Source: https://context7.com/zernio-dev/latewiz/llms.txt

This persisted Zustand store manages user preferences such as timezone, default profile, and sidebar state. Use the provided setters to update these preferences and `toggleSidebar` to change the sidebar's visibility.

```typescript
import { useAppStore } from "@/stores";

function Settings() {
  const {
    timezone,
    defaultProfileId,
    sidebarOpen,
    setTimezone,
    setDefaultProfileId,
    toggleSidebar,
  } = useAppStore();

  setTimezone("America/New_York");
  setDefaultProfileId("profile_abc123");
  toggleSidebar(); // flip sidebarOpen boolean
}
```

--------------------------------

### Manage Auth State with `useAuthStore`

Source: https://context7.com/zernio-dev/latewiz/llms.txt

This persisted Zustand store holds the API key and usage statistics. Use `setApiKey` to save a new key, access `usageStats` for plan details, and `logout` to clear all stored authentication data.

```typescript
import { useAuthStore } from "@/stores";

function ApiKeyManager() {
  const { apiKey, usageStats, isValidating, error, setApiKey, logout } = 
    useAuthStore();

  // Save a new key
  setApiKey("sk_live_abc123");

  // Read plan limits
  console.log(usageStats?.planName);          // "Pro"
  console.log(usageStats?.limits.profiles);   // 10
  console.log(usageStats?.usage.uploads);     // 42

  // Clear everything
  logout();
}
```

--------------------------------

### Linting and Type Checking for LateWiz

Source: https://github.com/zernio-dev/latewiz/blob/main/README.md

Run linting to check code style and type checking to ensure code quality during development.

```bash
# Run linting
npm run lint

# Type check
npx tsc --noEmit
```

--------------------------------

### Platform Constants and Constraints

Source: https://context7.com/zernio-dev/latewiz/llms.txt

Exports for platform slugs, display names, and media constraints. Use these to understand available platforms and their specific limitations.

```typescript
import {
  PLATFORMS,
  PLATFORM_NAMES,
  PLATFORM_CONSTRAINTS,
  PLATFORMS_WITH_ENTITY_SELECTION,
} from "@/lib/late-api";

// All 13 platform slugs
console.log(PLATFORMS);
// ["instagram","tiktok","youtube","linkedin","pinterest","twitter",
//  "facebook","threads","bluesky","snapchat","googlebusiness","reddit","telegram"]

// Display name lookup
console.log(PLATFORM_NAMES["twitter"]);  // "X (Twitter)"
console.log(PLATFORM_NAMES["youtube"]);  // "YouTube"

// Media constraints per platform
const igConstraints = PLATFORM_CONSTRAINTS["instagram"];
// { maxCarouselItems: 10 }

const ytConstraints = PLATFORM_CONSTRAINTS["youtube"];
// { requiresVideo: true }

const twConstraints = PLATFORM_CONSTRAINTS["twitter"];
// { maxImages: 4 }

// Platforms that show an entity-selection step after OAuth
console.log(PLATFORMS_WITH_ENTITY_SELECTION);
// ["facebook", "linkedin", "pinterest", "googlebusiness"]
```

--------------------------------

### Upload media files with `useUploadMedia` and `useUploadMultipleMedia`

Source: https://context7.com/zernio-dev/latewiz/llms.txt

Upload single media files using `useUploadMedia` or multiple files with `useUploadMultipleMedia`. These hooks support images up to 10MB and videos up to 5GB, utilizing a presigned-URL approach. Helper functions `isValidMediaType` and `getMaxFileSize` are available.

```typescript
import {
  useUploadMedia,
  useUploadMultipleMedia,
  isValidMediaType,
  getMaxFileSize,
} from "@/hooks";

function MediaUploadHandler() {
  const uploadOne = useUploadMedia();
  const uploadMany = useUploadMultipleMedia();

  const handleFile = async (file: File) => {
    if (!isValidMediaType(file)) {
      console.error("Unsupported type:", file.type);
      return;
    }
    const max = getMaxFileSize(file.type.startsWith("video/") ? "video" : "image");
    if (file.size > max) {
      console.error("File too large");
      return;
    }

    const uploaded = await uploadOne.mutateAsync(file);
    // uploaded: { url: "https://cdn.../photo.jpg", type: "image", filename, contentType }
    console.log(uploaded.url);
  };

  const handleMultiple = async (files: File[]) => {
    const results = await uploadMany.mutateAsync(files);
    // results: UploadedMedia[]  (one per file, in order)
    return results.map(r => ({ type: r.type, url: r.url }));
  };
}
```

--------------------------------

### useCreatePost Hook for Post Creation

Source: https://context7.com/zernio-dev/latewiz/llms.txt

Mutation hook to create a post, with options to publish immediately, schedule for a specific time, or add to a profile's queue. Automatically invalidates post list queries on success. Requires `toast` for notifications.

```typescript
import { useCreatePost } from "@/hooks";
import { toast } from "sonner";

function ComposerSubmit() {
  const createPost = useCreatePost();

  // Publish immediately to two platforms
  await createPost.mutateAsync({
    content: "Hello world! 🌍",
    mediaItems: [
      { type: "image", url: "https://cdn.example.com/photo.jpg" }
    ],
    platforms: [
      { platform: "twitter", accountId: "acct_tw_123" },
      { platform: "instagram", accountId: "acct_ig_456" },
    ],
    publishNow: true,
    timezone: "America/New_York",
  });

  // Schedule for a specific time
  await createPost.mutateAsync({
    content: "Scheduled post 📅",
    platforms: [{ platform: "linkedin", accountId: "acct_li_789" }],
    scheduledFor: "2025-07-04T14:00:00.000Z",
    timezone: "UTC",
  });

  // Add to queue (uses the profile's queue schedule)
  await createPost.mutateAsync({
    content: "Queued post 🗓️",
    platforms: [{ platform: "facebook", accountId: "acct_fb_abc" }],
    queuedFromProfile: "profile_xyz",
  });
}
```

--------------------------------

### Run Linting and Type Checks

Source: https://github.com/zernio-dev/latewiz/blob/main/CONTRIBUTING.md

Execute linting and TypeScript type checking to ensure code quality.

```bash
npm run lint
npx tsc --noEmit
```

--------------------------------

### App Store for User Preferences

Source: https://context7.com/zernio-dev/latewiz/llms.txt

The `useAppStore` is a persisted Zustand store for managing user-specific application settings like timezone, default profile, and sidebar state.

```APIDOC
## App Store — `useAppStore`

Persisted Zustand store (key: `latewiz-app`) for user preferences: timezone, default profile, and sidebar state.

```typescript
import { useAppStore } from "@/stores";

function Settings() {
  const {
    timezone,
    defaultProfileId,
    sidebarOpen,
    setTimezone,
    setDefaultProfileId,
    toggleSidebar,
  } = useAppStore();

  setTimezone("America/New_York");
  setDefaultProfileId("profile_abc123");
  toggleSidebar(); // flip sidebarOpen boolean
}
```
```

--------------------------------

### Manage Social Media Queues with LateWiz Hooks

Source: https://context7.com/zernio-dev/latewiz/llms.txt

Utilize various hooks to manage social media posting queues. This includes listing, creating, updating slots, previewing, fetching the next available slot, toggling active status, setting default queues, and deleting queues. Ensure necessary imports are included.

```typescript
import {
  useQueues,
  useCreateQueue,
  useUpdateQueueSlots,
  useQueuePreview,
  useNextQueueSlot,
  useDeleteQueue,
  useToggleQueueActive,
  useSetDefaultQueue,
  formatQueueSlot,
  getSlotTime,
} from "@/hooks";

function QueueSetup() {
  // List all queues for the current profile
  const { data } = useQueues();
  // data: { queues: QueueSchedule[], count: number }

  // Create a new queue with Mon/Wed/Fri at 9am and 5pm
  const createQueue = useCreateQueue();
  await createQueue.mutateAsync({
    name: "Main Schedule",
    timezone: "America/Chicago",
    slots: [
      { dayOfWeek: 1, time: "09:00" }, // Monday 9am
      { dayOfWeek: 1, time: "17:00" }, // Monday 5pm
      { dayOfWeek: 3, time: "09:00" }, // Wednesday 9am
      { dayOfWeek: 5, time: "09:00" }, // Friday 9am
    ],
    active: true,
  });

  // Preview the next 5 upcoming slot times (ISO strings)
  const { data: preview } = useQueuePreview(5);
  // preview: { slots: ["2025-07-07T14:00:00Z", ...] }

  // Get the very next available slot
  const { data: next } = useNextQueueSlot();
  // next: { nextSlot: "2025-07-07T14:00:00Z", timezone: "America/Chicago", queueName: "Main Schedule" }

  // Update slots (replace the entire slot list)
  const updateSlots = useUpdateQueueSlots();
  await updateSlots.mutateAsync({
    slots: [{ dayOfWeek: 2, time: "10:00" }], // Tuesday 10am only
    timezone: "UTC",
    reshuffleExisting: true,
  });

  // Toggle active / set as default / delete
  const toggle = useToggleQueueActive();
  await toggle.mutateAsync({ queueId: "q_abc", active: false });

  const setDefault = useSetDefaultQueue();
  await setDefault.mutateAsync({ queueId: "q_abc" });

  const deleteQueue = useDeleteQueue();
  await deleteQueue.mutateAsync({ queueId: "q_abc" });

  // Display helper
  console.log(formatQueueSlot({ dayOfWeek: 1, time: "09:00" })); // "Monday at 09:00"
}
```

--------------------------------

### useProfiles / useCreateProfile / useUpdateProfile

Source: https://context7.com/zernio-dev/latewiz/llms.txt

Hooks for managing user profiles, which act as workspaces grouping accounts and schedules. Includes functions to fetch, create, and update profiles.

```APIDOC
## `useProfiles` / `useCreateProfile` / `useUpdateProfile` — manage profiles

### Description
Manages user profiles, which serve as organizational units for accounts and scheduled posts.

### Methods
- `useProfiles()`: Fetches all profiles associated with the user.
- `useCreateProfile()`: Creates a new profile.
- `useUpdateProfile()`: Updates an existing profile.

### Parameters
- **`createProfile.mutateAsync(name)`**:
  - **name** (string) - Required - The name for the new profile.
- **`updateProfile.mutateAsync({ profileId, name, timezone })`**:
  - **profileId** (string) - Required - The ID of the profile to update.
  - **name** (string) - Optional - The new name for the profile.
  - **timezone** (string) - Optional - The new timezone for the profile (e.g., 'Europe/London').

### Response
- **`useProfiles` data**: `{ profiles: Array<{ _id, name, timezone, ... }> }`
- **`createProfile` / `updateProfile`**: Returns the updated or created profile object.
```

--------------------------------

### useUploadMedia / useUploadMultipleMedia

Source: https://context7.com/zernio-dev/latewiz/llms.txt

Hooks for uploading media files (images and videos). Supports single or multiple uploads with size limits for images (10 MB) and videos (5 GB).

```APIDOC
## `useUploadMedia` / `useUploadMultipleMedia` — upload images and videos

### Description
Handles the upload of media files, including images and videos, to the platform.

### Methods
- `uploadOne.mutateAsync(file)`: Uploads a single file.
- `uploadMany.mutateAsync(files)`: Uploads an array of files.

### Parameters
- **`uploadOne.mutateAsync(file)`**:
  - **file** (File) - Required - The image or video file to upload.
- **`uploadMany.mutateAsync(files)`**:
  - **files** (Array<File>) - Required - An array of files to upload.

### Constraints
- Images: Max 10 MB.
- Videos: Max 5 GB.
- Supported media types are validated by `isValidMediaType`.

### Response
- **`uploadOne` / `uploadMany`**: Returns an array of uploaded media objects, each containing `url`, `type`, `filename`, and `contentType`.
```

--------------------------------

### usePosts Hook for Fetching Posts

Source: https://context7.com/zernio-dev/latewiz/llms.txt

Fetches a paginated and filterable list of posts using TanStack Query. Supports filtering by status, date range, and pagination. Requires `Spinner` component for loading state and handles errors.

```typescript
import { usePosts, useScheduledPosts, useRecentPosts, useCalendarPosts } from "@/hooks";

function PostList() {
  // General filtered query
  const { data, isLoading, error } = usePosts({
    status: "scheduled",
    dateFrom: "2025-01-01",
    dateTo: "2025-01-31",
    limit: 20,
    page: 1,
  });
  // data: { posts: Post[], total: number, page: number }

  // Convenience hooks
  const { data: scheduled } = useScheduledPosts(10);   // next 10 scheduled
  const { data: published } = useRecentPosts(10);       // last 10 published
  const { data: calPosts } = useCalendarPosts(         // calendar range (up to 500)
    "2025-06-01",
    "2025-06-30"
  );

  if (isLoading) return <Spinner />;
  if (error) return <p>Error: {error.message}</p>;
  return <ul>{data?.posts?.map(p => <li key={p._id}>{p.content}</li>)}</ul>;
}
```

--------------------------------

### List connected social accounts with `useAccounts` and `useAccountsByPlatform`

Source: https://context7.com/zernio-dev/latewiz/llms.txt

Fetch a flat list of all connected accounts for the current profile using `useAccounts`, or retrieve accounts grouped by their platform using `useAccountsByPlatform`. Use `useAccountsHealth` to check the validity of account tokens.

```typescript
import { useAccounts, useAccountsByPlatform, useAccountsHealth } from "@/hooks";

function AccountsPanel() {
  // Flat list for the current profile
  const { data } = useAccounts();
  // data: { accounts: Account[] }
  // Account: { _id, platform, username, displayName, isActive, profilePicture, profileId, createdAt, updatedAt }

  // Grouped by platform
  const { data: byPlatform } = useAccountsByPlatform();
  // byPlatform: { instagram: Account[], twitter: Account[], ... }

  // Health check — token validity
  const { data: health } = useAccountsHealth();
  // health: { results: Array<{ accountId, isHealthy, error? }> }
}
```

--------------------------------

### Auth Store Management

Source: https://context7.com/zernio-dev/latewiz/llms.txt

The `useAuthStore` is a persisted Zustand store for managing the API key, plan usage stats, and validation status across sessions.

```APIDOC
## Auth Store — `useAuthStore`

Persisted Zustand store (key: `latewiz-auth`) that holds the API key and plan usage stats across page reloads.

```typescript
import { useAuthStore } from "@/stores";

function ApiKeyManager() {
  const { apiKey, usageStats, isValidating, error, setApiKey, logout } = 
    useAuthStore();

  // Save a new key
  setApiKey("sk_live_abc123");

  // Read plan limits
  console.log(usageStats?.planName);          // "Pro"
  console.log(usageStats?.limits.profiles);   // 10
  console.log(usageStats?.usage.uploads);     // 42

  // Clear everything
  logout();
}
```
```

--------------------------------

### useDeletePost / useRetryPost

Source: https://context7.com/zernio-dev/latewiz/llms.txt

Hooks to remove a post or retry a failed post. `useDeletePost` removes the post from the system and cache, while `useRetryPost` attempts to re-queue a failed post.

```APIDOC
## `useDeletePost` / `useRetryPost` — remove or retry a post

### Description
Provides functionality to delete a post entirely or to retry a post that previously failed.

### Methods
- `deletePost.mutateAsync(postId)`: Deletes the specified post.
- `retryPost.mutateAsync(postId)`: Retries a failed post.

### Parameters
- **postId** (string) - Required - The ID of the post to delete or retry.

### Response
- **deletePost**: No specific response data mentioned, implies success or failure.
- **retryPost**: Returns the updated post object with its new status.
```

--------------------------------

### Delete or retry a post using `useDeletePost` and `useRetryPost`

Source: https://context7.com/zernio-dev/latewiz/llms.txt

Use `useDeletePost` to remove a post from the system and invalidate related cache entries. Use `useRetryPost` to re-attempt publishing a post that previously failed.

```typescript
import { useDeletePost, useRetryPost } from "@/hooks";

function PostActions({ postId }: { postId: string }) {
  const deletePost = useDeletePost();
  const retryPost = useRetryPost();

  // Delete (removes from cache + invalidates lists)
  await deletePost.mutateAsync(postId);

  // Retry a failed post
  const result = await retryPost.mutateAsync(postId);
  // result: updated post object with new status
}
```

--------------------------------

### useConnectAccount

Source: https://context7.com/zernio-dev/latewiz/llms.txt

Initiates the OAuth connection flow for a specified social media platform. Returns a redirect URL to complete the authorization.

```APIDOC
## `useConnectAccount` — start an OAuth connection flow

### Description
Initiates the process for connecting a new social media account via OAuth.

### Method
`connectAccount.mutateAsync({ platform })`

### Parameters
- **platform** (string) - Required - The social media platform to connect (e.g., 'instagram', 'twitter').

### Response
- **result**: `{ url: string }` - An object containing the OAuth redirect URL. The user should be navigated to this URL to complete the connection.
```

--------------------------------

### useAccounts / useAccountsByPlatform

Source: https://context7.com/zernio-dev/latewiz/llms.txt

Hooks to retrieve a list of connected social media accounts. `useAccounts` provides a flat list, while `useAccountsByPlatform` groups them by platform.

```APIDOC
## `useAccounts` / `useAccountsByPlatform` — list connected social accounts

### Description
Fetches lists of social media accounts connected to the user's profile.

### Methods
- `useAccounts()`: Returns a flat list of all connected accounts.
- `useAccountsByPlatform()`: Returns accounts grouped by their respective social media platforms.

### Response
- **`useAccounts` data**: `{ accounts: Account[] }`
  - **Account**: `{ _id, platform, username, displayName, isActive, profilePicture, profileId, createdAt, updatedAt }`
- **`useAccountsByPlatform` data**: `{ [platform: string]: Account[] }` (e.g., `{ instagram: Account[], twitter: Account[] }`)
```

--------------------------------

### usePost Hook for Fetching Single Post

Source: https://context7.com/zernio-dev/latewiz/llms.txt

Fetches details for a single post by its ID. Displays loading and error states. Requires a `postId` prop and a `Spinner` component.

```typescript
import { usePost } from "@/hooks";

function PostDetail({ postId }: { postId: string }) {
  const { data: post, isLoading, error } = usePost(postId);

  if (isLoading) return <Spinner />;
  if (error) return <p>Not found</p>;
  return <div>{post?.content} — status: {post?.status}</div>;
}
```

--------------------------------

### useUpdatePost

Source: https://context7.com/zernio-dev/latewiz/llms.txt

Hook to edit a scheduled post. Allows modification of content, scheduled time, and media items.

```APIDOC
## `useUpdatePost` — edit a scheduled post

### Description
Allows users to update the content, scheduled time, and media associated with an existing scheduled post.

### Method
`updatePost.mutateAsync({ postId, content, scheduledFor, mediaItems })`

### Parameters
- **postId** (string) - Required - The ID of the post to update.
- **content** (string) - Required - The new content for the post.
- **scheduledFor** (string) - Required - The new date and time for the post to be scheduled, in ISO 8601 format.
- **mediaItems** (Array<Object>) - Optional - An array of media items to associate with the post. Each item should have a `type` (e.g., 'video', 'image') and a `url`.

### Request Example
```json
{
  "postId": "post123",
  "content": "Updated caption with #hashtags",
  "scheduledFor": "2025-07-05T10:00:00.000Z",
  "mediaItems": [
    { "type": "video", "url": "https://cdn.example.com/video.mp4" }
  ]
}
```

### Response
- **updatedPost** (Object) - The updated post object.
```

--------------------------------

### Update a scheduled post using `useUpdatePost`

Source: https://context7.com/zernio-dev/latewiz/llms.txt

Use `useUpdatePost` to modify the content, schedule time, or media of an existing scheduled post. Ensure the `postId` is valid and the `scheduledFor` date is in ISO format.

```typescript
import { useUpdatePost } from "@/hooks";

function EditPost({ postId }: { postId: string }) {
  const updatePost = useUpdatePost();

  await updatePost.mutateAsync({
    postId,
    content: "Updated caption with #hashtags",
    scheduledFor: "2025-07-05T10:00:00.000Z",
    mediaItems: [{ type: "video", url: "https://cdn.example.com/video.mp4" }],
  });
}
```

--------------------------------

### Platform-Specific Data Interfaces

Source: https://context7.com/zernio-dev/latewiz/llms.txt

Interfaces for defining payload shapes for different social media platforms when creating posts with custom settings. Ensure you use the correct interface for each platform.

```typescript
import type {
  TikTokPlatformData,
  YouTubePlatformData,
  PinterestPlatformData,
  InstagramPlatformData,
  FacebookPlatformData,
  LinkedInPlatformData,
  GoogleBusinessPlatformData,
  TelegramPlatformData,
} from "@/lib/late-api";

const tiktokData: TikTokPlatformData = {
  privacyLevel: "PUBLIC_TO_EVERYONE",
  allowComment: true,
  allowDuet: false,
  allowStitch: false,
  commercialContentType: "none",
};

const youtubeData: YouTubePlatformData = {
  title: "My Video Title",
  visibility: "public",
  madeForKids: false,
};

const pinterestData: PinterestPlatformData = {
  title: "Recipe idea",
  boardId: "board_abc123",
  link: "https://example.com/recipe",
};

const instagramData: InstagramPlatformData = {
  contentType: "story",
  shareToFeed: true,
  collaborators: ["@partner_handle"],
};

const telegramData: TelegramPlatformData = {
  parseMode: "HTML",
  disableNotification: false,
};
```

--------------------------------

### Disconnect a social account using `useDeleteAccount`

Source: https://context7.com/zernio-dev/latewiz/llms.txt

Use `useDeleteAccount` to revoke access and remove a connected social account. This action automatically invalidates all queries related to accounts.

```typescript
import { useDeleteAccount } from "@/hooks";

function DisconnectButton({ accountId }: { accountId: string }) {
  const deleteAccount = useDeleteAccount();

  await deleteAccount.mutateAsync(accountId);
  // Automatically invalidates all account queries
}
```

--------------------------------

### useDeleteAccount

Source: https://context7.com/zernio-dev/latewiz/llms.txt

Disconnects a specified social media account. This action invalidates related account queries.

```APIDOC
## `useDeleteAccount` — disconnect a social account

### Description
Removes the connection for a specified social media account.

### Method
`deleteAccount.mutateAsync(accountId)`

### Parameters
- **accountId** (string) - Required - The ID of the account to disconnect.

### Response
- No specific response data mentioned, implies success or failure. Automatically invalidates all account queries.
```
Tokens:
Raw