@todoist/sdk 0.0.1 → 19.0.0

package/dist/esm/types/apps/types.js

@@ -0,0 +1,255 @@
+import { z } from 'zod';
+import { StringOrNumberSchema } from '../common.js';
+import { UI_EXTENSION_TYPES } from '../ui-extensions/types.js';
+/**
+ * Available statuses for a developer application.
+ */
+export const APP_STATUSES = ['public'];
+export const AppStatusSchema = z.enum(APP_STATUSES);
+/**
+ * Webhook event types that can be subscribed to.
+ *
+ * These are the friendly public names the backend uses in webhook payloads.
+ * The on-the-wire config endpoint uses a different (legacy) form (see
+ * {@link WEBHOOK_EVENT_WIRE_NAMES}); the SDK converts between the two
+ * so consumers only ever work with these pretty names.
+ *
+ * @see https://developer.todoist.com/sync/v1/#webhooks
+ */
+export const WEBHOOK_EVENTS = [
+    'item:added',
+    'item:updated',
+    'item:completed',
+    'item:uncompleted',
+    'item:deleted',
+    'note:added',
+    'note:updated',
+    'note:deleted',
+    'project:added',
+    'project:updated',
+    'project:deleted',
+    'project:archived',
+    'project:unarchived',
+    'section:added',
+    'section:updated',
+    'section:deleted',
+    'section:archived',
+    'section:unarchived',
+    'label:added',
+    'label:updated',
+    'label:deleted',
+    'filter:added',
+    'filter:updated',
+    'filter:deleted',
+    'reminder:fired',
+];
+export const WebhookEventSchema = z.enum(WEBHOOK_EVENTS);
+/**
+ * Raw wire-format webhook event names used by the config endpoint
+ * (`POST/GET /apps/<id>/webhook`). Exported for completeness — prefer
+ * {@link WEBHOOK_EVENTS} when working with the SDK.
+ */
+export const WEBHOOK_EVENT_WIRE_NAMES = [
+    'e_item_added',
+    'e_item_updated',
+    'e_item_completed',
+    'e_item_uncompleted',
+    'e_item_deleted',
+    'e_note_added',
+    'e_note_updated',
+    'e_note_deleted',
+    'e_project_added',
+    'e_project_updated',
+    'e_project_deleted',
+    'e_project_archived',
+    'e_project_unarchived',
+    'e_section_added',
+    'e_section_updated',
+    'e_section_deleted',
+    'e_section_archived',
+    'e_section_unarchived',
+    'e_label_added',
+    'e_label_updated',
+    'e_label_deleted',
+    'e_filter_added',
+    'e_filter_updated',
+    'e_filter_deleted',
+    'e_reminder_fired',
+];
+export const WebhookEventWireNameSchema = z.enum(WEBHOOK_EVENT_WIRE_NAMES);
+/**
+ * Translates a wire-format event name (`'e_item_added'`) to its pretty form (`'item:added'`).
+ */
+export function webhookEventFromWireName(wireName) {
+    // Strip leading `e_`, replace first `_` with `:`. The resulting string is
+    // guaranteed to be a `WebhookEvent` by construction of the two const arrays.
+    return wireName.slice(2).replace('_', ':');
+}
+/**
+ * Translates a pretty event name (`'item:added'`) to its wire-format form (`'e_item_added'`).
+ */
+export function webhookEventToWireName(event) {
+    return ('e_' + event.replace(':', '_'));
+}
+/**
+ * Available statuses for an app webhook.
+ */
+export const WEBHOOK_STATUSES = ['active', 'invalid'];
+export const WebhookStatusSchema = z.enum(WEBHOOK_STATUSES);
+/**
+ * Supported webhook payload versions. v9 is deprecated and intentionally excluded.
+ */
+export const WEBHOOK_VERSIONS = ['1'];
+export const WebhookVersionSchema = z.enum(WEBHOOK_VERSIONS);
+/**
+ * Available installation types for an app installation.
+ */
+export const INSTALLATION_TYPES = ['user'];
+export const InstallationTypeSchema = z.enum(INSTALLATION_TYPES);
+/**
+ * Transforms a comma-separated scope string into `string[] | null`.
+ *
+ * The backend stores `app_token_scopes` as a single comma-separated string
+ * (e.g. `"data:read,task:add"`). Reads are exposed as `string[]` (rather than
+ * `Permission[]`) so that newly added backend scopes don't break parsing —
+ * writes accept `Permission` for autocomplete while still permitting `string`
+ * (via `UpdateAppArgs`), so a fetched `App.appTokenScopes` can be round-tripped
+ * back into `updateApp()` without casts.
+ *
+ * Preserves `null` on read (backend returns `null` for apps that have had
+ * their scopes cleared via `updateApp({ appTokenScopes: null })`) so the
+ * read and write shapes line up and information is not lost.
+ */
+export const AppTokenScopesSchema = z
+    .string()
+    .nullable()
+    .transform((value) => {
+    if (value === null)
+        return null;
+    if (value === '')
+        return [];
+    return value.split(',').filter(Boolean);
+});
+/**
+ * Available OAuth client types for a developer application (RFC 6749 §2.1).
+ */
+export const APP_CLIENT_TYPES = ['confidential', 'public'];
+export const AppClientTypeSchema = z.enum(APP_CLIENT_TYPES);
+/**
+ * Schema for a developer application.
+ * @see https://developer.todoist.com/api/v1/#tag/Apps
+ */
+export const AppSchema = z.object({
+    id: StringOrNumberSchema,
+    clientId: z.string(),
+    status: AppStatusSchema,
+    displayName: z.string(),
+    userId: StringOrNumberSchema,
+    createdAt: z.coerce.date(),
+    serviceUrl: z.string().nullable(),
+    oauthRedirectUri: z.string().nullable(),
+    description: z.string().nullable(),
+    iconSm: z.string().nullable(),
+    iconMd: z.string().nullable(),
+    iconLg: z.string().nullable(),
+    appTokenScopes: AppTokenScopesSchema,
+    clientType: AppClientTypeSchema,
+});
+/**
+ * Schema for a developer application that includes the user count.
+ * Returned by most endpoints that manage a single app (get, update, delete).
+ */
+export const AppWithUserCountSchema = AppSchema.extend({
+    userCount: z.number().int(),
+});
+/**
+ * OAuth client credentials for a developer application.
+ */
+export const AppSecretsSchema = z.object({
+    clientId: z.string(),
+    clientSecret: z.string(),
+});
+/**
+ * Webhook verification token for a developer application.
+ */
+export const AppVerificationTokenSchema = z.object({
+    verificationToken: z.string(),
+});
+/**
+ * Developer test access token for a developer application.
+ */
+export const AppTestTokenSchema = z.object({
+    accessToken: z.string().nullish(),
+});
+/**
+ * Distribution token for a developer application.
+ */
+export const AppDistributionTokenSchema = z.object({
+    distributionToken: z.string(),
+});
+/**
+ * Subset of an app returned when resolving by distribution token — used by the installation flow.
+ * Includes a lightweight list of the app's UI extensions (not full `UIExtension` records).
+ */
+export const AppByDistributionTokenUiExtensionSchema = z.object({
+    name: z.string(),
+    description: z.string(),
+    icon: z.string().nullable(),
+    extensionType: z.enum(UI_EXTENSION_TYPES),
+});
+export const AppByDistributionTokenSchema = z.object({
+    id: StringOrNumberSchema,
+    displayName: z.string(),
+    description: z.string().nullable(),
+    iconMd: z.string().nullable(),
+    appTokenScopes: AppTokenScopesSchema,
+    uiExtensions: z.array(AppByDistributionTokenUiExtensionSchema),
+});
+/**
+ * Schema for an app webhook.
+ *
+ * Events arrive from the wire in their `e_*` form and are transformed to
+ * their pretty `item:added`-style names for SDK consumers.
+ */
+export const AppWebhookSchema = z.object({
+    status: WebhookStatusSchema,
+    callbackUrl: z.string(),
+    version: WebhookVersionSchema,
+    events: z.array(WebhookEventWireNameSchema.transform(webhookEventFromWireName)),
+});
+/**
+ * Lightweight view of an app embedded in an installation record.
+ * Mirrors `AppSchema` shape — backend returns the same `ApplicationRestView`.
+ */
+export const InstalledIntegrationSchema = AppSchema;
+/**
+ * Schema for an installed application (integration installed to a user's account).
+ */
+export const AppInstallationSchema = z.object({
+    id: StringOrNumberSchema,
+    creator: StringOrNumberSchema,
+    createdTs: z.number().int(),
+    installationType: InstallationTypeSchema,
+    appTokenScopesValidated: z.boolean(),
+    integration: InstalledIntegrationSchema.nullable(),
+});
+/**
+ * Lightweight app info included on a user authorization record.
+ */
+export const UserAuthorizationAppSchema = z.object({
+    id: StringOrNumberSchema,
+    displayName: z.string(),
+    description: z.string().nullable(),
+    serviceUrl: z.string().nullable(),
+    iconMd: z.string().nullable(),
+});
+/**
+ * Schema for a user authorization entry — a token the user has granted to a third-party app.
+ */
+export const UserAuthorizationSchema = z.object({
+    accessTokenId: StringOrNumberSchema,
+    scope: z.array(z.string()),
+    scopeDescriptions: z.array(z.string()),
+    createdAt: z.coerce.date(),
+    app: UserAuthorizationAppSchema.nullable(),
+});

package/dist/esm/types/backups/index.js

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './requests.js';

package/dist/esm/types/backups/requests.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/backups/types.js

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+export const BackupSchema = z.object({
+    version: z.string(),
+    url: z.string(),
+});

package/dist/esm/types/billing/index.js

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './requests.js';

package/dist/esm/types/billing/requests.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/billing/types.js

@@ -0,0 +1,89 @@
+import { z } from 'zod';
+import { WORKSPACE_PLAN_STATUSES } from '../workspaces/types.js';
+/** Available subscription statuses. */
+export const BILLING_SUBSCRIPTION_STATUSES = [
+    'none',
+    'autorenew',
+    'canceled',
+    'expired',
+    'trial',
+    'trial_canceled',
+];
+/** Available plan tiers. */
+export const BILLING_PLANS = ['free', 'pro', 'pro_gifted', 'pro_legacy'];
+/** Ways an active subscription can be purchased. */
+export const BILLING_ACTIVATION_METHODS = [
+    'stripe',
+    'appstore',
+    'playstore',
+    'teams',
+    'manual',
+];
+/** Available billing cycles. */
+export const BILLING_CYCLES = ['monthly', 'yearly'];
+/** Available tax behaviors for a price. */
+export const TAX_BEHAVIORS = ['exclusive', 'inclusive', 'unspecified'];
+export const BillingPlanPriceSchema = z.object({
+    amount: z.string(),
+    rawAmount: z.number(),
+    currency: z.string(),
+    billingCycle: z.enum(BILLING_CYCLES).nullable(),
+    taxBehavior: z.enum(TAX_BEHAVIORS),
+});
+export const SubscriptionInfoSchema = z.object({
+    status: z.enum(BILLING_SUBSCRIPTION_STATUSES),
+    plan: z.enum(BILLING_PLANS),
+    expirationDate: z.string().nullable(),
+    activationMethod: z.enum(BILLING_ACTIVATION_METHODS),
+    planPrice: BillingPlanPriceSchema.nullable(),
+    billingPortalUrl: z.string().nullable(),
+    billingPortalSwitchToAnnualUrl: z.string().nullable(),
+    hasBillingPortal: z.boolean(),
+    hasBillingPortalSwitchToAnnual: z.boolean(),
+    invoiceCreditBalance: z.record(z.string(), z.number().int()).nullable(),
+    hasSwitchLegacyToCurrent: z.boolean(),
+});
+export const FormattedPriceSchema = z.object({
+    currency: z.string(),
+    unitAmount: z.number().int(),
+    taxBehavior: z.enum(TAX_BEHAVIORS),
+});
+export const PriceListingSchema = z.object({
+    billingCycle: z.enum(BILLING_CYCLES),
+    prices: z.array(FormattedPriceSchema),
+});
+export const ProPlanDetailsSchema = z.object({
+    currentPlanStatus: z.enum(WORKSPACE_PLAN_STATUSES),
+    downgradeAt: z.string().nullable(),
+    priceList: z.array(PriceListingSchema),
+});
+export const PricesResponseSchema = z.object({
+    pro: z.array(PriceListingSchema),
+    teams: z.array(PriceListingSchema),
+});
+/**
+ * Monthly and yearly amounts for a single currency. Each amount is a number in
+ * the currency's smallest unit, or a localized formatted string when the
+ * `pricing` endpoint is called with `formatted: true`.
+ */
+export const PricingTermsSchema = z.object({
+    monthly: z.union([z.number(), z.string()]),
+    yearly: z.union([z.number(), z.string()]),
+});
+/**
+ * A pricing version entry: plan name (`pro` / `biz`) → currency code →
+ * {@link PricingTerms}.
+ */
+export const PricingVersionSchema = z.record(z.string(), z.record(z.string(), PricingTermsSchema));
+/**
+ * Response of the `pricing` endpoint: fixed version-pointer string fields plus
+ * dynamic version keys (`v1`, `v2`, …), each a {@link PricingVersion}.
+ */
+export const PricingResponseSchema = z
+    .object({
+    latestPro: z.string(),
+    latestBiz: z.string(),
+    sessionPro: z.string(),
+    sessionBiz: z.string(),
+})
+    .catchall(PricingVersionSchema);

package/dist/esm/types/comments/index.js

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './requests.js';

package/dist/esm/types/comments/requests.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/comments/types.js

@@ -0,0 +1,57 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { z } from 'zod';
+/** Available file attachment upload states. */
+export const UPLOAD_STATES = ['pending', 'completed'];
+export const AttachmentSchema = z
+    .object({
+    resourceType: z.string(),
+})
+    .extend({
+    fileName: z.string().nullable().optional(),
+    fileSize: z.number().int().nullable().optional(),
+    fileType: z.string().nullable().optional(),
+    fileUrl: z.string().nullable().optional(),
+    fileDuration: z.number().int().nullable().optional(),
+    uploadState: z.enum(UPLOAD_STATES).nullable().optional(),
+    image: z.string().nullable().optional(),
+    imageWidth: z.number().int().nullable().optional(),
+    imageHeight: z.number().int().nullable().optional(),
+    url: z.string().nullable().optional(),
+    title: z.string().nullable().optional(),
+});
+export const RawCommentSchema = z
+    .object({
+    id: z.string(),
+    itemId: z.string().optional(),
+    projectId: z.string().optional(),
+    content: z.string(),
+    postedAt: z.coerce.date(),
+    fileAttachment: AttachmentSchema.nullable(),
+    postedUid: z.string(),
+    uidsToNotify: z.array(z.string()).nullable(),
+    reactions: z.record(z.string(), z.array(z.string())).nullable(),
+    isDeleted: z.boolean(),
+})
+    .refine((data) => {
+    // At least one of itemId or projectId must be present
+    return ((data.itemId !== undefined && data.projectId === undefined) ||
+        (data.itemId === undefined && data.projectId !== undefined));
+}, {
+    message: 'Exactly one of itemId or projectId must be provided',
+});
+export const CommentSchema = RawCommentSchema.transform((data) => {
+    const { itemId } = data, rest = __rest(data, ["itemId"]);
+    return Object.assign(Object.assign({}, rest), { 
+        // Map itemId to taskId for backwards compatibility
+        taskId: itemId });
+});

package/dist/esm/types/common.js

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+/**
+ * Zod schema that accepts both string and number values and coerces to string.
+ * The REST API returns numeric IDs while the Sync API returns string IDs.
+ */
+const StringOrNumberSchema = z.union([z.string(), z.number()]).transform((val) => String(val));
+export { StringOrNumberSchema };

package/dist/esm/types/emails/index.js

@@ -0,0 +1 @@
+export * from './requests.js';

package/dist/esm/types/emails/requests.js

@@ -0,0 +1,2 @@
+/** Object types that support email forwarding. */
+export const EMAIL_OBJECT_TYPES = ['project', 'project_comments', 'task'];

package/dist/esm/types/errors.js

@@ -0,0 +1,41 @@
+import { CustomError } from 'ts-custom-error';
+const authenticationErrorCodes = [401, 403];
+export class TodoistRequestError extends CustomError {
+    constructor(message, httpStatusCode, responseData) {
+        super(message);
+        this.message = message;
+        this.httpStatusCode = httpStatusCode;
+        this.responseData = responseData;
+        this.isAuthenticationError = () => {
+            if (!this.httpStatusCode) {
+                return false;
+            }
+            return authenticationErrorCodes.includes(this.httpStatusCode);
+        };
+        Object.defineProperty(this, 'name', { value: 'TodoistRequestError' });
+    }
+}
+/**
+ * Thrown when the Sync API accepts a request but one or more of its commands fail.
+ *
+ * Sync commands are applied independently, so the commands that succeeded have
+ * already taken effect. `message`, `httpStatusCode` and `responseData` describe the
+ * first failed command, as on a plain {@link TodoistRequestError}, while
+ * `syncStatus` and `tempIdMapping` cover every command in the request, so callers
+ * can tell which ones were applied.
+ */
+export class TodoistSyncError extends TodoistRequestError {
+    constructor(firstFailure, { syncStatus, tempIdMapping }) {
+        super(firstFailure.error, firstFailure.httpCode, firstFailure.errorExtra);
+        Object.defineProperty(this, 'name', { value: 'TodoistSyncError' });
+        this.syncStatus = syncStatus;
+        this.tempIdMapping = tempIdMapping;
+    }
+}
+export class TodoistArgumentError extends CustomError {
+    constructor(message) {
+        super(message);
+        this.message = message;
+        Object.defineProperty(this, 'name', { value: 'TodoistArgumentError' });
+    }
+}

package/dist/esm/types/folders/index.js

@@ -0,0 +1 @@
+export * from './requests.js';

package/dist/esm/types/folders/requests.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/http.js

@@ -0,0 +1,20 @@
+/**
+ * Type guard to check if an error is a network error
+ */
+export function isNetworkError(error) {
+    // Network errors in fetch are typically TypeError with specific messages.
+    // Timeout errors are created by fetch-with-retry with the TimeoutError name.
+    return ((error instanceof TypeError &&
+        (error.message.includes('fetch') ||
+            error.message.includes('network') ||
+            error.message.includes('Failed to fetch') ||
+            error.message.includes('NetworkError'))) ||
+        error.name === 'TimeoutError' ||
+        error.isNetworkError === true);
+}
+/**
+ * Type guard to check if an error is an HTTP error
+ */
+export function isHttpError(error) {
+    return 'status' in error && typeof error.status === 'number';
+}

package/dist/esm/types/id-mappings/index.js

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './requests.js';

package/dist/esm/types/id-mappings/requests.js

@@ -0,0 +1,17 @@
+/** Object types that support ID mappings. */
+export const ID_MAPPING_OBJECT_TYPES = [
+    'sections',
+    'tasks',
+    'comments',
+    'reminders',
+    'location_reminders',
+    'projects',
+];
+/** Object types that support moved ID lookups. */
+export const MOVED_ID_OBJECT_TYPES = [
+    'sections',
+    'tasks',
+    'comments',
+    'reminders',
+    'location_reminders',
+];

package/dist/esm/types/id-mappings/types.js

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export const IdMappingSchema = z.object({
+    oldId: z.string().nullable(),
+    newId: z.string().nullable(),
+});
+export const MovedIdSchema = z.object({
+    oldId: z.string(),
+    newId: z.string(),
+});

package/dist/esm/types/index.js

@@ -0,0 +1,24 @@
+export * from './tasks/index.js';
+export * from './projects/index.js';
+export * from './sections/index.js';
+export * from './labels/index.js';
+export * from './comments/index.js';
+export * from './reminders/index.js';
+export * from './users/index.js';
+export * from './productivity/index.js';
+export * from './activity/index.js';
+export * from './workspaces/index.js';
+export * from './folders/index.js';
+export * from './billing/index.js';
+export * from './insights/index.js';
+export * from './backups/index.js';
+export * from './id-mappings/index.js';
+export * from './emails/index.js';
+export * from './uploads/index.js';
+export * from './templates/index.js';
+export * from './errors.js';
+export * from './http.js';
+export * from './sync/index.js';
+export * from './apps/index.js';
+export * from './ui-extensions/index.js';
+export * from './webhooks/index.js';

package/dist/esm/types/insights/index.js

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './requests.js';

package/dist/esm/types/insights/requests.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/insights/types.js

@@ -0,0 +1,77 @@
+import { z } from 'zod';
+export const DayActivitySchema = z.object({
+    // Kept as string: this is a calendar-day bucket (e.g. '2025-01-13'), not a timestamp.
+    // Coercing to Date would create UTC midnight, causing day-shift for non-UTC consumers.
+    date: z.string(),
+    totalCount: z.number().int(),
+});
+export const WeekRollupSchema = z.object({
+    fromDate: z.string(),
+    toDate: z.string(),
+    totalCount: z.number().int(),
+});
+export const ProjectActivityStatsSchema = z.object({
+    dayItems: z.array(DayActivitySchema),
+    weekItems: z.array(WeekRollupSchema).nullable(),
+});
+/** Available project health statuses. */
+export const HEALTH_STATUSES = [
+    'UNKNOWN',
+    'ON_TRACK',
+    'AT_RISK',
+    'CRITICAL',
+    'EXCELLENT',
+    'ERROR',
+];
+export const ProjectHealthSchema = z.object({
+    status: z.enum(HEALTH_STATUSES),
+    description: z.string().nullable().optional(),
+    descriptionSummary: z.string().nullable().optional(),
+    projectId: z.string().nullable().optional(),
+    updatedAt: z.coerce.date().nullable().optional(),
+    isStale: z.boolean().default(false),
+    updateInProgress: z.boolean().default(false),
+});
+export const ProjectMetricsSchema = z.object({
+    totalTasks: z.number().int(),
+    completedTasks: z.number().int(),
+    overdueTasks: z.number().int(),
+    tasksCreatedThisWeek: z.number().int(),
+    tasksCompletedThisWeek: z.number().int(),
+    averageCompletionTime: z.number().nullable(),
+});
+export const TaskContextSchema = z.object({
+    id: z.string(),
+    content: z.string(),
+    due: z.string().nullable().optional(),
+    deadline: z.string().nullable().optional(),
+    priority: z.string(),
+    isCompleted: z.boolean(),
+    createdAt: z.coerce.date(),
+    updatedAt: z.coerce.date(),
+    completedAt: z.coerce.date().nullable(),
+    completedByUid: z.string().nullable(),
+    labels: z.array(z.string()),
+});
+export const ProjectHealthContextSchema = z.object({
+    projectId: z.string(),
+    projectName: z.string(),
+    projectDescription: z.string().nullable(),
+    projectMetrics: ProjectMetricsSchema,
+    tasks: z.array(TaskContextSchema),
+    language: z.string().nullable().optional(),
+});
+export const ProjectProgressSchema = z.object({
+    projectId: z.string(),
+    completedCount: z.number().int(),
+    activeCount: z.number().int(),
+    progressPercent: z.number().int(),
+});
+export const ProjectInsightSchema = z.object({
+    projectId: z.string(),
+    health: ProjectHealthSchema.nullable(),
+    progress: ProjectProgressSchema.nullable(),
+});
+export const WorkspaceInsightsSchema = z.object({
+    projectInsights: z.array(ProjectInsightSchema),
+});

package/dist/esm/types/labels/index.js

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './requests.js';

package/dist/esm/types/labels/requests.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/labels/types.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export const LabelSchema = z.object({
+    id: z.string(),
+    order: z.number().int().nullable(),
+    name: z.string(),
+    color: z.string(),
+    isFavorite: z.boolean(),
+});