@knpkv/clockify-api-client 2.0.0 → 3.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knpkv/clockify-api-client",
-  "version": "2.0.0",
+  "version": "3.0.1",
   "description": "Effect-based Clockify REST API client",
   "license": "MIT",
   "author": "knpkv",
@@ -58,7 +58,7 @@
   ],
   "scripts": {
     "build": "tsc",
-    "check": "tsc --noEmit && tsc -p scripts/tsconfig.json",
+    "check": "tsc --noEmit && tsc -p scripts/tsconfig.json && tsc -p test/tsconfig.json --noEmit",
     "test": "vitest run",
     "test:watch": "vitest",
     "lint": "eslint src",

package/scripts/regenerate.ts

@@ -194,6 +194,7 @@ const root = Command.make("clockify-api-regenerate", { check, local }).pipe(
       const current = yield* fs.readFileString(scriptPaths.specFile).pipe(
         Effect.flatMap(Schema.decodeUnknownEffect(JsonString)),
         Effect.flatMap(canonicalJson),
+        // ast-grep-ignore: no-silent-catch-all -- follow-up: silent fallback; fail with a typed error, log it, or mark it best-effort
         Effect.orElseSucceed(() => "")
       )
 

package/src/generated/ClockifyApi.ts

@@ -25,8 +25,8 @@ export type FeaturePlan = { readonly "addonSubscriptionPlan"?: "FREE" | "BASIC"
 export const FeaturePlan = Schema.Struct({ "addonSubscriptionPlan": Schema.optionalKey(Schema.Literals(["FREE", "BASIC", "STANDARD", "PRO", "ENTERPRISE"])), "featurePermissions": Schema.optionalKey(Schema.Array(Schema.Literals(["ACTIVITY_MONITORING", "ADD_TIME_FOR_OTHERS", "ADMIN_PANEL", "ALERTS", "APPROVAL", "AUDIT_LOG", "AUTOMATIC_LOCK", "BRANDED_REPORTS", "BULK_EDIT", "CUSTOM_FIELDS", "CUSTOM_REPORTING", "CUSTOM_SUBDOMAIN", "CREATION_PERMISSIONS", "DECIMAL_FORMAT", "DISABLE_MANUAL_MODE", "EDIT_MEMBER_PROFILE", "EXCLUDE_NON_BILLABLE_FROM_ESTIMATE", "EXPENSES", "FILE_IMPORT", "TIMESHEET_IMPORT", "USER_IMPORT", "HIDE_PAGES", "HISTORIC_RATES", "INVOICING", "INVOICE_EMAILS", "INVOICE_REMINDERS", "LABOR_COST", "LOCATIONS", "MANAGER_ROLE", "MULTI_FACTOR_AUTHENTICATION", "PROJECT_BUDGET", "PROJECT_TEMPLATES", "GRANT_PROJECT_MANAGER_ROLE", "PRIVATE_PROJECT_ACCESS", "QUICKBOOKS_INTEGRATION", "RECURRING_ESTIMATES", "RECURRING_INVOICES", "REQUIRED_FIELDS", "SCHEDULED_REPORTS", "SCHEDULING", "SCHEDULING_BILLABLE_AND_COST_AMOUNT", "SCREENSHOTS", "SSO", "SUMMARY_ESTIMATE", "TARGETS_AND_REMINDERS", "TASK_RATES", "TASK_COST_RATES", "TASK_HOURLY_RATES", "TIME_OFF", "UNLIMITED_REPORTS", "USER_CUSTOM_FIELDS", "WHO_CAN_CHANGE_TIMEENTRY_BILLABILITY", "BREAKS", "KIOSK_SESSION_DURATION", "KIOSK_PIN_REQUIRED", "WHO_CAN_SEE_ALL_TIME_ENTRIES", "WHO_CAN_SEE_PROJECT_STATUS", "WHO_CAN_SEE_PUBLIC_PROJECTS_ENTRIES", "WHO_CAN_SEE_TEAMS_DASHBOARD", "WORKSPACE_LOCK_TIMEENTRIES", "WORKSPACE_TIME_AUDIT", "WORKSPACE_TIME_ROUNDING", "KIOSK", "KIOSK_SIX_DIGIT_PIN", "KIOSK_QR_CODE", "KIOSK_PHOTO_CAPTURE", "LIMITED_USERS", "FORECASTING", "TIME_TRACKING", "ATTENDANCE_REPORT", "WEEKLY_OVERTIME_CALCULATION_PERIOD", "MONTHLY_OVERTIME_CALCULATION_PERIOD", "WORKSPACE_TRANSFER", "FAVORITE_ENTRIES", "SPLIT_TIME_ENTRY", "CLIENT_CURRENCY", "SCHEDULING_FORECASTING", "SCIM", "UNLIMITED_USER_SEATS", "BILLABLE_HOURS", "PROJECT_ESTIMATE", "CSV_EXPORT", "XLSX_EXPORT", "ONE_MONTH_RANGE_REPORTS", "ONE_YEAR_RANGE_REPORTS", "SHARED_REPORTS"])).check(Schema.isUnique().annotate({ "expected": "an array with unique items" }))), "legacy": Schema.optionalKey(Schema.Boolean), "paidPlan": Schema.optionalKey(Schema.Boolean), "regionalAllowed": Schema.optionalKey(Schema.Boolean), "weight": Schema.optionalKey(Schema.Number.annotate({ "format": "int32" }).check(Schema.isInt().annotate({ "expected": "an integer" }))) }).annotate({ "description": "Represents a feature plan type enum.", "identifier": "FeaturePlan" })
 export type Feature = never
 export const Feature = Schema.Never.annotate({ "identifier": "Feature" })
-export type WorkspaceSubdomainDtoV1 = { readonly "enabled"?: boolean, readonly "name"?: string }
-export const WorkspaceSubdomainDtoV1 = Schema.Struct({ "enabled": Schema.optionalKey(Schema.Boolean.annotate({ "description": "Indicates whether subdomain is enabled on workspace" })), "name": Schema.optionalKey(Schema.String.annotate({ "description": "Represents subdomain name" })) }).annotate({ "description": "Represents the workspace subdomain", "identifier": "WorkspaceSubdomainDtoV1" })
+export type WorkspaceSubdomainDtoV1 = { readonly "enabled"?: boolean, readonly "name"?: string | null }
+export const WorkspaceSubdomainDtoV1 = Schema.Struct({ "enabled": Schema.optionalKey(Schema.Boolean.annotate({ "description": "Indicates whether subdomain is enabled on workspace" })), "name": Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]).annotate({ "description": "Represents subdomain name" })) }).annotate({ "description": "Represents the workspace subdomain", "identifier": "WorkspaceSubdomainDtoV1" })
 export type TimeApprovalSettingsDtoV1 = { readonly "approvalEnabled"?: boolean, readonly "approvalPeriod"?: "WEEKLY" | "SEMI_MONTHLY" | "MONTHLY", readonly "approvalRoles"?: ReadonlyArray<"ADMIN" | "TEAM_MANAGER" | "PROJECT_MANAGER"> }
 export const TimeApprovalSettingsDtoV1 = Schema.Struct({ "approvalEnabled": Schema.optionalKey(Schema.Boolean.annotate({ "description": "Indicates whether approval is enabled." })), "approvalPeriod": Schema.optionalKey(Schema.Literals(["WEEKLY", "SEMI_MONTHLY", "MONTHLY"]).annotate({ "description": "Represents the approval period." })), "approvalRoles": Schema.optionalKey(Schema.Array(Schema.Literals(["ADMIN", "TEAM_MANAGER", "PROJECT_MANAGER"]).annotate({ "description": "Represents the list of roles who can approve." })).annotate({ "description": "Represents the list of roles who can approve." }).check(Schema.isUnique().annotate({ "expected": "an array with unique items" }))) }).annotate({ "description": "Represents the settings for time approval.", "identifier": "TimeApprovalSettingsDtoV1" })
 export type AuditLogSettingsDtoV1 = { readonly "auditEnabled"?: boolean, readonly "clientAuditing"?: boolean, readonly "clientStartedRecording"?: string, readonly "expensesAuditing"?: boolean, readonly "expensesStartedRecording"?: string, readonly "projectAuditing"?: boolean, readonly "projectStartedRecording"?: string, readonly "tagAuditing"?: boolean, readonly "tagStartedRecording"?: string, readonly "timeEntryAuditing"?: boolean, readonly "timeEntryStartedRecording"?: string }
@@ -367,8 +367,8 @@ export type AuditLogDtoV1 = { readonly "action"?: "CREATE_TIME_PERSONAL_TIMER" |
 export const AuditLogDtoV1 = Schema.Struct({ "action": Schema.optionalKey(Schema.Literals(["CREATE_TIME_PERSONAL_TIMER", "CREATE_TIME_PERSONAL_MANUAL", "CREATE_TIME_IMPORT", "CREATE_TIME_KIOSK", "CREATE_TIME_FOR_OTHER", "RESTORE_TIME", "RESTORE_TIME_FOR_OTHER", "UPDATE_TIME_PERSONAL", "UPDATE_TIME_FOR_OTHER", "DELETE_TIME_PERSONAL", "DELETE_TIME_FOR_OTHER", "CREATE_PROJECT", "CREATE_PROJECT_IMPORT", "CREATE_PROJECT_QUICKBOOKS", "UPDATE_PROJECT", "DELETE_PROJECT", "CREATE_TASK", "CREATE_TASK_IMPORT", "UPDATE_TASK", "DELETE_TASK", "CREATE_CLIENT", "CREATE_CLIENT_IMPORT", "CREATE_CLIENT_QUICKBOOKS", "UPDATE_CLIENT", "DELETE_CLIENT", "CREATE_TAG", "CREATE_TAG_IMPORT", "UPDATE_TAG", "DELETE_TAG", "CREATE_EXPENSE", "CREATE_EXPENSE_FOR_OTHER", "RESTORE_EXPENSE", "RESTORE_EXPENSE_FOR_OTHER", "UPDATE_EXPENSE", "UPDATE_EXPENSE_FOR_OTHER", "DELETE_EXPENSE", "DELETE_EXPENSE_FOR_OTHER"]).annotate({ "description": "Represents an audit log action type." })), "content": Schema.optionalKey(Schema.String.annotate({ "description": "Represents the current value of the modified entity" })), "previousContent": Schema.optionalKey(Schema.String.annotate({ "description": "Represents the previous value of the modified entity." })), "timestamp": Schema.optionalKey(Schema.String.annotate({ "description": "Represents a timestamp of when the audit log entry was created." })), "userEmail": Schema.optionalKey(Schema.String.annotate({ "description": "Represents the email address of the user." })), "userId": Schema.optionalKey(Schema.String.annotate({ "description": "Represents a user identifier across the system." })), "userName": Schema.optionalKey(Schema.String.annotate({ "description": "Represents the name of the user." })), "workspaceId": Schema.optionalKey(Schema.String.annotate({ "description": "Represents a workspace identifier across the system." })) }).annotate({ "identifier": "AuditLogDtoV1" })
 export type UserCustomFieldValueDtoV1 = { readonly "customFieldId"?: string, readonly "customFieldName"?: string, readonly "customFieldType"?: CustomFieldType, readonly "userId"?: string, readonly "value"?: {  } }
 export const UserCustomFieldValueDtoV1 = Schema.Struct({ "customFieldId": Schema.optionalKey(Schema.String.annotate({ "description": "Represents custom field identifier across the system." })), "customFieldName": Schema.optionalKey(Schema.String.annotate({ "description": "Represents custom field name." })), "customFieldType": Schema.optionalKey(CustomFieldType), "userId": Schema.optionalKey(Schema.String.annotate({ "description": "Represents user identifier across the system." })), "value": Schema.optionalKey(Schema.Struct({  }).annotate({ "description": "Represents custom field value." })) }).annotate({ "description": "Represents a list of value objects for user’s custom fields.", "identifier": "UserCustomFieldValueDtoV1" })
-export type MembershipDtoV1 = { readonly "costRate"?: RateDtoV1, readonly "hourlyRate"?: HourlyRateDtoV1, readonly "membershipStatus"?: "PENDING" | "ACTIVE" | "DECLINED" | "INACTIVE" | "ALL", readonly "membershipType"?: "WORKSPACE" | "PROJECT" | "USERGROUP", readonly "targetId"?: string, readonly "userId"?: string }
-export const MembershipDtoV1 = Schema.Struct({ "costRate": Schema.optionalKey(RateDtoV1), "hourlyRate": Schema.optionalKey(HourlyRateDtoV1), "membershipStatus": Schema.optionalKey(Schema.Literals(["PENDING", "ACTIVE", "DECLINED", "INACTIVE", "ALL"]).annotate({ "description": "Represents a membership status enum." })), "membershipType": Schema.optionalKey(Schema.Literals(["WORKSPACE", "PROJECT", "USERGROUP"]).annotate({ "description": "Represents membership type enum." })), "targetId": Schema.optionalKey(Schema.String.annotate({ "description": "Represents target identifier across the system." })), "userId": Schema.optionalKey(Schema.String.annotate({ "description": "Represents user identifier across the system." })) }).annotate({ "description": "Represents a list of membership objects.", "identifier": "MembershipDtoV1" })
+export type MembershipDtoV1 = { readonly "costRate"?: RateDtoV1 | null, readonly "hourlyRate"?: HourlyRateDtoV1 | null, readonly "membershipStatus"?: "PENDING" | "ACTIVE" | "DECLINED" | "INACTIVE" | "ALL", readonly "membershipType"?: "WORKSPACE" | "PROJECT" | "USERGROUP", readonly "targetId"?: string, readonly "userId"?: string }
+export const MembershipDtoV1 = Schema.Struct({ "costRate": Schema.optionalKey(Schema.Union([RateDtoV1, Schema.Null])), "hourlyRate": Schema.optionalKey(Schema.Union([HourlyRateDtoV1, Schema.Null])), "membershipStatus": Schema.optionalKey(Schema.Literals(["PENDING", "ACTIVE", "DECLINED", "INACTIVE", "ALL"]).annotate({ "description": "Represents a membership status enum." })), "membershipType": Schema.optionalKey(Schema.Literals(["WORKSPACE", "PROJECT", "USERGROUP"]).annotate({ "description": "Represents membership type enum." })), "targetId": Schema.optionalKey(Schema.String.annotate({ "description": "Represents target identifier across the system." })), "userId": Schema.optionalKey(Schema.String.annotate({ "description": "Represents user identifier across the system." })) }).annotate({ "description": "Represents a list of membership objects.", "identifier": "MembershipDtoV1" })
 export type UserSettingsDtoV1 = { readonly "alerts"?: boolean, readonly "approval"?: boolean, readonly "collapseAllProjectLists"?: boolean, readonly "dashboardPinToTop"?: boolean, readonly "dashboardSelection"?: "ME" | "TEAM", readonly "dashboardViewType"?: "PROJECT" | "BILLABILITY", readonly "dateFormat": string, readonly "groupSimilarEntriesDisabled"?: boolean, readonly "invoiceReminders"?: boolean, readonly "isCompactViewOn"?: boolean, readonly "lang"?: string, readonly "longRunning"?: boolean, readonly "multiFactorEnabled"?: boolean, readonly "myStartOfDay"?: string, readonly "onboarding"?: boolean, readonly "projectListCollapse"?: number, readonly "projectPickerTaskFilter"?: boolean, readonly "pto"?: boolean, readonly "reminders"?: boolean, readonly "scheduledReports"?: boolean, readonly "scheduling"?: boolean, readonly "sendNewsletter"?: boolean, readonly "showOnlyWorkingDays"?: boolean, readonly "summaryReportSettings"?: SummaryReportSettingsDtoV1, readonly "theme"?: "DARK" | "DEFAULT", readonly "timeFormat": "HOUR12" | "HOUR24", readonly "timeTrackingManual"?: boolean, readonly "timeZone": string, readonly "weekStart"?: "MONDAY" | "TUESDAY" | "WEDNESDAY" | "THURSDAY" | "FRIDAY" | "SATURDAY" | "SUNDAY", readonly "weeklyUpdates"?: boolean }
 export const UserSettingsDtoV1 = Schema.Struct({ "alerts": Schema.optionalKey(Schema.Boolean), "approval": Schema.optionalKey(Schema.Boolean), "collapseAllProjectLists": Schema.optionalKey(Schema.Boolean), "dashboardPinToTop": Schema.optionalKey(Schema.Boolean), "dashboardSelection": Schema.optionalKey(Schema.Literals(["ME", "TEAM"])), "dashboardViewType": Schema.optionalKey(Schema.Literals(["PROJECT", "BILLABILITY"])), "dateFormat": Schema.String.annotate({ "description": "Represents a date format." }).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })), "groupSimilarEntriesDisabled": Schema.optionalKey(Schema.Boolean), "invoiceReminders": Schema.optionalKey(Schema.Boolean), "isCompactViewOn": Schema.optionalKey(Schema.Boolean), "lang": Schema.optionalKey(Schema.String), "longRunning": Schema.optionalKey(Schema.Boolean), "multiFactorEnabled": Schema.optionalKey(Schema.Boolean), "myStartOfDay": Schema.optionalKey(Schema.String), "onboarding": Schema.optionalKey(Schema.Boolean), "projectListCollapse": Schema.optionalKey(Schema.Number.annotate({ "format": "int32" }).check(Schema.isInt().annotate({ "expected": "an integer" }))), "projectPickerTaskFilter": Schema.optionalKey(Schema.Boolean), "pto": Schema.optionalKey(Schema.Boolean), "reminders": Schema.optionalKey(Schema.Boolean), "scheduledReports": Schema.optionalKey(Schema.Boolean), "scheduling": Schema.optionalKey(Schema.Boolean), "sendNewsletter": Schema.optionalKey(Schema.Boolean), "showOnlyWorkingDays": Schema.optionalKey(Schema.Boolean), "summaryReportSettings": Schema.optionalKey(SummaryReportSettingsDtoV1), "theme": Schema.optionalKey(Schema.Literals(["DARK", "DEFAULT"])), "timeFormat": Schema.Literals(["HOUR12", "HOUR24"]).annotate({ "description": "Represents a time format enum." }), "timeTrackingManual": Schema.optionalKey(Schema.Boolean), "timeZone": Schema.String.annotate({ "description": "Represents a valid timezone ID" }).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })), "weekStart": Schema.optionalKey(Schema.Literals(["MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY", "SATURDAY", "SUNDAY"]).annotate({ "description": "Represents a day of the week." })), "weeklyUpdates": Schema.optionalKey(Schema.Boolean) }).annotate({ "description": "Represents user settings object.", "identifier": "UserSettingsDtoV1" })
 export type BreakSettingsDtoV1 = { readonly "breaksEnabled"?: boolean, readonly "defaultBreakEntities"?: DefaultBreakEntitiesDtoV1 }
@@ -461,8 +461,8 @@ export type UpdateTimeEntryBulkRequest = { readonly "billable"?: boolean, readon
 export const UpdateTimeEntryBulkRequest = Schema.Struct({ "billable": Schema.optionalKey(Schema.Boolean.annotate({ "description": "Indicates whether a time entry is billable or not." })), "customFields": Schema.optionalKey(Schema.Array(UpdateCustomFieldRequest).check(Schema.isMinLength(0).annotate({ "expected": "a value with a length of at least 0" })).check(Schema.isMaxLength(50).annotate({ "expected": "a value with a length of at most 50" }))), "description": Schema.optionalKey(Schema.String.annotate({ "description": "Represents a time entry description." }).check(Schema.isMinLength(0).annotate({ "expected": "a value with a length of at least 0" })).check(Schema.isMaxLength(3000).annotate({ "expected": "a value with a length of at most 3000" }))), "end": Schema.optionalKey(Schema.String.annotate({ "description": "Represents an end date in the yyyy-MM-ddThh:mm:ssZ format.", "format": "date-time" })), "id": Schema.String.annotate({ "description": "Represents a time entry identifier across the system." }).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })), "projectId": Schema.optionalKey(Schema.String.annotate({ "description": "Represents a project identifier across the system." })), "start": Schema.optionalKey(Schema.String.annotate({ "description": "Represents a start date in the yyyy-MM-ddThh:mm:ssZ format.", "format": "date-time" })), "tagIds": Schema.optionalKey(Schema.Array(Schema.String.annotate({ "description": "Represents a list of tag ids." })).annotate({ "description": "Represents a list of tag ids." })), "taskId": Schema.optionalKey(Schema.String.annotate({ "description": "Represents a task identifier across the system." })), "type": Schema.optionalKey(Schema.Literals(["REGULAR", "BREAK"])) }).annotate({ "identifier": "UpdateTimeEntryBulkRequest" })
 export type TimeEntryDtoImplV1 = { readonly "billable": boolean, readonly "customFieldValues"?: ReadonlyArray<CustomFieldValueDtoV1>, readonly "description": string, readonly "id": string, readonly "isLocked"?: boolean, readonly "kioskId"?: string | null, readonly "projectId"?: string | null, readonly "tagIds"?: ReadonlyArray<string> | null, readonly "taskId"?: string | null, readonly "timeInterval": TimeIntervalDtoV1, readonly "type"?: "REGULAR" | "BREAK" | "HOLIDAY" | "TIME_OFF", readonly "userId": string, readonly "workspaceId": string }
 export const TimeEntryDtoImplV1 = Schema.Struct({ "billable": Schema.Boolean.annotate({ "description": "Indicates whether a time entry is billable." }), "customFieldValues": Schema.optionalKey(Schema.Array(CustomFieldValueDtoV1).annotate({ "description": "Represents a list of custom field value objects." })), "description": Schema.String.annotate({ "description": "Represents time entry description." }), "id": Schema.String.annotate({ "description": "Represents time entry identifier across the system." }), "isLocked": Schema.optionalKey(Schema.Boolean.annotate({ "description": "Represents whether time entry is locked for modification." })), "kioskId": Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]).annotate({ "description": "Represents kiosk identifier across the system." })), "projectId": Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]).annotate({ "description": "Represents project identifier across the system." })), "tagIds": Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null]).annotate({ "description": "Represents a list of tag identifiers across the system." })), "taskId": Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]).annotate({ "description": "Represents task identifier across the system." })), "timeInterval": TimeIntervalDtoV1, "type": Schema.optionalKey(Schema.Literals(["REGULAR", "BREAK", "HOLIDAY", "TIME_OFF"]).annotate({ "description": "Represents a time entry type enum." })), "userId": Schema.String.annotate({ "description": "Represents user identifier across the system." }), "workspaceId": Schema.String.annotate({ "description": "Represents workspace identifier across the system." }) }).annotate({ "identifier": "TimeEntryDtoImplV1" })
-export type TimeEntryWithRatesDtoV1 = { readonly "billable": boolean, readonly "costRate"?: RateDtoV1, readonly "customFieldValues"?: ReadonlyArray<CustomFieldValueDtoV1>, readonly "description": string, readonly "hourlyRate"?: RateDtoV1, readonly "id": string, readonly "isLocked"?: boolean, readonly "kioskId"?: string | null, readonly "projectId"?: string | null, readonly "tagIds"?: ReadonlyArray<string> | null, readonly "taskId"?: string | null, readonly "timeInterval": TimeIntervalDtoV1, readonly "type"?: "REGULAR" | "BREAK" | "HOLIDAY" | "TIME_OFF", readonly "userId": string, readonly "workspaceId": string }
-export const TimeEntryWithRatesDtoV1 = Schema.Struct({ "billable": Schema.Boolean.annotate({ "description": "Indicates whether a time entry is billable." }), "costRate": Schema.optionalKey(RateDtoV1), "customFieldValues": Schema.optionalKey(Schema.Array(CustomFieldValueDtoV1).annotate({ "description": "Represents a list of custom field value objects." })), "description": Schema.String.annotate({ "description": "Represents time entry description." }), "hourlyRate": Schema.optionalKey(RateDtoV1), "id": Schema.String.annotate({ "description": "Represents time entry identifier across the system." }), "isLocked": Schema.optionalKey(Schema.Boolean.annotate({ "description": "Represents whether time entry is locked for modification." })), "kioskId": Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]).annotate({ "description": "Represents kiosk identifier across the system." })), "projectId": Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]).annotate({ "description": "Represents project identifier across the system." })), "tagIds": Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null]).annotate({ "description": "Represents a list of tag identifiers across the system." })), "taskId": Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]).annotate({ "description": "Represents task identifier across the system." })), "timeInterval": TimeIntervalDtoV1, "type": Schema.optionalKey(Schema.Literals(["REGULAR", "BREAK", "HOLIDAY", "TIME_OFF"]).annotate({ "description": "Represents a time entry type enum." })), "userId": Schema.String.annotate({ "description": "Represents user identifier across the system." }), "workspaceId": Schema.String.annotate({ "description": "Represents workspace identifier across the system." }) }).annotate({ "identifier": "TimeEntryWithRatesDtoV1" })
+export type TimeEntryWithRatesDtoV1 = { readonly "billable": boolean, readonly "costRate"?: RateDtoV1 | null, readonly "customFieldValues"?: ReadonlyArray<CustomFieldValueDtoV1>, readonly "description": string, readonly "hourlyRate"?: RateDtoV1 | null, readonly "id": string, readonly "isLocked"?: boolean, readonly "kioskId"?: string | null, readonly "projectId"?: string | null, readonly "tagIds"?: ReadonlyArray<string> | null, readonly "taskId"?: string | null, readonly "timeInterval": TimeIntervalDtoV1, readonly "type"?: "REGULAR" | "BREAK" | "HOLIDAY" | "TIME_OFF", readonly "userId": string, readonly "workspaceId": string }
+export const TimeEntryWithRatesDtoV1 = Schema.Struct({ "billable": Schema.Boolean.annotate({ "description": "Indicates whether a time entry is billable." }), "costRate": Schema.optionalKey(Schema.Union([RateDtoV1, Schema.Null])), "customFieldValues": Schema.optionalKey(Schema.Array(CustomFieldValueDtoV1).annotate({ "description": "Represents a list of custom field value objects." })), "description": Schema.String.annotate({ "description": "Represents time entry description." }), "hourlyRate": Schema.optionalKey(Schema.Union([RateDtoV1, Schema.Null])), "id": Schema.String.annotate({ "description": "Represents time entry identifier across the system." }), "isLocked": Schema.optionalKey(Schema.Boolean.annotate({ "description": "Represents whether time entry is locked for modification." })), "kioskId": Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]).annotate({ "description": "Represents kiosk identifier across the system." })), "projectId": Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]).annotate({ "description": "Represents project identifier across the system." })), "tagIds": Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null]).annotate({ "description": "Represents a list of tag identifiers across the system." })), "taskId": Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]).annotate({ "description": "Represents task identifier across the system." })), "timeInterval": TimeIntervalDtoV1, "type": Schema.optionalKey(Schema.Literals(["REGULAR", "BREAK", "HOLIDAY", "TIME_OFF"]).annotate({ "description": "Represents a time entry type enum." })), "userId": Schema.String.annotate({ "description": "Represents user identifier across the system." }), "workspaceId": Schema.String.annotate({ "description": "Represents workspace identifier across the system." }) }).annotate({ "identifier": "TimeEntryWithRatesDtoV1" })
 export type TimeEntryDtoV1 = { readonly "billable"?: boolean, readonly "customFieldValues"?: ReadonlyArray<CustomFieldValueDtoV1>, readonly "description"?: string, readonly "id"?: string, readonly "isLocked"?: boolean, readonly "kioskId"?: string | null, readonly "projectId"?: string | null, readonly "tagIds"?: ReadonlyArray<string> | null, readonly "taskId"?: string | null, readonly "timeInterval"?: TimeIntervalDtoV1, readonly "type"?: "REGULAR" | "BREAK" | "HOLIDAY" | "TIME_OFF", readonly "userId"?: string, readonly "workspaceId"?: string }
 export const TimeEntryDtoV1 = Schema.Struct({ "billable": Schema.optionalKey(Schema.Boolean.annotate({ "description": "Indicates whether a time entry is billable." })), "customFieldValues": Schema.optionalKey(Schema.Array(CustomFieldValueDtoV1).annotate({ "description": "Represents a list of custom field value objects." })), "description": Schema.optionalKey(Schema.String.annotate({ "description": "Represents time entry description." })), "id": Schema.optionalKey(Schema.String.annotate({ "description": "Represents time entry identifier across the system." })), "isLocked": Schema.optionalKey(Schema.Boolean.annotate({ "description": "Represents whether time entry is locked for modification." })), "kioskId": Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]).annotate({ "description": "Represents kiosk identifier across the system." })), "projectId": Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]).annotate({ "description": "Represents project identifier across the system." })), "tagIds": Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null]).annotate({ "description": "Represents a list of tag identifiers across the system." })), "taskId": Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]).annotate({ "description": "Represents task identifier across the system." })), "timeInterval": Schema.optionalKey(TimeIntervalDtoV1), "type": Schema.optionalKey(Schema.Literals(["REGULAR", "BREAK", "HOLIDAY", "TIME_OFF"]).annotate({ "description": "Represents a time entry type enum." })), "userId": Schema.optionalKey(Schema.String.annotate({ "description": "Represents user identifier across the system." })), "workspaceId": Schema.optionalKey(Schema.String.annotate({ "description": "Represents workspace identifier across the system." })) }).annotate({ "identifier": "TimeEntryDtoV1" })
 export type UpdateInvoicedStatusRequest = { readonly "invoiced": boolean, readonly "timeEntryIds": ReadonlyArray<TimeEntryId> }
@@ -557,8 +557,8 @@ export type ReportFilterV1 = { readonly "amountShown"?: "EARNED" | "COST" | "PRO
 export const ReportFilterV1 = Schema.Struct({ "amountShown": Schema.optionalKey(Schema.Literals(["EARNED", "COST", "PROFIT", "HIDE_AMOUNT", "EXPORT"]).annotate({ "description": "If provided, you'll get filtered result including reports with provided amount shown." })), "amounts": Schema.optionalKey(Schema.Array(Schema.Literals(["EARNED", "COST", "PROFIT", "HIDE_AMOUNT", "EXPORT"]))), "approvalState": Schema.optionalKey(Schema.Literals(["APPROVED", "UNAPPROVED", "ALL"]).annotate({ "description": "If provided, you'll get filtered result including reports with provided approval state." })), "archived": Schema.optionalKey(Schema.Boolean.annotate({ "description": "Indicates whether the report is archived" })), "attendanceFilter": Schema.optionalKey(AttendanceFilterV1), "billable": Schema.optionalKey(Schema.Boolean.annotate({ "description": "Indicates whether the report is billable" })), "clients": Schema.optionalKey(ContainsArchivedFilterV1), "currency": Schema.optionalKey(ContainsArchivedFilterV1), "customFields": Schema.optionalKey(Schema.Array(CustomFieldFilterV1)), "dateFormat": Schema.optionalKey(Schema.String.annotate({ "description": "Provide date in format YYYY-MM-DD" })), "dateRangeEnd": Schema.String.annotate({ "description": "Provide date in format YYYY-MM-DDTHH:MM:SS.ssssss. The system interprets this value based on the user's timezone (provided in the timeZone request parameter or the timezone configured in the user profile)" }).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })), "dateRangeStart": Schema.String.annotate({ "description": "Provide date in format YYYY-MM-DDTHH:MM:SS.ssssss. The system interprets this value based on the user's timezone (provided in the timeZone request parameter or the timezone configured in the user profile)" }).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })), "dateRangeType": Schema.optionalKey(Schema.Literals(["ABSOLUTE", "TODAY", "YESTERDAY", "THIS_WEEK", "LAST_WEEK", "PAST_TWO_WEEKS", "THIS_MONTH", "LAST_MONTH", "THIS_YEAR", "LAST_YEAR"]).annotate({ "description": "Provide the date range type" })), "description": Schema.optionalKey(Schema.String.annotate({ "description": "Represents search term for filtering report entries by description" })), "detailedFilter": Schema.optionalKey(DetailedFilterV1), "exportType": Schema.optionalKey(Schema.Literals(["JSON", "JSON_V1", "PDF", "CSV", "XLSX", "ZIP"]).annotate({ "description": "If provided, you'll get filtered result including reports with provided export type." })), "invoicingState": Schema.optionalKey(Schema.Literals(["INVOICED", "UNINVOICED", "ALL"]).annotate({ "description": "If provided, you'll get filtered result including reports with provided invoicing state." })), "projects": Schema.optionalKey(ContainsArchivedFilterV1), "rounding": Schema.optionalKey(Schema.Boolean.annotate({ "description": "Indicates whether the report filter is rounding" })), "sortOrder": Schema.optionalKey(Schema.Literals(["ASCENDING", "DESCENDING"]).annotate({ "description": "If provided, you'll get sorted result by provided sort order." })), "summaryFilter": Schema.optionalKey(SummaryFilterV1), "tags": Schema.optionalKey(ContainsTagFilterV1), "tasks": Schema.optionalKey(ContainsTaskFilterV1), "timeFormat": Schema.optionalKey(Schema.String.annotate({ "description": "Provide time in format THH:MM:SS.ssssss" })), "timeZone": Schema.optionalKey(Schema.String.annotate({ "description": "If provided, you'll get filtered result including reports with provided time zone." })), "userCustomFields": Schema.optionalKey(Schema.Array(CustomFieldFilterV1).annotate({ "writeOnly": true })), "userGroups": Schema.optionalKey(ContainsUsersFilterV1), "userLocale": Schema.optionalKey(Schema.String.annotate({ "description": "If provided, you'll get filtered result including reports with provided user locale." })), "users": Schema.optionalKey(ContainsUsersFilterV1), "weekStart": Schema.optionalKey(Schema.Literals(["MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY", "SATURDAY", "SUNDAY"]).annotate({ "description": "If provided, you'll get filtered result including reports with provided week start." })), "weeklyFilter": Schema.optionalKey(WeeklyFilterV1), "withoutDescription": Schema.optionalKey(Schema.Boolean.annotate({ "description": "If set to 'true', report will only include entries with empty description" })), "zoomLevel": Schema.optionalKey(Schema.Literals(["WEEK", "MONTH", "YEAR"]).annotate({ "description": "If provided, you'll get filtered result including reports with provided zoom level." })) }).annotate({ "identifier": "ReportFilterV1" })
 export type ExpenseDetailedReportDtoV1 = { readonly "expenses"?: ReadonlyArray<ExpenseReportDtoV1>, readonly "totals"?: ExpenseTotalsDtoV1 }
 export const ExpenseDetailedReportDtoV1 = Schema.Struct({ "expenses": Schema.optionalKey(Schema.Array(ExpenseReportDtoV1).annotate({ "description": "Represents list of expenses" })), "totals": Schema.optionalKey(ExpenseTotalsDtoV1) }).annotate({ "description": "report", "identifier": "ExpenseDetailedReportDtoV1" })
-export type WorkspaceDtoV1 = { readonly "cakeOrganizationId"?: string, readonly "costRate"?: RateDtoV1, readonly "currencies"?: ReadonlyArray<CurrencyWithDefaultInfoDtoV1>, readonly "featureSubscriptionType"?: FeaturePlan, readonly "features"?: Feature, readonly "hourlyRate"?: HourlyRateDtoV1, readonly "id": string, readonly "imageUrl"?: string, readonly "memberships"?: ReadonlyArray<MembershipDtoV1>, readonly "name": string, readonly "subdomain"?: WorkspaceSubdomainDtoV1, readonly "workspaceSettings"?: WorkspaceSettingsDtoV1 }
-export const WorkspaceDtoV1 = Schema.Struct({ "cakeOrganizationId": Schema.optionalKey(Schema.String.annotate({ "description": "Represents the Cake organization identifier across the system." })), "costRate": Schema.optionalKey(RateDtoV1), "currencies": Schema.optionalKey(Schema.Array(CurrencyWithDefaultInfoDtoV1).annotate({ "description": "Represents currency with default info object." })), "featureSubscriptionType": Schema.optionalKey(FeaturePlan), "features": Schema.optionalKey(Feature), "hourlyRate": Schema.optionalKey(HourlyRateDtoV1), "id": Schema.String.annotate({ "description": "Represents workspace identifier across the system." }), "imageUrl": Schema.optionalKey(Schema.String.annotate({ "description": "Represents an image url." })), "memberships": Schema.optionalKey(Schema.Array(MembershipDtoV1).annotate({ "description": "Represents a list of membership objects." })), "name": Schema.String.annotate({ "description": "Represents workspace name." }), "subdomain": Schema.optionalKey(WorkspaceSubdomainDtoV1), "workspaceSettings": Schema.optionalKey(WorkspaceSettingsDtoV1) }).annotate({ "identifier": "WorkspaceDtoV1" })
+export type WorkspaceDtoV1 = { readonly "cakeOrganizationId"?: string, readonly "costRate"?: RateDtoV1, readonly "currencies"?: ReadonlyArray<CurrencyWithDefaultInfoDtoV1>, readonly "featureSubscriptionType"?: string, readonly "features"?: ReadonlyArray<string>, readonly "hourlyRate"?: HourlyRateDtoV1, readonly "id": string, readonly "imageUrl"?: string, readonly "memberships"?: ReadonlyArray<MembershipDtoV1>, readonly "name": string, readonly "subdomain"?: WorkspaceSubdomainDtoV1, readonly "workspaceSettings"?: { readonly [x: string]: Schema.Json } }
+export const WorkspaceDtoV1 = Schema.Struct({ "cakeOrganizationId": Schema.optionalKey(Schema.String.annotate({ "description": "Represents the Cake organization identifier across the system." })), "costRate": Schema.optionalKey(RateDtoV1), "currencies": Schema.optionalKey(Schema.Array(CurrencyWithDefaultInfoDtoV1).annotate({ "description": "Represents currency with default info object." })), "featureSubscriptionType": Schema.optionalKey(Schema.String.annotate({ "description": "The workspace's subscription plan, e.g. FREE_2026. The upstream spec references FeaturePlan, an object, but the API returns this string; it is left open because Clockify adds plan names." })), "features": Schema.optionalKey(Schema.Array(Schema.String).annotate({ "description": "The workspace's enabled features, e.g. TIME_TRACKING. The upstream spec references Feature, which has no type, but the API returns these strings; they are left open because Clockify adds features." })), "hourlyRate": Schema.optionalKey(HourlyRateDtoV1), "id": Schema.String.annotate({ "description": "Represents workspace identifier across the system." }), "imageUrl": Schema.optionalKey(Schema.String.annotate({ "description": "Represents an image url." })), "memberships": Schema.optionalKey(Schema.Array(MembershipDtoV1).annotate({ "description": "Represents a list of membership objects." })), "name": Schema.String.annotate({ "description": "Represents workspace name." }), "subdomain": Schema.optionalKey(WorkspaceSubdomainDtoV1), "workspaceSettings": Schema.optionalKey(Schema.Record(Schema.String, Schema.Json).annotate({ "description": "Workspace settings, not modelled: the upstream schema disagrees with live responses on many nullable and enum fields." })) }).annotate({ "identifier": "WorkspaceDtoV1" })
 export type ExpensesAndTotalsDtoV1 = { readonly "dailyTotals"?: ReadonlyArray<ExpenseDailyTotalsDtoV1>, readonly "expenses"?: ExpensesWithCountDtoV1, readonly "weeklyTotals"?: ReadonlyArray<ExpenseWeeklyTotalsDtoV1> }
 export const ExpensesAndTotalsDtoV1 = Schema.Struct({ "dailyTotals": Schema.optionalKey(Schema.Array(ExpenseDailyTotalsDtoV1).annotate({ "description": "Represents a list of expense daily total data transfer objects." })), "expenses": Schema.optionalKey(ExpensesWithCountDtoV1), "weeklyTotals": Schema.optionalKey(Schema.Array(ExpenseWeeklyTotalsDtoV1).annotate({ "description": "Represents a list of expense weekly total data transfer objects." })) }).annotate({ "identifier": "ExpensesAndTotalsDtoV1" })
 export type MemberProfileDtoV1 = { readonly "email"?: string, readonly "hasPassword"?: boolean, readonly "hasPendingApprovalRequest"?: boolean, readonly "imageUrl"?: string, readonly "name"?: string, readonly "userCustomFieldValues"?: ReadonlyArray<UserCustomFieldValueFullDtoV1>, readonly "weekStart"?: "MONDAY" | "TUESDAY" | "WEDNESDAY" | "THURSDAY" | "FRIDAY" | "SATURDAY" | "SUNDAY", readonly "workCapacity"?: string, readonly "workingDays"?: "MONDAY" | "TUESDAY" | "WEDNESDAY" | "THURSDAY" | "FRIDAY" | "SATURDAY" | "SUNDAY", readonly "workspaceNumber"?: number }

package/test/ClockifyApiClient.test.ts

@@ -196,6 +196,25 @@ it.layer(suite)("ClockifyApiClient", (it) => {
       expect(entries[0]?.tagIds).toBeNull()
     }))
 
+  it.effect("decodes a time-entries list whose entries have null rates", () =>
+    Effect.gen(function*() {
+      // Clockify returns costRate/hourlyRate as explicit null when no rate applies.
+      reply(200, [{
+        id: "entry-1",
+        description: "[ENG-6169] review transaction mapper",
+        billable: true,
+        userId: "user-1",
+        workspaceId: "workspace-1",
+        costRate: null,
+        hourlyRate: null,
+        timeInterval: { start: "2026-07-20T09:00:00Z", end: "2026-07-20T11:00:00Z", duration: "PT2H" }
+      }])
+      const client = yield* ClockifyApiClient
+      const entries = yield* client.getTimeEntries("workspace-1", "user-1")
+      expect(entries[0]?.costRate).toBeNull()
+      expect(entries[0]?.hourlyRate).toBeNull()
+    }))
+
   it.effect("fails when a successful response violates the generated schema", () =>
     Effect.gen(function*() {
       reply(200, { id: "user-1" })

package/test/GeneratedSchemas.test.ts

@@ -1,37 +1,31 @@
 import { describe, expect, it } from "@effect/vitest"
 import * as Effect from "effect/Effect"
 import * as Schema from "effect/Schema"
-import { type FeaturePlan, WorkspaceDtoV1 } from "../src/generated/ClockifyApi.js"
+import { FeaturePlan, WorkspaceDtoV1, WorkspaceSettingsDtoV1 } from "../src/generated/ClockifyApi.js"
 
-describe("generated workspace schema", () => {
+describe("generated workspace settings schema", () => {
   // Preserve both upstream spellings in responses without rewriting either value.
   it.effect.each(["ADMINS", "ADMINS_AND_PROJECT_MANAGERS", "ANYONE", "EVERYONE"])(
-    "preserves scheduling assignment creator %s in workspace responses",
+    "preserves scheduling assignment creator %s",
     (creator) =>
       Effect.gen(function*() {
-        const workspace = yield* Schema.decodeUnknownEffect(WorkspaceDtoV1)({
-          id: "workspace-1",
-          name: "Delivery",
-          workspaceSettings: {
-            schedulingSettings: { whoCanCreateAssignments: creator }
-          }
+        const settings = yield* Schema.decodeUnknownEffect(WorkspaceSettingsDtoV1)({
+          schedulingSettings: { whoCanCreateAssignments: creator }
         })
-        expect(workspace.workspaceSettings?.schedulingSettings?.whoCanCreateAssignments).toBe(creator)
+        expect(settings.schedulingSettings?.whoCanCreateAssignments).toBe(creator)
       })
   )
 
   it.effect("rejects undocumented scheduling assignment creators", () =>
     Effect.gen(function*() {
-      const failure = yield* Schema.decodeUnknownEffect(WorkspaceDtoV1)({
-        id: "workspace-1",
-        name: "Delivery",
-        workspaceSettings: {
-          schedulingSettings: { whoCanCreateAssignments: "OWNER_ONLY" }
-        }
+      const failure = yield* Schema.decodeUnknownEffect(WorkspaceSettingsDtoV1)({
+        schedulingSettings: { whoCanCreateAssignments: "OWNER_ONLY" }
       }).pipe(Effect.flip)
       expect(failure._tag).toBe("SchemaError")
     }))
+})
 
+describe("generated feature plan schema", () => {
   it.effect("decodes feature plans after removing the upstream recursive oneOf", () =>
     Effect.gen(function*() {
       const plan: FeaturePlan = {
@@ -40,21 +34,43 @@ describe("generated workspace schema", () => {
         paidPlan: true,
         weight: 3
       }
-      const workspace = yield* Schema.decodeUnknownEffect(WorkspaceDtoV1)({
-        id: "workspace-1",
-        name: "Delivery",
-        featureSubscriptionType: plan
-      })
-      expect(workspace.featureSubscriptionType).toEqual(plan)
+      expect(yield* Schema.decodeUnknownEffect(FeaturePlan)(plan)).toEqual(plan)
     }))
 
   it.effect("rejects feature plans with a fractional weight", () =>
     Effect.gen(function*() {
-      const failure = yield* Schema.decodeUnknownEffect(WorkspaceDtoV1)({
+      const failure = yield* Schema.decodeUnknownEffect(FeaturePlan)({ weight: 1.5 }).pipe(Effect.flip)
+      expect(failure._tag).toBe("SchemaError")
+    }))
+})
+
+describe("generated workspace schema", () => {
+  // Live /v1/workspaces responses: the plan is a string, features are strings, settings are not modelled.
+  it.effect("accepts the plan, features and settings shapes the API returns", () =>
+    Effect.gen(function*() {
+      const workspace = yield* Schema.decodeUnknownEffect(WorkspaceDtoV1)({
         id: "workspace-1",
         name: "Delivery",
-        featureSubscriptionType: { weight: 1.5 }
-      }).pipe(Effect.flip)
-      expect(failure._tag).toBe("SchemaError")
+        featureSubscriptionType: "FREE_2026",
+        features: ["TIME_TRACKING"],
+        workspaceSettings: { automaticLock: null, adminOnlyPages: [] },
+        memberships: [{ userId: "u1", costRate: null, hourlyRate: null }],
+        subdomain: { enabled: false, name: null }
+      })
+      expect(workspace.featureSubscriptionType).toBe("FREE_2026")
+      expect(workspace.features).toEqual(["TIME_TRACKING"])
     }))
+
+  it.effect.each([42, "oops", [], true])(
+    "rejects workspace settings that are not an object: %s",
+    (settings) =>
+      Effect.gen(function*() {
+        const failure = yield* Schema.decodeUnknownEffect(WorkspaceDtoV1)({
+          id: "workspace-1",
+          name: "Delivery",
+          workspaceSettings: settings
+        }).pipe(Effect.flip)
+        expect(failure._tag).toBe("SchemaError")
+      })
+  )
 })

package/test/WorkspaceSubscription.test.ts

@@ -0,0 +1,11 @@
+import { describe, expect, it } from "@effect/vitest"
+import { Schema } from "effect"
+import { GetWorkspacesOfUser200 } from "../src/generated/ClockifyApi.js"
+import workspaces from "./fixtures/clockify-workspaces.json" with { type: "json" }
+
+describe("workspace subscription plan", () => {
+  it("decodes a real-shaped /v1/workspaces response, whose featureSubscriptionType is a string", () => {
+    const [workspace] = Schema.decodeUnknownSync(GetWorkspacesOfUser200)(workspaces)
+    expect(workspace?.featureSubscriptionType).toBe("FREE_2026")
+  })
+})

package/test/fixtures/clockify-workspaces.json

@@ -0,0 +1,144 @@
+[
+  {
+    "id": "64f0c0ffee0000000000aa01",
+    "name": "Example Workspace",
+    "hourlyRate": {
+      "amount": 0,
+      "currency": "USD"
+    },
+    "costRate": {
+      "amount": 0,
+      "currency": "USD"
+    },
+    "memberships": [
+      {
+        "userId": "redacted",
+        "hourlyRate": null,
+        "costRate": null,
+        "targetId": "redacted",
+        "membershipType": "WORKSPACE",
+        "membershipStatus": "ACTIVE"
+      }
+    ],
+    "workspaceSettings": {
+      "timeRoundingInReports": false,
+      "onlyAdminsSeeBillableRates": true,
+      "activeBillableHours": false,
+      "onlyAdminsCanChangeBillableStatus": false,
+      "onlyAdminsCreateProject": false,
+      "onlyAdminsSeeDashboard": false,
+      "defaultBillableProjects": true,
+      "lockTimeEntries": null,
+      "lockTimeZone": null,
+      "round": {
+        "round": "redacted",
+        "minutes": "redacted"
+      },
+      "projectFavorites": true,
+      "canSeeTimeSheet": false,
+      "canSeeTracker": true,
+      "projectPickerSpecialFilter": false,
+      "forceProjects": false,
+      "forceTasks": false,
+      "forceTags": false,
+      "forceDescription": false,
+      "onlyAdminsSeeAllTimeEntries": false,
+      "onlyAdminsSeePublicProjectsEntries": false,
+      "onlyAdminsSeeProjectStatus": false,
+      "trackTimeDownToSecond": true,
+      "projectGroupingLabel": "CLIENT",
+      "adminOnlyPages": [],
+      "automaticLock": null,
+      "onlyAdminsCreateTag": false,
+      "timeApprovalEnabled": false,
+      "approvalSettings": {
+        "approvalEnabled": false,
+        "approvalPeriod": "WEEKLY",
+        "approvalRoles": ["TEAM_MANAGER", "ADMIN"]
+      },
+      "screenshotsEnabled": false,
+      "highResolutionScreenshots": false,
+      "locationsEnabled": false,
+      "onlyAdminsCreateTask": false,
+      "timeTrackingMode": "DEFAULT",
+      "taskBillableEnabled": false,
+      "taskRateEnabled": false,
+      "invoicingEnabled": false,
+      "expensesEnabled": false,
+      "schedulingEnabled": false,
+      "companyAddress": "redacted",
+      "canManagerEditUsersTime": false,
+      "timeOff": {
+        "active": false,
+        "regularUserCanSeeOtherUsersTimeOff": false,
+        "showDefaultPoliciesMessageToUsers": []
+      },
+      "auditLogSettings": null,
+      "schedulingSettings": {
+        "enabled": false,
+        "everyoneCanSeeAllAssignments": false,
+        "whoCanCreateAssignments": "ADMINS",
+        "canSeeBillableAndCostAmount": false
+      },
+      "kioskEnabled": false,
+      "kioskAuthType": null,
+      "kioskProjectsAndTasksEnabled": false,
+      "kioskAutologinEnabled": false,
+      "canManagerLaunchKiosk": false,
+      "kioskPhotoCaptureEnabled": false,
+      "multiFactorEnabled": false,
+      "numberFormat": "PERIOD_COMMA",
+      "currencyFormat": "VALUE_SPACE_CURRENCY",
+      "favoriteEntriesEnabled": false,
+      "breakSettings": {
+        "breaksEnabled": false,
+        "defaultBreakEntities": {
+          "projectId": null,
+          "taskId": null
+        }
+      },
+      "weekStart": "MONDAY",
+      "timeViewMode": "TIME_SENSITIVE_VIEW",
+      "whitelistedForAggregateView": false,
+      "workCapacity": "PT8H",
+      "overtimeCalculationPeriod": "DAILY",
+      "decimalFormat": false,
+      "durationFormat": "FULL",
+      "entityCreationPermissions": {
+        "whoCanCreateTasks": "EVERYONE",
+        "whoCanCreateProjectsAndClients": "EVERYONE",
+        "whoCanCreateTags": "EVERYONE"
+      },
+      "projectLabel": "redacted",
+      "taskLabel": "redacted",
+      "customLabels": {
+        "projectGroupingLabel": "redacted",
+        "projectLabel": "redacted",
+        "taskLabel": "redacted"
+      },
+      "workingDays": ["THURSDAY", "FRIDAY", "MONDAY", "TUESDAY", "WEDNESDAY"],
+      "isCostRateActive": false,
+      "expenseApprovalSettings": {
+        "approvalEnabled": false,
+        "approvalPeriod": "WEEKLY",
+        "approvalRoles": ["TEAM_MANAGER", "ADMIN"]
+      },
+      "isProjectPublicByDefault": true
+    },
+    "imageUrl": "redacted",
+    "featureSubscriptionType": "FREE_2026",
+    "features": ["TIME_TRACKING", "ONE_MONTH_RANGE_REPORTS"],
+    "currencies": [
+      {
+        "id": "redacted",
+        "code": "USD",
+        "isDefault": true
+      }
+    ],
+    "subdomain": {
+      "name": null,
+      "enabled": false
+    },
+    "cakeOrganizationId": "redacted"
+  }
+]

package/test/tsconfig.json

@@ -0,0 +1,6 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": { "noEmit": true, "composite": false, "rootDir": "..", "outDir": null, "tsBuildInfoFile": null },
+  "include": ["../src", "."],
+  "exclude": []
+}

package/vitest.config.ts

@@ -1,6 +1,8 @@
 import { defineConfig } from "vitest/config"
+import { workspaceSourceAlias } from "../../vitest.workspace-sources.ts"
 
 export default defineConfig({
+  resolve: { alias: [...workspaceSourceAlias] },
   test: {
     include: ["test/**/*.test.ts"]
   }