@loculabs/api-client 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1075 @@
+interface components {
+    schemas: {
+        /** @description Task description in multiple formats */
+        TaskDescription: {
+            /** @description Description content as Markdown */
+            markdown: string;
+            /** @description Description content as HTML (only included when includeHtml=true) */
+            html?: string;
+            /**
+             * @description ProseMirror JSON document. Root node always has type "doc" with a content array of child nodes.
+             * @example {
+             *       "type": "doc",
+             *       "content": [
+             *         {
+             *           "type": "paragraph",
+             *           "content": [
+             *             {
+             *               "type": "text",
+             *               "text": "Hello "
+             *             },
+             *             {
+             *               "type": "text",
+             *               "text": "world",
+             *               "marks": [
+             *                 {
+             *                   "type": "bold"
+             *                 }
+             *               ]
+             *             }
+             *           ]
+             *         }
+             *       ]
+             *     }
+             */
+            json?: {
+                /**
+                 * @description Document root type, always "doc"
+                 * @enum {string}
+                 */
+                type: "doc";
+                /** @description Array of child document nodes */
+                content: {
+                    /** @description Node type (e.g., "paragraph", "text", "heading", "bulletList") */
+                    type: string;
+                    /** @description Node attributes */
+                    attrs?: {
+                        [key: string]: (string | null) | number | boolean;
+                    };
+                    /** @description Child nodes (recursive DocumentNode array) */
+                    content?: Record<string, never>[];
+                    /** @description Text content (only for text nodes) */
+                    text?: string;
+                    /** @description Text marks (bold, italic, links, etc.) - only for text nodes */
+                    marks?: {
+                        /** @description Mark type (e.g., "bold", "italic", "link") */
+                        type: string;
+                        /** @description Mark attributes */
+                        attrs?: {
+                            [key: string]: (string | null) | number | boolean;
+                        };
+                    }[];
+                }[];
+            };
+            /** @description Description content as plain text */
+            plainText: string;
+        } | null;
+        LocuTask: {
+            id: string;
+            name: string;
+            done: "completed" | "canceled" | unknown;
+            doneAt: number | null;
+            createdAt: number;
+            parent: {
+                id: string;
+                order: number | null;
+            } | null;
+            waiting?: {
+                reason?: string;
+                waitingAt: number;
+            } | null;
+            projectId?: string | null;
+            cursorAgentUrl?: string | null;
+            integrationId: unknown;
+            slackLink?: string;
+            /**
+             * @default locu
+             * @enum {string}
+             */
+            type: "locu";
+            description?: components["schemas"]["TaskDescription"];
+        };
+        LinearTask: {
+            id: string;
+            name: string;
+            done: "completed" | "canceled" | unknown;
+            doneAt: number | null;
+            createdAt: number;
+            parent: {
+                id: string;
+                order: number | null;
+            } | null;
+            waiting?: {
+                reason?: string;
+                waitingAt: number;
+            } | null;
+            projectId?: string | null;
+            cursorAgentUrl?: string | null;
+            integrationId: string;
+            number: number;
+            priority?: number;
+            organizationId: string;
+            teamId: string;
+            description?: components["schemas"]["TaskDescription"];
+            assignee: {
+                id: string;
+                name: string;
+            } | null;
+            state: {
+                id: string;
+                type: string;
+            };
+            url: string;
+            identifier: string;
+            deletedInLinear: boolean;
+            /**
+             * @default linear
+             * @enum {string}
+             */
+            type: "linear";
+        };
+        JiraTask: {
+            id: string;
+            name: string;
+            done: "completed" | "canceled" | unknown;
+            doneAt: number | null;
+            createdAt: number;
+            parent: {
+                id: string;
+                order: number | null;
+            } | null;
+            waiting?: {
+                reason?: string;
+                waitingAt: number;
+            } | null;
+            projectId: string;
+            cursorAgentUrl?: string | null;
+            integrationId: string;
+            description?: components["schemas"]["TaskDescription"];
+            assignee: {
+                id: string;
+                avatar?: string;
+                name: string;
+            } | null;
+            issueType: {
+                id: string;
+                name: string;
+                icon: string;
+            };
+            state: {
+                id: string;
+                name: string;
+                statusCategory: {
+                    id: number;
+                    key: string;
+                    name: string;
+                    color: string;
+                };
+            };
+            url: string;
+            identifier: string;
+            deletedInJira: boolean;
+            /**
+             * @default jira
+             * @enum {string}
+             */
+            type: "jira";
+        };
+        Task: components["schemas"]["LocuTask"] | components["schemas"]["LinearTask"] | components["schemas"]["JiraTask"];
+        Note: {
+            id: string;
+            text: string;
+            name: string;
+            /** @default null */
+            icon: string | null;
+            /** @default null */
+            color: string | null;
+            /** @default null */
+            parent: {
+                id: string;
+                type: "folder" | "virtual-folder";
+            } | null;
+            createdAt?: number;
+            updatedAt?: number;
+            /** @description Note content as Markdown */
+            markdown: string;
+            /** @description Note content as HTML (only included when includeHtml=true) */
+            html?: string;
+            /**
+             * @description ProseMirror JSON document. Root node always has type "doc" with a content array of child nodes.
+             * @example {
+             *       "type": "doc",
+             *       "content": [
+             *         {
+             *           "type": "paragraph",
+             *           "content": [
+             *             {
+             *               "type": "text",
+             *               "text": "Hello "
+             *             },
+             *             {
+             *               "type": "text",
+             *               "text": "world",
+             *               "marks": [
+             *                 {
+             *                   "type": "bold"
+             *                 }
+             *               ]
+             *             }
+             *           ]
+             *         }
+             *       ]
+             *     }
+             */
+            json?: {
+                /**
+                 * @description Document root type, always "doc"
+                 * @enum {string}
+                 */
+                type: "doc";
+                /** @description Array of child document nodes */
+                content: {
+                    /** @description Node type (e.g., "paragraph", "text", "heading", "bulletList") */
+                    type: string;
+                    /** @description Node attributes */
+                    attrs?: {
+                        [key: string]: (string | null) | number | boolean;
+                    };
+                    /** @description Child nodes (recursive DocumentNode array) */
+                    content?: Record<string, never>[];
+                    /** @description Text content (only for text nodes) */
+                    text?: string;
+                    /** @description Text marks (bold, italic, links, etc.) - only for text nodes */
+                    marks?: {
+                        /** @description Mark type (e.g., "bold", "italic", "link") */
+                        type: string;
+                        /** @description Mark attributes */
+                        attrs?: {
+                            [key: string]: (string | null) | number | boolean;
+                        };
+                    }[];
+                }[];
+            };
+            /** @description Note content as plain text */
+            plainText: string;
+        };
+        NoteListResponse: {
+            data: components["schemas"]["Note"][];
+            nextCursor: string | null;
+            hasMore: boolean;
+        };
+        ErrorResponse: {
+            error: string;
+            message: string;
+            code?: string;
+        };
+        CreateNoteRequest: {
+            /**
+             * Format: uuid
+             * @description Optional custom ID for the note
+             */
+            id?: string;
+            /** @description Initial markdown text content */
+            text: string;
+            /** @description Icon for the note: Lucide icon name (e.g., "FileText") or emoji shortcode (e.g., ":memo:") */
+            icon?: string | null;
+            /** @description Hex color for the icon (e.g., "#FF5733"). Only applies to Lucide icons, not emojis. */
+            color?: string | null;
+            /** @description Parent folder ID */
+            folderId?: string;
+        };
+        UpdateNoteRequest: {
+            /** @description New text content for the note */
+            text?: string;
+            /** @description New icon for the note: Lucide icon name (e.g., "FileText") or emoji shortcode (e.g., ":memo:") */
+            icon?: string | null;
+            /** @description New hex color for the icon (e.g., "#FF5733"). Only applies to Lucide icons, not emojis. */
+            color?: string | null;
+            /** @description New parent folder ID */
+            folderId?: string | null;
+        };
+        DeleteNoteResponse: {
+            success: boolean;
+        };
+        /** @description Project description in multiple formats */
+        ProjectDescription: {
+            /** @description Description content as Markdown */
+            markdown: string;
+            /** @description Description content as HTML (only included when includeHtml=true) */
+            html?: string;
+            /**
+             * @description ProseMirror JSON document. Root node always has type "doc" with a content array of child nodes.
+             * @example {
+             *       "type": "doc",
+             *       "content": [
+             *         {
+             *           "type": "paragraph",
+             *           "content": [
+             *             {
+             *               "type": "text",
+             *               "text": "Hello "
+             *             },
+             *             {
+             *               "type": "text",
+             *               "text": "world",
+             *               "marks": [
+             *                 {
+             *                   "type": "bold"
+             *                 }
+             *               ]
+             *             }
+             *           ]
+             *         }
+             *       ]
+             *     }
+             */
+            json?: {
+                /**
+                 * @description Document root type, always "doc"
+                 * @enum {string}
+                 */
+                type: "doc";
+                /** @description Array of child document nodes */
+                content: {
+                    /** @description Node type (e.g., "paragraph", "text", "heading", "bulletList") */
+                    type: string;
+                    /** @description Node attributes */
+                    attrs?: {
+                        [key: string]: (string | null) | number | boolean;
+                    };
+                    /** @description Child nodes (recursive DocumentNode array) */
+                    content?: Record<string, never>[];
+                    /** @description Text content (only for text nodes) */
+                    text?: string;
+                    /** @description Text marks (bold, italic, links, etc.) - only for text nodes */
+                    marks?: {
+                        /** @description Mark type (e.g., "bold", "italic", "link") */
+                        type: string;
+                        /** @description Mark attributes */
+                        attrs?: {
+                            [key: string]: (string | null) | number | boolean;
+                        };
+                    }[];
+                }[];
+            };
+            /** @description Description content as plain text */
+            plainText: string;
+        } | null;
+        Project: {
+            id: string;
+            name: string;
+            icon: string | null;
+            color: string | null;
+            state: "planned" | "completed";
+            completedAt?: number | null;
+            createdAt: number;
+            updatedAt: number;
+            description?: components["schemas"]["ProjectDescription"];
+        };
+        ProjectListResponse: {
+            data: components["schemas"]["Project"][];
+            nextCursor: string | null;
+            hasMore: boolean;
+        };
+        CreateProjectRequest: {
+            /**
+             * Format: uuid
+             * @description Optional custom ID for the project
+             */
+            id?: string;
+            /** @description Name of the project */
+            name: string;
+            /** @description Project description in markdown format */
+            description?: string;
+            /** @description Icon for the project: Lucide icon name (e.g., "Folder") or emoji shortcode (e.g., ":rocket:") */
+            icon?: string | null;
+            /** @description Hex color for the icon (e.g., "#FF5733"). Only applies to Lucide icons, not emojis. */
+            color?: string | null;
+        };
+        UpdateProjectRequest: {
+            /** @description New name for the project */
+            name?: string;
+            /** @description Project description in markdown format */
+            description?: string;
+            /** @description New icon for the project: Lucide icon name (e.g., "Folder") or emoji shortcode (e.g., ":rocket:") */
+            icon?: string | null;
+            /** @description New hex color for the icon (e.g., "#FF5733"). Only applies to Lucide icons, not emojis. */
+            color?: string | null;
+            /**
+             * @description New state for the project
+             * @enum {string}
+             */
+            state?: "planned" | "completed";
+        };
+        DeleteProjectResponse: {
+            success: boolean;
+        };
+        SessionActivity: {
+            /** @enum {string} */
+            type: "TASK";
+            taskId: string;
+            id: string;
+            createdAt: number;
+            finishedAt: number;
+            sessionId: string;
+            isManual: boolean;
+        } | {
+            /** @enum {string} */
+            type: "MEETING";
+            title: string;
+            htmlLink: string;
+            meetingId: string;
+            calendarId?: string;
+            id: string;
+            createdAt: number;
+            finishedAt: number;
+            sessionId: string;
+            isManual: boolean;
+        } | {
+            /** @enum {string} */
+            type: "PLANNING";
+            id: string;
+            createdAt: number;
+            finishedAt: number;
+            sessionId: string;
+            isManual: boolean;
+        } | {
+            /** @enum {string} */
+            type: "WRAP_UP";
+            id: string;
+            createdAt: number;
+            finishedAt: number;
+            sessionId: string;
+            isManual: boolean;
+        };
+        Session: {
+            /**
+             * Format: uuid
+             * @description Unique identifier for the session
+             */
+            id: string;
+            /** @description Whether the session was manually created */
+            isManual: boolean;
+            /** @description Start timestamp (Unix seconds) */
+            createdAt: number;
+            /** @description End timestamp (Unix seconds) */
+            finishedAt: number;
+        };
+        SessionWithActivities: components["schemas"]["Session"] & {
+            /** @description Activities within this session */
+            activities: components["schemas"]["SessionActivity"][];
+        };
+        SessionListResponse: {
+            data: components["schemas"]["SessionWithActivities"][];
+            nextCursor: string | null;
+            hasMore: boolean;
+        };
+        CreateSessionRequest: {
+            /**
+             * Format: uuid
+             * @description Optional custom ID for the session
+             */
+            id?: string;
+            /** @description Start timestamp (Unix seconds) */
+            createdAt: number;
+            /** @description End timestamp (Unix seconds) */
+            finishedAt: number;
+        };
+        UpdateSessionRequest: {
+            /** @description New start timestamp (Unix seconds) */
+            createdAt?: number;
+            /** @description New end timestamp (Unix seconds) */
+            finishedAt?: number;
+        };
+        DeleteSessionResponse: {
+            success: boolean;
+        };
+        ActivityListResponse: {
+            data: components["schemas"]["SessionActivity"][];
+        };
+        CreateActivityRequest: {
+            /** @description Optional custom ID for the activity */
+            id?: string;
+            /** @enum {string} */
+            type: "TASK";
+            /** @description Associated task ID */
+            taskId: string;
+            /** @description Start timestamp (Unix seconds) */
+            createdAt: number;
+            /** @description End timestamp (Unix seconds) */
+            finishedAt: number;
+        };
+        UpdateActivityRequest: {
+            /** @description New start timestamp (Unix seconds) */
+            createdAt?: number;
+            /** @description New end timestamp (Unix seconds) */
+            finishedAt?: number;
+        };
+        DeleteActivityResponse: {
+            success: boolean;
+        };
+        TaskListResponse: {
+            data: components["schemas"]["Task"][];
+            nextCursor: string | null;
+            hasMore: boolean;
+        };
+        TaskBySection: {
+            /** Format: uuid */
+            taskId: string;
+            /** @enum {string} */
+            section: "today" | "sooner" | "later";
+            order: number;
+            task: components["schemas"]["Task"];
+        };
+        TaskSectionsResponse: {
+            today: components["schemas"]["TaskBySection"][];
+            sooner: components["schemas"]["TaskBySection"][];
+            later: components["schemas"]["TaskBySection"][];
+        };
+        TaskSubtasksResponse: {
+            data: components["schemas"]["Task"][];
+            nextCursor: string | null;
+            hasMore: boolean;
+        };
+        CreateTaskRequest: {
+            /**
+             * Format: uuid
+             * @description Optional custom ID for the task
+             */
+            id?: string;
+            /** @description Task name */
+            name: string;
+            /** @description Task description in markdown format */
+            description?: string;
+            /**
+             * Format: uuid
+             * @description Parent task ID for subtasks
+             */
+            parentId?: string;
+            /**
+             * Format: uuid
+             * @description Project to assign the task to
+             */
+            projectId?: string;
+            /**
+             * @description Section to place the task in. Required for root tasks (when parentId is not provided). Ignored for subtasks.
+             * @enum {string}
+             */
+            section?: "today" | "sooner" | "later";
+        };
+        UpdateTaskRequest: {
+            /** @description Task name */
+            name?: string;
+            /** @description Task description in markdown format */
+            description?: string;
+            /** @description Task completion status */
+            done?: "completed" | "canceled" | unknown | unknown;
+            /**
+             * Format: uuid
+             * @description Project to assign the task to
+             */
+            projectId?: string | null;
+            /** @description Mark task as waiting */
+            waiting?: {
+                reason?: string;
+            } | null;
+        };
+        DeleteTaskResponse: {
+            success: boolean;
+        };
+        TimerState: {
+            /**
+             * @description Current timer state
+             * @enum {string}
+             */
+            state: "IDLE" | "ACTIVE" | "PAUSED";
+            /** @description Planned duration in seconds (only present when not IDLE) */
+            duration?: number;
+            /** @description ID of the task being worked on (only present when ACTIVE with a task) */
+            currentTaskId?: string;
+            /** @description When the timer was started as Unix timestamp in seconds (only present when not IDLE) */
+            startedAt?: number;
+        };
+        StartTimerRequest: {
+            /** @description Duration in seconds (must be positive) */
+            duration: number;
+            /** @description Optional task ID to start working on */
+            taskId?: string;
+        };
+        StopTimerSession: {
+            /** @description Unique identifier for the session */
+            id: string;
+            /** @description Whether the session was manually created */
+            isManual: boolean;
+            /** @description Start timestamp (Unix seconds) */
+            createdAt: number;
+            /** @description End timestamp (Unix seconds) */
+            finishedAt: number;
+        };
+        StopTimerResponse: {
+            /** @description The completed sessions that were created */
+            sessions: components["schemas"]["StopTimerSession"][];
+        };
+        Webhook: {
+            /**
+             * Format: uuid
+             * @description Unique identifier for the webhook
+             */
+            id: string;
+            /**
+             * Format: uri
+             * @description URL to receive webhook payloads
+             */
+            url: string;
+            /** @description Entity types to listen for (task, project, timer, note) */
+            entityTypes: ("task" | "project" | "timer" | "note")[];
+            /** @description Event types to listen for (created, updated, deleted) */
+            eventTypes: ("created" | "updated" | "deleted")[];
+            /** @description Whether the webhook is active */
+            isActive: boolean;
+            /**
+             * Format: date-time
+             * @description Creation timestamp
+             */
+            createdAt: string;
+            /**
+             * Format: date-time
+             * @description Last update timestamp
+             */
+            updatedAt: string;
+        };
+        WebhookListResponse: {
+            data: components["schemas"]["Webhook"][];
+            nextCursor: string | null;
+            hasMore: boolean;
+        };
+        WebhookWithSecret: components["schemas"]["Webhook"] & {
+            /** @description Secret for verifying webhook signatures (only shown once) */
+            secret: string;
+        };
+        CreateWebhookRequest: {
+            /**
+             * Format: uri
+             * @description URL to receive webhook payloads
+             */
+            url: string;
+            /**
+             * @description Entity types to listen for
+             * @default [
+             *       "task",
+             *       "project",
+             *       "timer",
+             *       "note"
+             *     ]
+             */
+            entityTypes: ("task" | "project" | "timer" | "note")[];
+            /**
+             * @description Event types to listen for
+             * @default [
+             *       "created",
+             *       "updated",
+             *       "deleted"
+             *     ]
+             */
+            eventTypes: ("created" | "updated" | "deleted")[];
+        };
+        UpdateWebhookRequest: {
+            /**
+             * Format: uri
+             * @description New URL for webhook payloads
+             */
+            url?: string;
+            /** @description New entity types to listen for */
+            entityTypes?: ("task" | "project" | "timer" | "note")[];
+            /** @description New event types to listen for */
+            eventTypes?: ("created" | "updated" | "deleted")[];
+            /** @description Enable or disable the webhook */
+            isActive?: boolean;
+        };
+        DeleteWebhookResponse: {
+            success: boolean;
+        };
+        WebhookDelivery: {
+            /**
+             * Format: uuid
+             * @description Delivery ID
+             */
+            id: string;
+            /**
+             * Format: uuid
+             * @description Associated webhook ID
+             */
+            webhookId: string;
+            /**
+             * @description Delivery status
+             * @enum {string}
+             */
+            status: "pending" | "success" | "failed";
+            /** @description Number of delivery attempts */
+            attemptNumber: number;
+            /** @description HTTP response status code */
+            responseStatus: number | null;
+            /** @description Error message if failed */
+            errorMessage: string | null;
+            /**
+             * Format: date-time
+             * @description Delivery creation timestamp
+             */
+            createdAt: string;
+            /**
+             * Format: date-time
+             * @description Delivery completion timestamp
+             */
+            completedAt: string | null;
+        };
+        WebhookDeliveryListResponse: {
+            data: components["schemas"]["WebhookDelivery"][];
+            nextCursor: string | null;
+            hasMore: boolean;
+        };
+        RotateSecretResponse: {
+            /** @description New webhook secret */
+            secret: string;
+        };
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+
+/**
+ * Re-export types from the generated OpenAPI types.
+ * These provide typed access to the Locu API.
+ */
+
+type Task = components["schemas"]["Task"];
+type LocuTask = components["schemas"]["LocuTask"];
+type LinearTask = components["schemas"]["LinearTask"];
+type JiraTask = components["schemas"]["JiraTask"];
+type TaskDescription = components["schemas"]["TaskDescription"];
+type CreateTaskRequest = components["schemas"]["CreateTaskRequest"];
+type UpdateTaskRequest = components["schemas"]["UpdateTaskRequest"];
+type TaskListResponse = components["schemas"]["TaskListResponse"];
+type TaskBySection = components["schemas"]["TaskBySection"];
+type TaskSectionsResponse = components["schemas"]["TaskSectionsResponse"];
+type DeleteTaskResponse = components["schemas"]["DeleteTaskResponse"];
+type Project = components["schemas"]["Project"];
+type ProjectDescription = components["schemas"]["ProjectDescription"];
+type CreateProjectRequest = components["schemas"]["CreateProjectRequest"];
+type UpdateProjectRequest = components["schemas"]["UpdateProjectRequest"];
+type ProjectListResponse = components["schemas"]["ProjectListResponse"];
+type DeleteProjectResponse = components["schemas"]["DeleteProjectResponse"];
+type Note = components["schemas"]["Note"];
+type CreateNoteRequest = components["schemas"]["CreateNoteRequest"];
+type UpdateNoteRequest = components["schemas"]["UpdateNoteRequest"];
+type NoteListResponse = components["schemas"]["NoteListResponse"];
+type DeleteNoteResponse = components["schemas"]["DeleteNoteResponse"];
+type Session = components["schemas"]["Session"];
+type SessionWithActivities = components["schemas"]["SessionWithActivities"];
+type SessionActivity = components["schemas"]["SessionActivity"];
+type CreateSessionRequest = components["schemas"]["CreateSessionRequest"];
+type UpdateSessionRequest = components["schemas"]["UpdateSessionRequest"];
+type SessionListResponse = components["schemas"]["SessionListResponse"];
+type DeleteSessionResponse = components["schemas"]["DeleteSessionResponse"];
+type CreateActivityRequest = components["schemas"]["CreateActivityRequest"];
+type UpdateActivityRequest = components["schemas"]["UpdateActivityRequest"];
+type ActivityListResponse = components["schemas"]["ActivityListResponse"];
+type DeleteActivityResponse = components["schemas"]["DeleteActivityResponse"];
+type TimerState = components["schemas"]["TimerState"];
+type StartTimerRequest = components["schemas"]["StartTimerRequest"];
+type StopTimerResponse = components["schemas"]["StopTimerResponse"];
+type StopTimerSession = components["schemas"]["StopTimerSession"];
+type Webhook = components["schemas"]["Webhook"];
+type WebhookWithSecret = components["schemas"]["WebhookWithSecret"];
+type CreateWebhookRequest = components["schemas"]["CreateWebhookRequest"];
+type UpdateWebhookRequest = components["schemas"]["UpdateWebhookRequest"];
+type WebhookListResponse = components["schemas"]["WebhookListResponse"];
+type WebhookDelivery = components["schemas"]["WebhookDelivery"];
+type WebhookDeliveryListResponse = components["schemas"]["WebhookDeliveryListResponse"];
+type RotateSecretResponse = components["schemas"]["RotateSecretResponse"];
+type DeleteWebhookResponse = components["schemas"]["DeleteWebhookResponse"];
+type ErrorResponse = components["schemas"]["ErrorResponse"];
+type ApiError = ErrorResponse;
+type WebhookPayload<T = unknown> = {
+    /** Event type, e.g. "task.created", "project.updated" */
+    event: string;
+    /** ISO 8601 timestamp when the event occurred */
+    timestamp: string;
+    /** The entity data that triggered the event */
+    data: T;
+};
+type PaginatedResponse<T> = {
+    data: T[];
+    nextCursor: string | null;
+    hasMore: boolean;
+};
+type PaginationParams = {
+    limit?: number;
+    cursor?: string;
+};
+type TaskListParams = PaginationParams & {
+    done?: "true" | "false";
+    projectId?: string;
+    parentId?: string;
+    section?: "today" | "sooner" | "later";
+    doneAfter?: string;
+    doneBefore?: string;
+    includeHtml?: boolean | null;
+};
+type TaskSectionsParams = {
+    projectId?: string;
+    includeHtml?: boolean | null;
+};
+type SubtaskListParams = PaginationParams & {
+    done?: "true" | "false";
+    includeHtml?: boolean | null;
+};
+type ProjectListParams = PaginationParams & {
+    state?: "planned" | "completed";
+    includeHtml?: boolean | null;
+};
+type NoteListParams = PaginationParams & {
+    folderId?: string;
+    includeHtml?: boolean | null;
+};
+type SessionListParams = PaginationParams & {
+    startAfter?: string;
+    startBefore?: string;
+    includeActivities?: boolean | null;
+};
+type WebhookListParams = PaginationParams & {
+    isActive?: "true" | "false";
+};
+
+type LocuClientConfig = {
+    /** API base URL (defaults to https://api.locu.app/api/v1) */
+    baseUrl?: string;
+    /** Personal Access Token for authentication */
+    token: string;
+    /** Custom fetch implementation (defaults to global fetch) */
+    fetch?: typeof fetch;
+};
+declare class LocuApiError extends Error {
+    status: number;
+    code?: string;
+    constructor(message: string, status: number, code?: string);
+}
+declare const createLocuClient: (config: LocuClientConfig) => {
+    tasks: {
+        /** List all tasks */
+        list: (params?: TaskListParams) => Promise<PaginatedResponse<Task>>;
+        /** Get a single task by ID */
+        get: (id: string) => Promise<Task>;
+        /** Create a new task */
+        create: (data: CreateTaskRequest) => Promise<Task>;
+        /** Update an existing task */
+        update: (id: string, data: UpdateTaskRequest) => Promise<Task>;
+        /** Delete a task */
+        delete: (id: string) => Promise<{
+            success: boolean;
+        }>;
+        /** Get tasks organized by section (today, sooner, later) */
+        sections: (params?: TaskSectionsParams) => Promise<TaskSectionsResponse>;
+        /** List subtasks for a task */
+        subtasks: (id: string, params?: SubtaskListParams) => Promise<PaginatedResponse<Task>>;
+        /** Create a subtask under a parent task */
+        createSubtask: (parentId: string, data: Omit<CreateTaskRequest, "parentId" | "section">) => Promise<Task>;
+    };
+    projects: {
+        /** List all projects */
+        list: (params?: ProjectListParams) => Promise<PaginatedResponse<Project>>;
+        /** Get a single project by ID */
+        get: (id: string) => Promise<Project>;
+        /** Create a new project */
+        create: (data: CreateProjectRequest) => Promise<Project>;
+        /** Update an existing project */
+        update: (id: string, data: UpdateProjectRequest) => Promise<Project>;
+        /** Delete a project */
+        delete: (id: string) => Promise<{
+            success: boolean;
+        }>;
+    };
+    notes: {
+        /** List all notes */
+        list: (params?: NoteListParams) => Promise<PaginatedResponse<Note>>;
+        /** Get a single note by ID */
+        get: (id: string) => Promise<Note>;
+        /** Create a new note */
+        create: (data: CreateNoteRequest) => Promise<Note>;
+        /** Update an existing note */
+        update: (id: string, data: UpdateNoteRequest) => Promise<Note>;
+        /** Delete a note */
+        delete: (id: string) => Promise<{
+            success: boolean;
+        }>;
+    };
+    sessions: {
+        /** List all sessions */
+        list: (params?: SessionListParams) => Promise<PaginatedResponse<SessionWithActivities>>;
+        /** Get a single session by ID */
+        get: (id: string) => Promise<SessionWithActivities>;
+        /** Create a new session */
+        create: (data: CreateSessionRequest) => Promise<Session>;
+        /** Update an existing session */
+        update: (id: string, data: UpdateSessionRequest) => Promise<Session>;
+        /** Delete a session */
+        delete: (id: string) => Promise<{
+            success: boolean;
+        }>;
+        activities: {
+            /** List activities for a session */
+            list: (sessionId: string) => Promise<{
+                data: SessionActivity[];
+            }>;
+            /** Create a new activitie */
+            create: (sessionId: string, data: CreateActivityRequest) => Promise<SessionActivity>;
+            /** Update an activitie */
+            update: (sessionId: string, activityId: string, data: UpdateActivityRequest) => Promise<SessionActivity>;
+            /** Delete an activitie */
+            delete: (sessionId: string, activityId: string) => Promise<{
+                success: boolean;
+            }>;
+        };
+    };
+    webhooks: {
+        /** List all webhooks */
+        list: (params?: WebhookListParams) => Promise<PaginatedResponse<Webhook>>;
+        /** Get a single webhook by ID */
+        get: (id: string) => Promise<Webhook>;
+        /** Create a new webhook */
+        create: (data: CreateWebhookRequest) => Promise<WebhookWithSecret>;
+        /** Update an existing webhook */
+        update: (id: string, data: UpdateWebhookRequest) => Promise<Webhook>;
+        /** Delete a webhook */
+        delete: (id: string) => Promise<{
+            success: boolean;
+        }>;
+        /** Rotate webhook secret */
+        rotateSecret: (id: string) => Promise<{
+            secret: string;
+        }>;
+        /** List deliveries for a webhook */
+        deliveries: (id: string, params?: PaginationParams) => Promise<PaginatedResponse<WebhookDelivery>>;
+    };
+    timer: {
+        /** Get current timer state */
+        get: () => Promise<TimerState>;
+        /** Start a new timer */
+        start: (data?: StartTimerRequest) => Promise<TimerState>;
+        /** Pause the running timer */
+        pause: () => Promise<TimerState>;
+        /** Resume a paused timer */
+        continue: () => Promise<TimerState>;
+        /** Stop timer and save sessions */
+        stop: () => Promise<StopTimerResponse>;
+    };
+};
+type LocuClient = ReturnType<typeof createLocuClient>;
+
+type WebhookSignatureResult = {
+    valid: true;
+} | {
+    valid: false;
+    error: string;
+};
+type ParsedWebhookSignature = {
+    timestamp: number;
+    signature: string;
+};
+type VerifyWebhookOptions = {
+    /** Maximum age of signature in seconds (default: 300 = 5 minutes) */
+    maxAge?: number;
+};
+/**
+ * Parse a webhook signature header into its components.
+ *
+ * The signature header format is: `t=<timestamp>,v1=<hex_signature>`
+ *
+ * @param signatureHeader - The X-Webhook-Signature header value
+ * @returns Parsed timestamp and signature, or null if invalid format
+ *
+ * @example
+ * ```typescript
+ * const parsed = parseWebhookSignature(request.headers['x-webhook-signature'])
+ * if (parsed) {
+ *   console.log('Timestamp:', parsed.timestamp)
+ *   console.log('Signature:', parsed.signature)
+ * }
+ * ```
+ */
+declare const parseWebhookSignature: (signatureHeader: string) => ParsedWebhookSignature | null;
+/**
+ * Verify a webhook signature using HMAC-SHA256.
+ *
+ * This function verifies that a webhook payload was signed by Locu using your webhook secret.
+ * It also checks that the signature timestamp is not too old to prevent replay attacks.
+ *
+ * @param secret - Your webhook secret (starts with `whsec_`)
+ * @param signatureHeader - The X-Webhook-Signature header value
+ * @param body - The raw request body as a string
+ * @param options - Optional verification settings
+ * @returns Object with `valid: true` if valid, or `valid: false` with an error message
+ *
+ * @example
+ * ```typescript
+ * import { verifyWebhookSignature } from '@locu/api-client'
+ *
+ * app.post('/webhooks/locu', (req, res) => {
+ *   const result = verifyWebhookSignature(
+ *     process.env.LOCU_WEBHOOK_SECRET,
+ *     req.headers['x-webhook-signature'],
+ *     req.body, // raw body string
+ *     { maxAge: 300 } // 5 minutes
+ *   )
+ *
+ *   if (!result.valid) {
+ *     return res.status(401).json({ error: result.error })
+ *   }
+ *
+ *   // Process the webhook
+ *   const payload = JSON.parse(req.body)
+ *   console.log('Received event:', payload.event)
+ * })
+ * ```
+ */
+declare const verifyWebhookSignature: (secret: string, signatureHeader: string, body: string, options?: VerifyWebhookOptions) => WebhookSignatureResult;
+/**
+ * Parse a webhook payload from a JSON string.
+ *
+ * @param body - The raw request body as a JSON string
+ * @returns The parsed webhook payload
+ *
+ * @example
+ * ```typescript
+ * import { parseWebhookPayload, TaskWebhookPayload } from '@locu/api-client'
+ *
+ * const payload = parseWebhookPayload<TaskWebhookPayload>(req.body)
+ * console.log('Event:', payload.event) // e.g., "task.created"
+ * console.log('Task name:', payload.data.name)
+ * ```
+ */
+declare const parseWebhookPayload: <T = unknown>(body: string) => WebhookPayload<T>;
+/**
+ * Generate a webhook signature for testing purposes.
+ *
+ * This is useful for testing your webhook handlers locally.
+ *
+ * @param secret - Your webhook secret
+ * @param timestamp - Unix timestamp in seconds
+ * @param body - The request body as a string
+ * @returns The signature header value in format `t=<timestamp>,v1=<signature>`
+ *
+ * @example
+ * ```typescript
+ * import { generateWebhookSignature } from '@locu/api-client'
+ *
+ * const body = JSON.stringify({ event: 'task.created', timestamp: '...', data: {...} })
+ * const signature = generateWebhookSignature('whsec_...', Math.floor(Date.now() / 1000), body)
+ * // Use signature for testing your webhook handler
+ * ```
+ */
+declare const generateWebhookSignature: (secret: string, timestamp: number, body: string) => string;
+
+export { type ActivityListResponse, type ApiError, type CreateActivityRequest, type CreateNoteRequest, type CreateProjectRequest, type CreateSessionRequest, type CreateTaskRequest, type CreateWebhookRequest, type DeleteActivityResponse, type DeleteNoteResponse, type DeleteProjectResponse, type DeleteSessionResponse, type DeleteTaskResponse, type DeleteWebhookResponse, type ErrorResponse, type JiraTask, type LinearTask, LocuApiError, type LocuClient, type LocuClientConfig, type LocuTask, type Note, type NoteListParams, type NoteListResponse, type PaginatedResponse, type PaginationParams, type ParsedWebhookSignature, type Project, type ProjectDescription, type ProjectListParams, type ProjectListResponse, type RotateSecretResponse, type Session, type SessionActivity, type SessionListParams, type SessionListResponse, type SessionWithActivities, type StartTimerRequest, type StopTimerResponse, type StopTimerSession, type SubtaskListParams, type Task, type TaskBySection, type TaskDescription, type TaskListParams, type TaskListResponse, type TaskSectionsParams, type TaskSectionsResponse, type TimerState, type UpdateActivityRequest, type UpdateNoteRequest, type UpdateProjectRequest, type UpdateSessionRequest, type UpdateTaskRequest, type UpdateWebhookRequest, type VerifyWebhookOptions, type Webhook, type WebhookDelivery, type WebhookDeliveryListResponse, type WebhookListParams, type WebhookListResponse, type WebhookPayload, type WebhookSignatureResult, type WebhookWithSecret, createLocuClient, generateWebhookSignature, parseWebhookPayload, parseWebhookSignature, verifyWebhookSignature };