shred-api-client 2.13.6 → 2.14.0

package/dist/index.d.ts

@@ -197,7 +197,7 @@ type Context = {
     requestId?: string;
 };
 
-interface IAPI$f {
+interface IAPI$g {
     getPrompt: (c: Context) => Promise<Prompt>;
     addScript: (c: Context, script: Partial<Script>) => Promise<Script>;
     deleteScript: (c: Context, id: string) => Promise<boolean>;
@@ -205,7 +205,7 @@ interface IAPI$f {
     generateScript: (c: Context, data: ScriptIARequest) => Promise<string>;
     updateScript: (c: Context, id: string, script: Partial<Script>) => Promise<boolean>;
 }
-declare const Endpoints$e: {
+declare const Endpoints$f: {
     GetPrompt: {
         uri: string;
         method: string;
@@ -232,15 +232,15 @@ declare const Endpoints$e: {
     };
 };
 
-type index$h_Category = Category;
-declare const index$h_CategorySchema: typeof CategorySchema;
-declare const index$h_PromptSchema: typeof PromptSchema;
-type index$h_Script = Script;
-type index$h_ScriptIARequest = ScriptIARequest;
-declare const index$h_ScriptIARequestSchema: typeof ScriptIARequestSchema;
-declare const index$h_ScriptSchema: typeof ScriptSchema;
-declare namespace index$h {
-  export { type index$h_Category as Category, index$h_CategorySchema as CategorySchema, Endpoints$e as Endpoints, type Prompt as Entity, type IAPI$f as IAPI, index$h_PromptSchema as PromptSchema, type index$h_Script as Script, type index$h_ScriptIARequest as ScriptIARequest, index$h_ScriptIARequestSchema as ScriptIARequestSchema, index$h_ScriptSchema as ScriptSchema };
+type index$i_Category = Category;
+declare const index$i_CategorySchema: typeof CategorySchema;
+declare const index$i_PromptSchema: typeof PromptSchema;
+type index$i_Script = Script;
+type index$i_ScriptIARequest = ScriptIARequest;
+declare const index$i_ScriptIARequestSchema: typeof ScriptIARequestSchema;
+declare const index$i_ScriptSchema: typeof ScriptSchema;
+declare namespace index$i {
+  export { type index$i_Category as Category, index$i_CategorySchema as CategorySchema, Endpoints$f as Endpoints, type Prompt as Entity, type IAPI$g as IAPI, index$i_PromptSchema as PromptSchema, type index$i_Script as Script, type index$i_ScriptIARequest as ScriptIARequest, index$i_ScriptIARequestSchema as ScriptIARequestSchema, index$i_ScriptSchema as ScriptSchema };
 }
 
 declare enum Type {
@@ -595,7 +595,7 @@ type Plan = z.infer<typeof PlanSchema>;
 type Product = z.infer<typeof ProductSchema>;
 type PromoCode = z.infer<typeof PromoCodeSchema>;
 
-interface IAPI$e {
+interface IAPI$f {
     getCharges: (ctx: Context) => Promise<Charge[]>;
     getPortalUrl: (ctx: Context) => Promise<string>;
     getSubscription: (context: Context, userId?: string) => Promise<Subscription | null>;
@@ -609,7 +609,7 @@ interface IAPI$e {
     getSubscriptionsSummary: (ctx: Context) => Promise<SubscriptionSummary[]>;
     listPromoCodes: (ctx: Context) => Promise<PromoCode[]>;
 }
-declare const Endpoints$d: {
+declare const Endpoints$e: {
     GetPortal: {
         uri: string;
         method: string;
@@ -668,19 +668,19 @@ declare const Endpoints$d: {
     };
 };
 
-type index$g_Charge = Charge;
-declare const index$g_ChargeSchema: typeof ChargeSchema;
-type index$g_Plan = Plan;
-declare const index$g_PlanSchema: typeof PlanSchema;
-type index$g_Product = Product;
-declare const index$g_ProductSchema: typeof ProductSchema;
-type index$g_PromoCode = PromoCode;
-declare const index$g_SubscriptionSchema: typeof SubscriptionSchema;
-declare const index$g_SubscriptionTypeSchema: typeof SubscriptionTypeSchema;
-type index$g_Type = Type;
-declare const index$g_Type: typeof Type;
-declare namespace index$g {
-  export { type index$g_Charge as Charge, index$g_ChargeSchema as ChargeSchema, Endpoints$d as Endpoints, type Subscription as Entity, type IAPI$e as IAPI, type index$g_Plan as Plan, index$g_PlanSchema as PlanSchema, type index$g_Product as Product, index$g_ProductSchema as ProductSchema, type index$g_PromoCode as PromoCode, index$g_SubscriptionSchema as SubscriptionSchema, index$g_SubscriptionTypeSchema as SubscriptionTypeSchema, type SubscriptionSummary as Summary, index$g_Type as Type };
+type index$h_Charge = Charge;
+declare const index$h_ChargeSchema: typeof ChargeSchema;
+type index$h_Plan = Plan;
+declare const index$h_PlanSchema: typeof PlanSchema;
+type index$h_Product = Product;
+declare const index$h_ProductSchema: typeof ProductSchema;
+type index$h_PromoCode = PromoCode;
+declare const index$h_SubscriptionSchema: typeof SubscriptionSchema;
+declare const index$h_SubscriptionTypeSchema: typeof SubscriptionTypeSchema;
+type index$h_Type = Type;
+declare const index$h_Type: typeof Type;
+declare namespace index$h {
+  export { type index$h_Charge as Charge, index$h_ChargeSchema as ChargeSchema, Endpoints$e as Endpoints, type Subscription as Entity, type IAPI$f as IAPI, type index$h_Plan as Plan, index$h_PlanSchema as PlanSchema, type index$h_Product as Product, index$h_ProductSchema as ProductSchema, type index$h_PromoCode as PromoCode, index$h_SubscriptionSchema as SubscriptionSchema, index$h_SubscriptionTypeSchema as SubscriptionTypeSchema, type SubscriptionSummary as Summary, index$h_Type as Type };
 }
 
 declare enum Role$1 {
@@ -873,16 +873,16 @@ type APIResponse<T> = {
     perPage?: number;
 };
 
-type index$f_APIResponse<T> = APIResponse<T>;
-type index$f_QueryFilterOp = QueryFilterOp;
-type index$f_QueryOptions<T> = QueryOptions<T>;
-type index$f_QueryOrderBy<T> = QueryOrderBy<T>;
-type index$f_QueryWhere<T> = QueryWhere<T>;
-declare namespace index$f {
-  export type { index$f_APIResponse as APIResponse, index$f_QueryFilterOp as QueryFilterOp, index$f_QueryOptions as QueryOptions, index$f_QueryOrderBy as QueryOrderBy, index$f_QueryWhere as QueryWhere };
+type index$g_APIResponse<T> = APIResponse<T>;
+type index$g_QueryFilterOp = QueryFilterOp;
+type index$g_QueryOptions<T> = QueryOptions<T>;
+type index$g_QueryOrderBy<T> = QueryOrderBy<T>;
+type index$g_QueryWhere<T> = QueryWhere<T>;
+declare namespace index$g {
+  export type { index$g_APIResponse as APIResponse, index$g_QueryFilterOp as QueryFilterOp, index$g_QueryOptions as QueryOptions, index$g_QueryOrderBy as QueryOrderBy, index$g_QueryWhere as QueryWhere };
 }
 
-interface IAPI$d {
+interface IAPI$e {
     getUserInfo: (context: Context) => Promise<User>;
     isEmailAvaliable: (email: string) => Promise<boolean>;
     sendValidationCode: (email: string) => Promise<boolean>;
@@ -899,7 +899,7 @@ interface IAPI$d {
     search: (ctx: Context, query: QueryOptions<User>) => Promise<APIResponse<User>>;
     createUser: (data: Create$2) => Promise<User>;
 }
-declare const Endpoints$c: {
+declare const Endpoints$d: {
     ChangeEmail: {
         uri: string;
         method: string;
@@ -966,11 +966,11 @@ declare const Endpoints$c: {
     };
 };
 
-type index$e_System = System;
-declare const index$e_System: typeof System;
-declare const index$e_UserSchema: typeof UserSchema;
-declare namespace index$e {
-  export { type Create$2 as Create, Endpoints$c as Endpoints, type User as Entity, type IAPI$d as IAPI, type Preferences$1 as Preferences, PreferencesSchema$1 as PreferencesSchema, Role$1 as Role, index$e_System as System, type Update$2 as Update, index$e_UserSchema as UserSchema };
+type index$f_System = System;
+declare const index$f_System: typeof System;
+declare const index$f_UserSchema: typeof UserSchema;
+declare namespace index$f {
+  export { type Create$2 as Create, Endpoints$d as Endpoints, type User as Entity, type IAPI$e as IAPI, type Preferences$1 as Preferences, PreferencesSchema$1 as PreferencesSchema, Role$1 as Role, index$f_System as System, type Update$2 as Update, index$f_UserSchema as UserSchema };
 }
 
 declare const PreferencesSchema: z.ZodObject<{
@@ -1710,7 +1710,7 @@ type Tenant = z.infer<typeof TenantSchema>;
 type Member = z.infer<typeof MemberSchema>;
 type Preferences = z.infer<typeof PreferencesSchema>;
 
-interface IAPI$c {
+interface IAPI$d {
     getByInviteCode: (code: string, context?: Context) => Promise<Tenant | null>;
     create: (tenant: Tenant, context: Context) => Promise<boolean>;
     /** Deleted tenants are left out unless `includeInactive` is true. */
@@ -1725,7 +1725,7 @@ interface IAPI$c {
 interface ListOptions {
     includeInactive?: boolean;
 }
-declare const Endpoints$b: {
+declare const Endpoints$c: {
     GetByInviteCode: {
         uri: string;
         method: string;
@@ -1764,18 +1764,18 @@ declare const Endpoints$b: {
     };
 };
 
-type index$d_ListOptions = ListOptions;
-type index$d_Member = Member;
-declare const index$d_MemberSchema: typeof MemberSchema;
-type index$d_MemberUpdate = MemberUpdate;
-declare const index$d_MemberUpdateSchema: typeof MemberUpdateSchema;
-type index$d_Preferences = Preferences;
-declare const index$d_PreferencesSchema: typeof PreferencesSchema;
-declare const index$d_TenantSchema: typeof TenantSchema;
-type index$d_TenantUpdate = TenantUpdate;
-declare const index$d_TenantUpdateSchema: typeof TenantUpdateSchema;
-declare namespace index$d {
-  export { Action$1 as Action, Endpoints$b as Endpoints, type Tenant as Entity, type IAPI$c as IAPI, type index$d_ListOptions as ListOptions, type index$d_Member as Member, index$d_MemberSchema as MemberSchema, type index$d_MemberUpdate as MemberUpdate, index$d_MemberUpdateSchema as MemberUpdateSchema, type index$d_Preferences as Preferences, index$d_PreferencesSchema as PreferencesSchema, index$d_TenantSchema as TenantSchema, type index$d_TenantUpdate as TenantUpdate, index$d_TenantUpdateSchema as TenantUpdateSchema };
+type index$e_ListOptions = ListOptions;
+type index$e_Member = Member;
+declare const index$e_MemberSchema: typeof MemberSchema;
+type index$e_MemberUpdate = MemberUpdate;
+declare const index$e_MemberUpdateSchema: typeof MemberUpdateSchema;
+type index$e_Preferences = Preferences;
+declare const index$e_PreferencesSchema: typeof PreferencesSchema;
+declare const index$e_TenantSchema: typeof TenantSchema;
+type index$e_TenantUpdate = TenantUpdate;
+declare const index$e_TenantUpdateSchema: typeof TenantUpdateSchema;
+declare namespace index$e {
+  export { Action$1 as Action, Endpoints$c as Endpoints, type Tenant as Entity, type IAPI$d as IAPI, type index$e_ListOptions as ListOptions, type index$e_Member as Member, index$e_MemberSchema as MemberSchema, type index$e_MemberUpdate as MemberUpdate, index$e_MemberUpdateSchema as MemberUpdateSchema, type index$e_Preferences as Preferences, index$e_PreferencesSchema as PreferencesSchema, index$e_TenantSchema as TenantSchema, type index$e_TenantUpdate as TenantUpdate, index$e_TenantUpdateSchema as TenantUpdateSchema };
 }
 
 declare const TrackParamSchema: z.ZodObject<{
@@ -1822,21 +1822,21 @@ declare const TrackSchema: z.ZodObject<{
 type Track = z.infer<typeof TrackSchema>;
 type TrackParam = z.infer<typeof TrackParamSchema>;
 
-interface IAPI$b {
+interface IAPI$c {
     send: (t: Track) => Promise<boolean>;
 }
-declare const Endpoints$a: {
+declare const Endpoints$b: {
     Track: {
         uri: string;
         method: string;
     };
 };
 
-type index$c_TrackParam = TrackParam;
-declare const index$c_TrackParamSchema: typeof TrackParamSchema;
-declare const index$c_TrackSchema: typeof TrackSchema;
-declare namespace index$c {
-  export { Endpoints$a as Endpoints, type Track as Entity, type IAPI$b as IAPI, type index$c_TrackParam as TrackParam, index$c_TrackParamSchema as TrackParamSchema, index$c_TrackSchema as TrackSchema };
+type index$d_TrackParam = TrackParam;
+declare const index$d_TrackParamSchema: typeof TrackParamSchema;
+declare const index$d_TrackSchema: typeof TrackSchema;
+declare namespace index$d {
+  export { Endpoints$b as Endpoints, type Track as Entity, type IAPI$c as IAPI, type index$d_TrackParam as TrackParam, index$d_TrackParamSchema as TrackParamSchema, index$d_TrackSchema as TrackSchema };
 }
 
 declare const EmailSchema: z.ZodObject<{
@@ -1854,19 +1854,19 @@ declare const EmailSchema: z.ZodObject<{
 }>;
 type Email = z.infer<typeof EmailSchema>;
 
-interface IAPI$a {
+interface IAPI$b {
     send: (email: Email, ctx?: Context) => Promise<boolean>;
 }
-declare const Endpoints$9: {
+declare const Endpoints$a: {
     SendEmail: {
         uri: string;
         method: string;
     };
 };
 
-declare const index$b_EmailSchema: typeof EmailSchema;
-declare namespace index$b {
-  export { index$b_EmailSchema as EmailSchema, Endpoints$9 as Endpoints, type Email as Entity, type IAPI$a as IAPI };
+declare const index$c_EmailSchema: typeof EmailSchema;
+declare namespace index$c {
+  export { index$c_EmailSchema as EmailSchema, Endpoints$a as Endpoints, type Email as Entity, type IAPI$b as IAPI };
 }
 
 declare enum Status$1 {
@@ -2272,7 +2272,7 @@ type Feedback = z.infer<typeof FeedbackSchema>;
 type Rating = z.infer<typeof RatingSchema>;
 type RatingInput = Pick<Rating, "score" | "tags" | "comment">;
 
-interface IAPI$9 {
+interface IAPI$a {
     /** Single-use credential for the SSE stream, which cannot carry a header. */
     streamTicket: (context: Context) => Promise<string>;
     reorder: (context: Context, projectId: string, position: number) => Promise<boolean>;
@@ -2300,7 +2300,7 @@ interface IAPI$9 {
         isEligibleForFreeProject(context: Context): Promise<boolean>;
     };
 }
-declare const Endpoints$8: {
+declare const Endpoints$9: {
     Reorder: {
         uri: string;
         method: string;
@@ -2431,33 +2431,33 @@ type StatusConfigType = {
 };
 declare const StatusConfig: Record<Status$1, StatusConfigType>;
 
-type index$a_Approve = Approve;
-type index$a_CaptionStyle = CaptionStyle;
-declare const index$a_CaptionStyle: typeof CaptionStyle;
-type index$a_Feedback = Feedback;
-declare const index$a_FeedbackSchema: typeof FeedbackSchema;
-type index$a_Interaction = Interaction;
-declare const index$a_InteractionSchema: typeof InteractionSchema;
-type index$a_InteractionType = InteractionType;
-declare const index$a_InteractionType: typeof InteractionType;
-type index$a_ProjectCreation = ProjectCreation;
-declare const index$a_ProjectSchema: typeof ProjectSchema;
-type index$a_Rating = Rating;
-type index$a_RatingInput = RatingInput;
-declare const index$a_RatingSchema: typeof RatingSchema;
-type index$a_RatingTag = RatingTag;
-declare const index$a_RatingTag: typeof RatingTag;
-type index$a_SendToApproval = SendToApproval;
-declare const index$a_StatusConfig: typeof StatusConfig;
-type index$a_StatusConfigType = StatusConfigType;
-type index$a_StreamTicket = StreamTicket;
-declare const index$a_StreamTicketSchema: typeof StreamTicketSchema;
-type index$a_Style = Style;
-declare const index$a_Styles: typeof Styles;
-type index$a_TimelineItem = TimelineItem;
-declare const index$a_TimelineItemSchema: typeof TimelineItemSchema;
-declare namespace index$a {
-  export { type index$a_Approve as Approve, index$a_CaptionStyle as CaptionStyle, Endpoints$8 as Endpoints, type Project as Entity, type index$a_Feedback as Feedback, index$a_FeedbackSchema as FeedbackSchema, type IAPI$9 as IAPI, type index$a_Interaction as Interaction, index$a_InteractionSchema as InteractionSchema, index$a_InteractionType as InteractionType, type index$a_ProjectCreation as ProjectCreation, index$a_ProjectSchema as ProjectSchema, type index$a_Rating as Rating, type index$a_RatingInput as RatingInput, index$a_RatingSchema as RatingSchema, index$a_RatingTag as RatingTag, type index$a_SendToApproval as SendToApproval, Status$1 as Status, index$a_StatusConfig as StatusConfig, type index$a_StatusConfigType as StatusConfigType, type index$a_StreamTicket as StreamTicket, index$a_StreamTicketSchema as StreamTicketSchema, type index$a_Style as Style, index$a_Styles as Styles, type index$a_TimelineItem as TimelineItem, index$a_TimelineItemSchema as TimelineItemSchema };
+type index$b_Approve = Approve;
+type index$b_CaptionStyle = CaptionStyle;
+declare const index$b_CaptionStyle: typeof CaptionStyle;
+type index$b_Feedback = Feedback;
+declare const index$b_FeedbackSchema: typeof FeedbackSchema;
+type index$b_Interaction = Interaction;
+declare const index$b_InteractionSchema: typeof InteractionSchema;
+type index$b_InteractionType = InteractionType;
+declare const index$b_InteractionType: typeof InteractionType;
+type index$b_ProjectCreation = ProjectCreation;
+declare const index$b_ProjectSchema: typeof ProjectSchema;
+type index$b_Rating = Rating;
+type index$b_RatingInput = RatingInput;
+declare const index$b_RatingSchema: typeof RatingSchema;
+type index$b_RatingTag = RatingTag;
+declare const index$b_RatingTag: typeof RatingTag;
+type index$b_SendToApproval = SendToApproval;
+declare const index$b_StatusConfig: typeof StatusConfig;
+type index$b_StatusConfigType = StatusConfigType;
+type index$b_StreamTicket = StreamTicket;
+declare const index$b_StreamTicketSchema: typeof StreamTicketSchema;
+type index$b_Style = Style;
+declare const index$b_Styles: typeof Styles;
+type index$b_TimelineItem = TimelineItem;
+declare const index$b_TimelineItemSchema: typeof TimelineItemSchema;
+declare namespace index$b {
+  export { type index$b_Approve as Approve, index$b_CaptionStyle as CaptionStyle, Endpoints$9 as Endpoints, type Project as Entity, type index$b_Feedback as Feedback, index$b_FeedbackSchema as FeedbackSchema, type IAPI$a as IAPI, type index$b_Interaction as Interaction, index$b_InteractionSchema as InteractionSchema, index$b_InteractionType as InteractionType, type index$b_ProjectCreation as ProjectCreation, index$b_ProjectSchema as ProjectSchema, type index$b_Rating as Rating, type index$b_RatingInput as RatingInput, index$b_RatingSchema as RatingSchema, index$b_RatingTag as RatingTag, type index$b_SendToApproval as SendToApproval, Status$1 as Status, index$b_StatusConfig as StatusConfig, type index$b_StatusConfigType as StatusConfigType, type index$b_StreamTicket as StreamTicket, index$b_StreamTicketSchema as StreamTicketSchema, type index$b_Style as Style, index$b_Styles as Styles, type index$b_TimelineItem as TimelineItem, index$b_TimelineItemSchema as TimelineItemSchema };
 }
 
 declare const DailyMilestoneSchema: z.ZodObject<{
@@ -2529,11 +2529,11 @@ declare const GoalSchema: z.ZodObject<{
 type DailyMilestone = z.infer<typeof DailyMilestoneSchema>;
 type Goal = z.infer<typeof GoalSchema>;
 
-interface IAPI$8 {
+interface IAPI$9 {
     getGoals: (context: Context) => Promise<Goal[]>;
     getEditorGoals: (context: Context, editorId: string) => Promise<Goal[]>;
 }
-declare const Endpoints$7: {
+declare const Endpoints$8: {
     GetGoals: {
         uri: string;
         method: string;
@@ -2544,11 +2544,11 @@ declare const Endpoints$7: {
     };
 };
 
-type index$9_DailyMilestone = DailyMilestone;
-declare const index$9_DailyMilestoneSchema: typeof DailyMilestoneSchema;
-declare const index$9_GoalSchema: typeof GoalSchema;
-declare namespace index$9 {
-  export { type index$9_DailyMilestone as DailyMilestone, index$9_DailyMilestoneSchema as DailyMilestoneSchema, Endpoints$7 as Endpoints, type Goal as Entity, index$9_GoalSchema as GoalSchema, type IAPI$8 as IAPI };
+type index$a_DailyMilestone = DailyMilestone;
+declare const index$a_DailyMilestoneSchema: typeof DailyMilestoneSchema;
+declare const index$a_GoalSchema: typeof GoalSchema;
+declare namespace index$a {
+  export { type index$a_DailyMilestone as DailyMilestone, index$a_DailyMilestoneSchema as DailyMilestoneSchema, Endpoints$8 as Endpoints, type Goal as Entity, index$a_GoalSchema as GoalSchema, type IAPI$9 as IAPI };
 }
 
 declare const EditorSchema: z.ZodObject<{
@@ -2581,11 +2581,11 @@ declare const EditorSchema: z.ZodObject<{
 }>;
 type Editor = z.infer<typeof EditorSchema>;
 
-interface IAPI$7 {
+interface IAPI$8 {
     getAll(context: Context): Promise<Editor[]>;
     getById(context: Context, editorId: string): Promise<Editor>;
 }
-declare const Endpoints$6: {
+declare const Endpoints$7: {
     GetAll: {
         uri: string;
         method: string;
@@ -2596,9 +2596,9 @@ declare const Endpoints$6: {
     };
 };
 
-declare const index$8_EditorSchema: typeof EditorSchema;
-declare namespace index$8 {
-  export { index$8_EditorSchema as EditorSchema, Endpoints$6 as Endpoints, type Editor as Entity, type IAPI$7 as IAPI };
+declare const index$9_EditorSchema: typeof EditorSchema;
+declare namespace index$9 {
+  export { index$9_EditorSchema as EditorSchema, Endpoints$7 as Endpoints, type Editor as Entity, type IAPI$8 as IAPI };
 }
 
 declare enum Frequency {
@@ -3099,7 +3099,7 @@ type RecurrenceRule = z.infer<typeof RecurrenceRuleSchema>;
 type History = z.infer<typeof HistorySchema>;
 type Criteria = z.infer<typeof CriteriaSchema>;
 
-interface IAPI$6 {
+interface IAPI$7 {
     getTriggers: (ctx: Context) => Promise<APIResponse<Trigger>>;
     createTrigger: (ctx: Context, t: Trigger) => Promise<Trigger>;
     deleteTrigger: (ctx: Context, triggerId: string) => Promise<boolean>;
@@ -3109,7 +3109,7 @@ interface IAPI$6 {
     markAsRead: (ctx: Context, id: string) => Promise<boolean>;
     clearNotifications: (ctx: Context) => Promise<boolean>;
 }
-declare const Endpoints$5: {
+declare const Endpoints$6: {
     Create: {
         uri: string;
         method: string;
@@ -3144,35 +3144,35 @@ declare const Endpoints$5: {
     };
 };
 
-type index$7_Criteria = Criteria;
-declare const index$7_CriteriaSchema: typeof CriteriaSchema;
-type index$7_CriteriaType = CriteriaType;
-declare const index$7_CriteriaType: typeof CriteriaType;
-type index$7_Frequency = Frequency;
-declare const index$7_Frequency: typeof Frequency;
-type index$7_History = History;
-declare const index$7_HistorySchema: typeof HistorySchema;
-type index$7_NotificationDetail = NotificationDetail;
-declare const index$7_NotificationDetailSchema: typeof NotificationDetailSchema;
-type index$7_NotificationItem = NotificationItem;
-declare const index$7_NotificationItemSchema: typeof NotificationItemSchema;
-type index$7_NotificationType = NotificationType;
-declare const index$7_NotificationType: typeof NotificationType;
-type index$7_RecurrenceRule = RecurrenceRule;
-declare const index$7_RecurrenceRuleSchema: typeof RecurrenceRuleSchema;
-type index$7_Status = Status;
-declare const index$7_Status: typeof Status;
-type index$7_TransportType = TransportType;
-declare const index$7_TransportType: typeof TransportType;
-type index$7_Trigger = Trigger;
-declare const index$7_TriggerSchema: typeof TriggerSchema;
-type index$7_WeekDay = WeekDay;
-declare const index$7_WeekDay: typeof WeekDay;
-declare namespace index$7 {
-  export { type index$7_Criteria as Criteria, index$7_CriteriaSchema as CriteriaSchema, index$7_CriteriaType as CriteriaType, Endpoints$5 as Endpoints, index$7_Frequency as Frequency, type index$7_History as History, index$7_HistorySchema as HistorySchema, type IAPI$6 as IAPI, type index$7_NotificationDetail as NotificationDetail, index$7_NotificationDetailSchema as NotificationDetailSchema, type index$7_NotificationItem as NotificationItem, index$7_NotificationItemSchema as NotificationItemSchema, index$7_NotificationType as NotificationType, type index$7_RecurrenceRule as RecurrenceRule, index$7_RecurrenceRuleSchema as RecurrenceRuleSchema, index$7_Status as Status, index$7_TransportType as TransportType, type index$7_Trigger as Trigger, index$7_TriggerSchema as TriggerSchema, index$7_WeekDay as WeekDay };
+type index$8_Criteria = Criteria;
+declare const index$8_CriteriaSchema: typeof CriteriaSchema;
+type index$8_CriteriaType = CriteriaType;
+declare const index$8_CriteriaType: typeof CriteriaType;
+type index$8_Frequency = Frequency;
+declare const index$8_Frequency: typeof Frequency;
+type index$8_History = History;
+declare const index$8_HistorySchema: typeof HistorySchema;
+type index$8_NotificationDetail = NotificationDetail;
+declare const index$8_NotificationDetailSchema: typeof NotificationDetailSchema;
+type index$8_NotificationItem = NotificationItem;
+declare const index$8_NotificationItemSchema: typeof NotificationItemSchema;
+type index$8_NotificationType = NotificationType;
+declare const index$8_NotificationType: typeof NotificationType;
+type index$8_RecurrenceRule = RecurrenceRule;
+declare const index$8_RecurrenceRuleSchema: typeof RecurrenceRuleSchema;
+type index$8_Status = Status;
+declare const index$8_Status: typeof Status;
+type index$8_TransportType = TransportType;
+declare const index$8_TransportType: typeof TransportType;
+type index$8_Trigger = Trigger;
+declare const index$8_TriggerSchema: typeof TriggerSchema;
+type index$8_WeekDay = WeekDay;
+declare const index$8_WeekDay: typeof WeekDay;
+declare namespace index$8 {
+  export { type index$8_Criteria as Criteria, index$8_CriteriaSchema as CriteriaSchema, index$8_CriteriaType as CriteriaType, Endpoints$6 as Endpoints, index$8_Frequency as Frequency, type index$8_History as History, index$8_HistorySchema as HistorySchema, type IAPI$7 as IAPI, type index$8_NotificationDetail as NotificationDetail, index$8_NotificationDetailSchema as NotificationDetailSchema, type index$8_NotificationItem as NotificationItem, index$8_NotificationItemSchema as NotificationItemSchema, index$8_NotificationType as NotificationType, type index$8_RecurrenceRule as RecurrenceRule, index$8_RecurrenceRuleSchema as RecurrenceRuleSchema, index$8_Status as Status, index$8_TransportType as TransportType, type index$8_Trigger as Trigger, index$8_TriggerSchema as TriggerSchema, index$8_WeekDay as WeekDay };
 }
 
-interface IAPI$5 {
+interface IAPI$6 {
     version: () => Promise<string>;
 }
 
@@ -3316,13 +3316,13 @@ declare const NoteSchema: z.ZodObject<{
 type Note = z.infer<typeof NoteSchema>;
 type NoteHistory = z.infer<typeof NoteHistorySchema>;
 
-interface IAPI$4 {
+interface IAPI$5 {
     list: (c: Context, userId: string) => Promise<Note[]>;
     add: (c: Context, note: Partial<Note>) => Promise<Note>;
     update: (c: Context, id: string, script: Partial<Note>) => Promise<Note>;
     delete: (c: Context, id: string) => Promise<boolean>;
 }
-declare const Endpoints$4: {
+declare const Endpoints$5: {
     GetNotes: {
         uri: string;
         method: string;
@@ -3341,11 +3341,11 @@ declare const Endpoints$4: {
     };
 };
 
-type index$6_NoteHistory = NoteHistory;
-declare const index$6_NoteHistorySchema: typeof NoteHistorySchema;
-declare const index$6_NoteSchema: typeof NoteSchema;
-declare namespace index$6 {
-  export { Endpoints$4 as Endpoints, type Note as Entity, type IAPI$4 as IAPI, type index$6_NoteHistory as NoteHistory, index$6_NoteHistorySchema as NoteHistorySchema, index$6_NoteSchema as NoteSchema };
+type index$7_NoteHistory = NoteHistory;
+declare const index$7_NoteHistorySchema: typeof NoteHistorySchema;
+declare const index$7_NoteSchema: typeof NoteSchema;
+declare namespace index$7 {
+  export { Endpoints$5 as Endpoints, type Note as Entity, type IAPI$5 as IAPI, type index$7_NoteHistory as NoteHistory, index$7_NoteHistorySchema as NoteHistorySchema, index$7_NoteSchema as NoteSchema };
 }
 
 declare const SpecialOfferSchema: z.ZodObject<{
@@ -3462,7 +3462,7 @@ type UserOfferDetails = z.infer<typeof UserOfferDetailsSchema>;
 type Create$1 = z.infer<typeof CreateSpecialOfferSchema>;
 type Update$1 = z.infer<typeof UpdateSpecialOfferSchema>;
 
-interface IAPI$3 {
+interface IAPI$4 {
     list: (ctx: Context) => Promise<SpecialOffer[]>;
     getActive: (ctx: Context) => Promise<SpecialOffer[]>;
     create: (ctx: Context, data: Create$1) => Promise<SpecialOffer>;
@@ -3472,7 +3472,7 @@ interface IAPI$3 {
     getMyOffer: (ctx: Context) => Promise<UserOfferDetails | null>;
     claim: (ctx: Context, callbackUrl?: string) => Promise<string>;
 }
-declare const Endpoints$3: {
+declare const Endpoints$4: {
     List: {
         uri: string;
         method: string;
@@ -3507,13 +3507,13 @@ declare const Endpoints$3: {
     };
 };
 
-declare const index$5_CreateSpecialOfferSchema: typeof CreateSpecialOfferSchema;
-declare const index$5_SpecialOfferSchema: typeof SpecialOfferSchema;
-declare const index$5_UpdateSpecialOfferSchema: typeof UpdateSpecialOfferSchema;
-type index$5_UserOfferDetails = UserOfferDetails;
-declare const index$5_UserOfferDetailsSchema: typeof UserOfferDetailsSchema;
-declare namespace index$5 {
-  export { type Create$1 as Create, index$5_CreateSpecialOfferSchema as CreateSpecialOfferSchema, Endpoints$3 as Endpoints, type SpecialOffer as Entity, type IAPI$3 as IAPI, index$5_SpecialOfferSchema as SpecialOfferSchema, type Update$1 as Update, index$5_UpdateSpecialOfferSchema as UpdateSpecialOfferSchema, type index$5_UserOfferDetails as UserOfferDetails, index$5_UserOfferDetailsSchema as UserOfferDetailsSchema };
+declare const index$6_CreateSpecialOfferSchema: typeof CreateSpecialOfferSchema;
+declare const index$6_SpecialOfferSchema: typeof SpecialOfferSchema;
+declare const index$6_UpdateSpecialOfferSchema: typeof UpdateSpecialOfferSchema;
+type index$6_UserOfferDetails = UserOfferDetails;
+declare const index$6_UserOfferDetailsSchema: typeof UserOfferDetailsSchema;
+declare namespace index$6 {
+  export { type Create$1 as Create, index$6_CreateSpecialOfferSchema as CreateSpecialOfferSchema, Endpoints$4 as Endpoints, type SpecialOffer as Entity, type IAPI$4 as IAPI, index$6_SpecialOfferSchema as SpecialOfferSchema, type Update$1 as Update, index$6_UpdateSpecialOfferSchema as UpdateSpecialOfferSchema, type index$6_UserOfferDetails as UserOfferDetails, index$6_UserOfferDetailsSchema as UserOfferDetailsSchema };
 }
 
 /**
@@ -4297,7 +4297,7 @@ type Update = z.infer<typeof UpdateShredUSessionSchema>;
 type SetRecording = z.infer<typeof SetShredUSessionRecordingSchema>;
 type PreviewEmail = z.infer<typeof PreviewShredUEmailSchema>;
 
-interface IAPI$2 {
+interface IAPI$3 {
     list: (ctx: Context) => Promise<ShredUSession[]>;
     getUpcoming: (ctx: Context) => Promise<ShredUSessionCustomer[]>;
     getLibrary: (ctx: Context) => Promise<ShredUSessionCustomer[]>;
@@ -4311,7 +4311,7 @@ interface IAPI$2 {
     /** The lead times the dispatch job runs on. Static: fetch once, not per keystroke. */
     getDispatchRules: (ctx: Context) => Promise<ShredUDispatchRules>;
 }
-declare const Endpoints$2: {
+declare const Endpoints$3: {
     List: {
         uri: string;
         method: string;
@@ -4358,34 +4358,34 @@ declare const Endpoints$2: {
     };
 };
 
-type index$4_Brief = Brief;
-type index$4_Create = Create;
-declare const index$4_CreateShredUBriefSchema: typeof CreateShredUBriefSchema;
-declare const index$4_CreateShredUSessionSchema: typeof CreateShredUSessionSchema;
-type index$4_Join = Join;
-type index$4_PreviewEmail = PreviewEmail;
-declare const index$4_PreviewShredUEmailSchema: typeof PreviewShredUEmailSchema;
-type index$4_SessionAsset = SessionAsset;
-declare const index$4_SessionAssetSchema: typeof SessionAssetSchema;
-type index$4_SetRecording = SetRecording;
-declare const index$4_SetShredUSessionRecordingSchema: typeof SetShredUSessionRecordingSchema;
-declare const index$4_ShredUBriefSchema: typeof ShredUBriefSchema;
-type index$4_ShredUDispatchRules = ShredUDispatchRules;
-declare const index$4_ShredUDispatchRulesSchema: typeof ShredUDispatchRulesSchema;
-declare const index$4_ShredUJoinSchema: typeof ShredUJoinSchema;
-type index$4_ShredUReminderBounds = ShredUReminderBounds;
-declare const index$4_ShredUReminderBoundsSchema: typeof ShredUReminderBoundsSchema;
-type index$4_ShredUSessionCustomer = ShredUSessionCustomer;
-declare const index$4_ShredUSessionCustomerSchema: typeof ShredUSessionCustomerSchema;
-declare const index$4_ShredUSessionSchema: typeof ShredUSessionSchema;
-type index$4_ShredUSessionStatus = ShredUSessionStatus;
-declare const index$4_ShredUSessionStatusSchema: typeof ShredUSessionStatusSchema;
-type index$4_ShredUStageRule = ShredUStageRule;
-declare const index$4_ShredUStageRuleSchema: typeof ShredUStageRuleSchema;
-type index$4_Update = Update;
-declare const index$4_UpdateShredUSessionSchema: typeof UpdateShredUSessionSchema;
-declare namespace index$4 {
-  export { type index$4_Brief as Brief, type index$4_Create as Create, index$4_CreateShredUBriefSchema as CreateShredUBriefSchema, index$4_CreateShredUSessionSchema as CreateShredUSessionSchema, Endpoints$2 as Endpoints, type ShredUSession as Entity, type IAPI$2 as IAPI, type index$4_Join as Join, type index$4_PreviewEmail as PreviewEmail, index$4_PreviewShredUEmailSchema as PreviewShredUEmailSchema, type index$4_SessionAsset as SessionAsset, index$4_SessionAssetSchema as SessionAssetSchema, type index$4_SetRecording as SetRecording, index$4_SetShredUSessionRecordingSchema as SetShredUSessionRecordingSchema, index$4_ShredUBriefSchema as ShredUBriefSchema, type index$4_ShredUDispatchRules as ShredUDispatchRules, index$4_ShredUDispatchRulesSchema as ShredUDispatchRulesSchema, index$4_ShredUJoinSchema as ShredUJoinSchema, type index$4_ShredUReminderBounds as ShredUReminderBounds, index$4_ShredUReminderBoundsSchema as ShredUReminderBoundsSchema, type index$4_ShredUSessionCustomer as ShredUSessionCustomer, index$4_ShredUSessionCustomerSchema as ShredUSessionCustomerSchema, index$4_ShredUSessionSchema as ShredUSessionSchema, type index$4_ShredUSessionStatus as ShredUSessionStatus, index$4_ShredUSessionStatusSchema as ShredUSessionStatusSchema, type index$4_ShredUStageRule as ShredUStageRule, index$4_ShredUStageRuleSchema as ShredUStageRuleSchema, type index$4_Update as Update, index$4_UpdateShredUSessionSchema as UpdateShredUSessionSchema };
+type index$5_Brief = Brief;
+type index$5_Create = Create;
+declare const index$5_CreateShredUBriefSchema: typeof CreateShredUBriefSchema;
+declare const index$5_CreateShredUSessionSchema: typeof CreateShredUSessionSchema;
+type index$5_Join = Join;
+type index$5_PreviewEmail = PreviewEmail;
+declare const index$5_PreviewShredUEmailSchema: typeof PreviewShredUEmailSchema;
+type index$5_SessionAsset = SessionAsset;
+declare const index$5_SessionAssetSchema: typeof SessionAssetSchema;
+type index$5_SetRecording = SetRecording;
+declare const index$5_SetShredUSessionRecordingSchema: typeof SetShredUSessionRecordingSchema;
+declare const index$5_ShredUBriefSchema: typeof ShredUBriefSchema;
+type index$5_ShredUDispatchRules = ShredUDispatchRules;
+declare const index$5_ShredUDispatchRulesSchema: typeof ShredUDispatchRulesSchema;
+declare const index$5_ShredUJoinSchema: typeof ShredUJoinSchema;
+type index$5_ShredUReminderBounds = ShredUReminderBounds;
+declare const index$5_ShredUReminderBoundsSchema: typeof ShredUReminderBoundsSchema;
+type index$5_ShredUSessionCustomer = ShredUSessionCustomer;
+declare const index$5_ShredUSessionCustomerSchema: typeof ShredUSessionCustomerSchema;
+declare const index$5_ShredUSessionSchema: typeof ShredUSessionSchema;
+type index$5_ShredUSessionStatus = ShredUSessionStatus;
+declare const index$5_ShredUSessionStatusSchema: typeof ShredUSessionStatusSchema;
+type index$5_ShredUStageRule = ShredUStageRule;
+declare const index$5_ShredUStageRuleSchema: typeof ShredUStageRuleSchema;
+type index$5_Update = Update;
+declare const index$5_UpdateShredUSessionSchema: typeof UpdateShredUSessionSchema;
+declare namespace index$5 {
+  export { type index$5_Brief as Brief, type index$5_Create as Create, index$5_CreateShredUBriefSchema as CreateShredUBriefSchema, index$5_CreateShredUSessionSchema as CreateShredUSessionSchema, Endpoints$3 as Endpoints, type ShredUSession as Entity, type IAPI$3 as IAPI, type index$5_Join as Join, type index$5_PreviewEmail as PreviewEmail, index$5_PreviewShredUEmailSchema as PreviewShredUEmailSchema, type index$5_SessionAsset as SessionAsset, index$5_SessionAssetSchema as SessionAssetSchema, type index$5_SetRecording as SetRecording, index$5_SetShredUSessionRecordingSchema as SetShredUSessionRecordingSchema, index$5_ShredUBriefSchema as ShredUBriefSchema, type index$5_ShredUDispatchRules as ShredUDispatchRules, index$5_ShredUDispatchRulesSchema as ShredUDispatchRulesSchema, index$5_ShredUJoinSchema as ShredUJoinSchema, type index$5_ShredUReminderBounds as ShredUReminderBounds, index$5_ShredUReminderBoundsSchema as ShredUReminderBoundsSchema, type index$5_ShredUSessionCustomer as ShredUSessionCustomer, index$5_ShredUSessionCustomerSchema as ShredUSessionCustomerSchema, index$5_ShredUSessionSchema as ShredUSessionSchema, type index$5_ShredUSessionStatus as ShredUSessionStatus, index$5_ShredUSessionStatusSchema as ShredUSessionStatusSchema, type index$5_ShredUStageRule as ShredUStageRule, index$5_ShredUStageRuleSchema as ShredUStageRuleSchema, type index$5_Update as Update, index$5_UpdateShredUSessionSchema as UpdateShredUSessionSchema };
 }
 
 /** The metrics served today. The list grows, so it never gates parsing — see ScoreMetricSchema. */
@@ -5531,7 +5531,7 @@ type ScoreProgress = z.infer<typeof ScoreProgressSchema>;
 type ScoreGoalOption = z.infer<typeof ScoreGoalOptionSchema>;
 type ScoreGoal = z.infer<typeof ScoreGoalSchema>;
 
-interface IAPI$1 {
+interface IAPI$2 {
     /**
      * The recap of a closed month, with the last months for the chart.
      * Omit `period` for the month that just closed; it is formatted `YYYY-MM`
@@ -5547,7 +5547,7 @@ interface IAPI$1 {
      */
     setGoal: (context: Context, target: number) => Promise<ScoreGoal>;
 }
-declare const Endpoints$1: {
+declare const Endpoints$2: {
     GetRecap: {
         uri: string;
         method: string;
@@ -5566,31 +5566,330 @@ declare const Endpoints$1: {
     };
 };
 
-type index$3_Score = Score;
-type index$3_ScoreBand = ScoreBand;
-declare const index$3_ScoreBandSchema: typeof ScoreBandSchema;
-type index$3_ScoreGoal = ScoreGoal;
-type index$3_ScoreGoalOption = ScoreGoalOption;
-declare const index$3_ScoreGoalOptionSchema: typeof ScoreGoalOptionSchema;
-declare const index$3_ScoreGoalSchema: typeof ScoreGoalSchema;
-type index$3_ScoreHistoryEntry = ScoreHistoryEntry;
-declare const index$3_ScoreHistoryEntrySchema: typeof ScoreHistoryEntrySchema;
-type index$3_ScoreMetric = ScoreMetric;
-type index$3_ScoreMetricKey = ScoreMetricKey;
-declare const index$3_ScoreMetricKeySchema: typeof ScoreMetricKeySchema;
-declare const index$3_ScoreMetricSchema: typeof ScoreMetricSchema;
-type index$3_ScoreMostShared = ScoreMostShared;
-declare const index$3_ScoreMostSharedSchema: typeof ScoreMostSharedSchema;
-type index$3_ScoreProgress = ScoreProgress;
-type index$3_ScoreProgressMetric = ScoreProgressMetric;
-declare const index$3_ScoreProgressMetricSchema: typeof ScoreProgressMetricSchema;
-declare const index$3_ScoreProgressSchema: typeof ScoreProgressSchema;
-type index$3_ScoreProjection = ScoreProjection;
-declare const index$3_ScoreProjectionSchema: typeof ScoreProjectionSchema;
-declare const index$3_ScoreRecapSchema: typeof ScoreRecapSchema;
-declare const index$3_ScoreSchema: typeof ScoreSchema;
+type index$4_Score = Score;
+type index$4_ScoreBand = ScoreBand;
+declare const index$4_ScoreBandSchema: typeof ScoreBandSchema;
+type index$4_ScoreGoal = ScoreGoal;
+type index$4_ScoreGoalOption = ScoreGoalOption;
+declare const index$4_ScoreGoalOptionSchema: typeof ScoreGoalOptionSchema;
+declare const index$4_ScoreGoalSchema: typeof ScoreGoalSchema;
+type index$4_ScoreHistoryEntry = ScoreHistoryEntry;
+declare const index$4_ScoreHistoryEntrySchema: typeof ScoreHistoryEntrySchema;
+type index$4_ScoreMetric = ScoreMetric;
+type index$4_ScoreMetricKey = ScoreMetricKey;
+declare const index$4_ScoreMetricKeySchema: typeof ScoreMetricKeySchema;
+declare const index$4_ScoreMetricSchema: typeof ScoreMetricSchema;
+type index$4_ScoreMostShared = ScoreMostShared;
+declare const index$4_ScoreMostSharedSchema: typeof ScoreMostSharedSchema;
+type index$4_ScoreProgress = ScoreProgress;
+type index$4_ScoreProgressMetric = ScoreProgressMetric;
+declare const index$4_ScoreProgressMetricSchema: typeof ScoreProgressMetricSchema;
+declare const index$4_ScoreProgressSchema: typeof ScoreProgressSchema;
+type index$4_ScoreProjection = ScoreProjection;
+declare const index$4_ScoreProjectionSchema: typeof ScoreProjectionSchema;
+declare const index$4_ScoreRecapSchema: typeof ScoreRecapSchema;
+declare const index$4_ScoreSchema: typeof ScoreSchema;
+declare namespace index$4 {
+  export { Endpoints$2 as Endpoints, type ScoreRecap as Entity, type IAPI$2 as IAPI, type index$4_Score as Score, type index$4_ScoreBand as ScoreBand, index$4_ScoreBandSchema as ScoreBandSchema, type index$4_ScoreGoal as ScoreGoal, type index$4_ScoreGoalOption as ScoreGoalOption, index$4_ScoreGoalOptionSchema as ScoreGoalOptionSchema, index$4_ScoreGoalSchema as ScoreGoalSchema, type index$4_ScoreHistoryEntry as ScoreHistoryEntry, index$4_ScoreHistoryEntrySchema as ScoreHistoryEntrySchema, type index$4_ScoreMetric as ScoreMetric, type index$4_ScoreMetricKey as ScoreMetricKey, index$4_ScoreMetricKeySchema as ScoreMetricKeySchema, index$4_ScoreMetricSchema as ScoreMetricSchema, type index$4_ScoreMostShared as ScoreMostShared, index$4_ScoreMostSharedSchema as ScoreMostSharedSchema, type index$4_ScoreProgress as ScoreProgress, type index$4_ScoreProgressMetric as ScoreProgressMetric, index$4_ScoreProgressMetricSchema as ScoreProgressMetricSchema, index$4_ScoreProgressSchema as ScoreProgressSchema, type index$4_ScoreProjection as ScoreProjection, index$4_ScoreProjectionSchema as ScoreProjectionSchema, index$4_ScoreRecapSchema as ScoreRecapSchema, index$4_ScoreSchema as ScoreSchema };
+}
+
+/** A board exists while the KPI catalog has an active KPI for it; the list is not fixed. */
+declare const KpiBoardSchema: z.ZodObject<{
+    id: z.ZodString;
+    kpiCount: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    kpiCount: number;
+}, {
+    id: string;
+    kpiCount: number;
+}>;
+/**
+ * One KPI in one month. The enumerable fields stay strings on purpose: the catalog is a
+ * spreadsheet, so a value added there must not break a client that predates it.
+ */
+declare const KpiEntrySchema: z.ZodObject<{
+    kpiId: z.ZodString;
+    kpiName: z.ZodString;
+    category: z.ZodString;
+    /** `num`, `pct` (percentage points: 5.5 means 5.5%), `dec`, `score`, `stars` or `usd`. */
+    unit: z.ZodString;
+    /** `up` or `down`. */
+    better: z.ZodString;
+    /** `stock` (level at the end of the month), `flow` (volume in the month) or `rate`. */
+    kpiType: z.ZodString;
+    sortOrder: z.ZodNullable<z.ZodNumber>;
+    /** YYYY-MM-DD, always the first day of the month. */
+    periodStart: z.ZodString;
+    actualValue: z.ZodNullable<z.ZodNumber>;
+    targetValue: z.ZodNullable<z.ZodNumber>;
+    /** `typed` or `derived` (from the plan assumptions). */
+    targetSource: z.ZodNullable<z.ZodString>;
+    /** Only alongside a typed target. */
+    baseline: z.ZodNullable<z.ZodNumber>;
+    /** True for the month still being lived. */
+    isPartial: z.ZodBoolean;
+    /** `no_data`, `no_target`, `in_progress`, `met` or `missed`. */
+    status: z.ZodString;
+    /** Against the previous month's value. */
+    delta: z.ZodNullable<z.ZodNumber>;
+    /** Direction-aware: at or above 1 means the target was met, whichever way `better` points. */
+    attainment: z.ZodNullable<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    status: string;
+    category: string;
+    kpiId: string;
+    kpiName: string;
+    unit: string;
+    better: string;
+    kpiType: string;
+    sortOrder: number | null;
+    periodStart: string;
+    actualValue: number | null;
+    targetValue: number | null;
+    targetSource: string | null;
+    baseline: number | null;
+    isPartial: boolean;
+    delta: number | null;
+    attainment: number | null;
+}, {
+    status: string;
+    category: string;
+    kpiId: string;
+    kpiName: string;
+    unit: string;
+    better: string;
+    kpiType: string;
+    sortOrder: number | null;
+    periodStart: string;
+    actualValue: number | null;
+    targetValue: number | null;
+    targetSource: string | null;
+    baseline: number | null;
+    isPartial: boolean;
+    delta: number | null;
+    attainment: number | null;
+}>;
+declare const KpiMonthSummarySchema: z.ZodObject<{
+    periodStart: z.ZodString;
+    met: z.ZodNumber;
+    missed: z.ZodNumber;
+    judged: z.ZodNumber;
+    inProgress: z.ZodNumber;
+    noTarget: z.ZodNumber;
+    noData: z.ZodNumber;
+    /** Null when no KPI was judged in the month. */
+    scoreOutOf10: z.ZodNullable<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    periodStart: string;
+    met: number;
+    missed: number;
+    judged: number;
+    inProgress: number;
+    noTarget: number;
+    noData: number;
+    scoreOutOf10: number | null;
+}, {
+    periodStart: string;
+    met: number;
+    missed: number;
+    judged: number;
+    inProgress: number;
+    noTarget: number;
+    noData: number;
+    scoreOutOf10: number | null;
+}>;
+/** Every month of a board: one scorecard per month, flattened into entries plus the monthly summaries. */
+declare const KpiBoardHistorySchema: z.ZodObject<{
+    board: z.ZodString;
+    /** ISO timestamp of the last automatic calculation. */
+    calculatedAt: z.ZodNullable<z.ZodString>;
+    entries: z.ZodArray<z.ZodObject<{
+        kpiId: z.ZodString;
+        kpiName: z.ZodString;
+        category: z.ZodString;
+        /** `num`, `pct` (percentage points: 5.5 means 5.5%), `dec`, `score`, `stars` or `usd`. */
+        unit: z.ZodString;
+        /** `up` or `down`. */
+        better: z.ZodString;
+        /** `stock` (level at the end of the month), `flow` (volume in the month) or `rate`. */
+        kpiType: z.ZodString;
+        sortOrder: z.ZodNullable<z.ZodNumber>;
+        /** YYYY-MM-DD, always the first day of the month. */
+        periodStart: z.ZodString;
+        actualValue: z.ZodNullable<z.ZodNumber>;
+        targetValue: z.ZodNullable<z.ZodNumber>;
+        /** `typed` or `derived` (from the plan assumptions). */
+        targetSource: z.ZodNullable<z.ZodString>;
+        /** Only alongside a typed target. */
+        baseline: z.ZodNullable<z.ZodNumber>;
+        /** True for the month still being lived. */
+        isPartial: z.ZodBoolean;
+        /** `no_data`, `no_target`, `in_progress`, `met` or `missed`. */
+        status: z.ZodString;
+        /** Against the previous month's value. */
+        delta: z.ZodNullable<z.ZodNumber>;
+        /** Direction-aware: at or above 1 means the target was met, whichever way `better` points. */
+        attainment: z.ZodNullable<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        status: string;
+        category: string;
+        kpiId: string;
+        kpiName: string;
+        unit: string;
+        better: string;
+        kpiType: string;
+        sortOrder: number | null;
+        periodStart: string;
+        actualValue: number | null;
+        targetValue: number | null;
+        targetSource: string | null;
+        baseline: number | null;
+        isPartial: boolean;
+        delta: number | null;
+        attainment: number | null;
+    }, {
+        status: string;
+        category: string;
+        kpiId: string;
+        kpiName: string;
+        unit: string;
+        better: string;
+        kpiType: string;
+        sortOrder: number | null;
+        periodStart: string;
+        actualValue: number | null;
+        targetValue: number | null;
+        targetSource: string | null;
+        baseline: number | null;
+        isPartial: boolean;
+        delta: number | null;
+        attainment: number | null;
+    }>, "many">;
+    summaries: z.ZodArray<z.ZodObject<{
+        periodStart: z.ZodString;
+        met: z.ZodNumber;
+        missed: z.ZodNumber;
+        judged: z.ZodNumber;
+        inProgress: z.ZodNumber;
+        noTarget: z.ZodNumber;
+        noData: z.ZodNumber;
+        /** Null when no KPI was judged in the month. */
+        scoreOutOf10: z.ZodNullable<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        periodStart: string;
+        met: number;
+        missed: number;
+        judged: number;
+        inProgress: number;
+        noTarget: number;
+        noData: number;
+        scoreOutOf10: number | null;
+    }, {
+        periodStart: string;
+        met: number;
+        missed: number;
+        judged: number;
+        inProgress: number;
+        noTarget: number;
+        noData: number;
+        scoreOutOf10: number | null;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    entries: {
+        status: string;
+        category: string;
+        kpiId: string;
+        kpiName: string;
+        unit: string;
+        better: string;
+        kpiType: string;
+        sortOrder: number | null;
+        periodStart: string;
+        actualValue: number | null;
+        targetValue: number | null;
+        targetSource: string | null;
+        baseline: number | null;
+        isPartial: boolean;
+        delta: number | null;
+        attainment: number | null;
+    }[];
+    board: string;
+    calculatedAt: string | null;
+    summaries: {
+        periodStart: string;
+        met: number;
+        missed: number;
+        judged: number;
+        inProgress: number;
+        noTarget: number;
+        noData: number;
+        scoreOutOf10: number | null;
+    }[];
+}, {
+    entries: {
+        status: string;
+        category: string;
+        kpiId: string;
+        kpiName: string;
+        unit: string;
+        better: string;
+        kpiType: string;
+        sortOrder: number | null;
+        periodStart: string;
+        actualValue: number | null;
+        targetValue: number | null;
+        targetSource: string | null;
+        baseline: number | null;
+        isPartial: boolean;
+        delta: number | null;
+        attainment: number | null;
+    }[];
+    board: string;
+    calculatedAt: string | null;
+    summaries: {
+        periodStart: string;
+        met: number;
+        missed: number;
+        judged: number;
+        inProgress: number;
+        noTarget: number;
+        noData: number;
+        scoreOutOf10: number | null;
+    }[];
+}>;
+type KpiBoard = z.infer<typeof KpiBoardSchema>;
+type KpiEntry = z.infer<typeof KpiEntrySchema>;
+type KpiMonthSummary = z.infer<typeof KpiMonthSummarySchema>;
+type KpiBoardHistory = z.infer<typeof KpiBoardHistorySchema>;
+
+interface IAPI$1 {
+    /** The boards with at least one active KPI, in catalog order. */
+    listBoards: (context: Context) => Promise<KpiBoard[]>;
+    /** Every month of the board. A board missing from the catalog answers 404. */
+    getBoard: (context: Context, board: string) => Promise<KpiBoardHistory>;
+}
+declare const Endpoints$1: {
+    ListBoards: {
+        uri: string;
+        method: string;
+    };
+    GetBoard: {
+        uri: string;
+        method: string;
+    };
+};
+
+type index$3_KpiBoard = KpiBoard;
+type index$3_KpiBoardHistory = KpiBoardHistory;
+declare const index$3_KpiBoardHistorySchema: typeof KpiBoardHistorySchema;
+declare const index$3_KpiBoardSchema: typeof KpiBoardSchema;
+type index$3_KpiEntry = KpiEntry;
+declare const index$3_KpiEntrySchema: typeof KpiEntrySchema;
+type index$3_KpiMonthSummary = KpiMonthSummary;
+declare const index$3_KpiMonthSummarySchema: typeof KpiMonthSummarySchema;
 declare namespace index$3 {
-  export { Endpoints$1 as Endpoints, type ScoreRecap as Entity, type IAPI$1 as IAPI, type index$3_Score as Score, type index$3_ScoreBand as ScoreBand, index$3_ScoreBandSchema as ScoreBandSchema, type index$3_ScoreGoal as ScoreGoal, type index$3_ScoreGoalOption as ScoreGoalOption, index$3_ScoreGoalOptionSchema as ScoreGoalOptionSchema, index$3_ScoreGoalSchema as ScoreGoalSchema, type index$3_ScoreHistoryEntry as ScoreHistoryEntry, index$3_ScoreHistoryEntrySchema as ScoreHistoryEntrySchema, type index$3_ScoreMetric as ScoreMetric, type index$3_ScoreMetricKey as ScoreMetricKey, index$3_ScoreMetricKeySchema as ScoreMetricKeySchema, index$3_ScoreMetricSchema as ScoreMetricSchema, type index$3_ScoreMostShared as ScoreMostShared, index$3_ScoreMostSharedSchema as ScoreMostSharedSchema, type index$3_ScoreProgress as ScoreProgress, type index$3_ScoreProgressMetric as ScoreProgressMetric, index$3_ScoreProgressMetricSchema as ScoreProgressMetricSchema, index$3_ScoreProgressSchema as ScoreProgressSchema, type index$3_ScoreProjection as ScoreProjection, index$3_ScoreProjectionSchema as ScoreProjectionSchema, index$3_ScoreRecapSchema as ScoreRecapSchema, index$3_ScoreSchema as ScoreSchema };
+  export { Endpoints$1 as Endpoints, type KpiBoardHistory as Entity, type IAPI$1 as IAPI, type index$3_KpiBoard as KpiBoard, type index$3_KpiBoardHistory as KpiBoardHistory, index$3_KpiBoardHistorySchema as KpiBoardHistorySchema, index$3_KpiBoardSchema as KpiBoardSchema, type index$3_KpiEntry as KpiEntry, index$3_KpiEntrySchema as KpiEntrySchema, type index$3_KpiMonthSummary as KpiMonthSummary, index$3_KpiMonthSummarySchema as KpiMonthSummarySchema };
 }
 
 /**
@@ -5957,21 +6256,22 @@ declare namespace index$2 {
 }
 
 declare class ShredAPI {
-    user: IAPI$d;
-    goal: IAPI$8;
-    editor: IAPI$7;
-    subscription: IAPI$e;
-    prompt: IAPI$f;
-    pushNotification: IAPI$6;
-    email: IAPI$a;
-    tenant: IAPI$c;
-    app: IAPI$5;
-    project: IAPI$9;
-    track: IAPI$b;
-    note: IAPI$4;
-    specialOffer: IAPI$3;
-    shredu: IAPI$2;
-    score: IAPI$1;
+    user: IAPI$e;
+    goal: IAPI$9;
+    editor: IAPI$8;
+    subscription: IAPI$f;
+    prompt: IAPI$g;
+    pushNotification: IAPI$7;
+    email: IAPI$b;
+    tenant: IAPI$d;
+    app: IAPI$6;
+    project: IAPI$a;
+    track: IAPI$c;
+    note: IAPI$5;
+    specialOffer: IAPI$4;
+    shredu: IAPI$3;
+    score: IAPI$2;
+    kpi: IAPI$1;
     rbac: IAPI;
     constructor(env: Environment);
 }
@@ -6064,4 +6364,4 @@ declare namespace index {
   export { index_AssetSchema as AssetSchema, type Asset as Entity };
 }
 
-export { index as Asset, index$f as Core, index$8 as Editor, index$b as Email, index$1 as Exceptions, index$9 as Goal, index$6 as Note, index$7 as Notification, index$a as Project, index$h as Prompt, index$2 as RBAC, index$3 as Score, ShredAPI, index$4 as ShredU, index$5 as SpecialOffer, index$g as Subscription, index$d as Tenant, index$c as Track, index$e as User, ShredAPI as default };
+export { index as Asset, index$g as Core, index$9 as Editor, index$c as Email, index$1 as Exceptions, index$a as Goal, index$3 as Kpi, index$7 as Note, index$8 as Notification, index$b as Project, index$i as Prompt, index$2 as RBAC, index$4 as Score, ShredAPI, index$5 as ShredU, index$6 as SpecialOffer, index$h as Subscription, index$e as Tenant, index$d as Track, index$f as User, ShredAPI as default };