shred-api-client 2.10.6 → 2.11.1

package/dist/index.d.ts

@@ -197,7 +197,7 @@ type Context = {
     requestId?: string;
 };
 
-interface IAPI$e {
+interface IAPI$f {
     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$e {
     generateScript: (c: Context, data: ScriptIARequest) => Promise<string>;
     updateScript: (c: Context, id: string, script: Partial<Script>) => Promise<boolean>;
 }
-declare const Endpoints$d: {
+declare const Endpoints$e: {
     GetPrompt: {
         uri: string;
         method: string;
@@ -232,15 +232,15 @@ declare const Endpoints$d: {
     };
 };
 
-type index$g_Category = Category;
-declare const index$g_CategorySchema: typeof CategorySchema;
-declare const index$g_PromptSchema: typeof PromptSchema;
-type index$g_Script = Script;
-type index$g_ScriptIARequest = ScriptIARequest;
-declare const index$g_ScriptIARequestSchema: typeof ScriptIARequestSchema;
-declare const index$g_ScriptSchema: typeof ScriptSchema;
-declare namespace index$g {
-  export { type index$g_Category as Category, index$g_CategorySchema as CategorySchema, Endpoints$d as Endpoints, type Prompt as Entity, type IAPI$e as IAPI, index$g_PromptSchema as PromptSchema, type index$g_Script as Script, type index$g_ScriptIARequest as ScriptIARequest, index$g_ScriptIARequestSchema as ScriptIARequestSchema, index$g_ScriptSchema as ScriptSchema };
+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 };
 }
 
 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$d {
+interface IAPI$e {
     getCharges: (ctx: Context) => Promise<Charge[]>;
     getPortalUrl: (ctx: Context) => Promise<string>;
     getSubscription: (context: Context, userId?: string) => Promise<Subscription | null>;
@@ -609,7 +609,7 @@ interface IAPI$d {
     getSubscriptionsSummary: (ctx: Context) => Promise<SubscriptionSummary[]>;
     listPromoCodes: (ctx: Context) => Promise<PromoCode[]>;
 }
-declare const Endpoints$c: {
+declare const Endpoints$d: {
     GetPortal: {
         uri: string;
         method: string;
@@ -668,19 +668,19 @@ declare const Endpoints$c: {
     };
 };
 
-type index$f_Charge = Charge;
-declare const index$f_ChargeSchema: typeof ChargeSchema;
-type index$f_Plan = Plan;
-declare const index$f_PlanSchema: typeof PlanSchema;
-type index$f_Product = Product;
-declare const index$f_ProductSchema: typeof ProductSchema;
-type index$f_PromoCode = PromoCode;
-declare const index$f_SubscriptionSchema: typeof SubscriptionSchema;
-declare const index$f_SubscriptionTypeSchema: typeof SubscriptionTypeSchema;
-type index$f_Type = Type;
-declare const index$f_Type: typeof Type;
-declare namespace index$f {
-  export { type index$f_Charge as Charge, index$f_ChargeSchema as ChargeSchema, Endpoints$c as Endpoints, type Subscription as Entity, type IAPI$d as IAPI, type index$f_Plan as Plan, index$f_PlanSchema as PlanSchema, type index$f_Product as Product, index$f_ProductSchema as ProductSchema, type index$f_PromoCode as PromoCode, index$f_SubscriptionSchema as SubscriptionSchema, index$f_SubscriptionTypeSchema as SubscriptionTypeSchema, type SubscriptionSummary as Summary, index$f_Type as Type };
+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 };
 }
 
 declare enum Role$1 {
@@ -873,16 +873,16 @@ type APIResponse<T> = {
     perPage?: number;
 };
 
-type index$e_APIResponse<T> = APIResponse<T>;
-type index$e_QueryFilterOp = QueryFilterOp;
-type index$e_QueryOptions<T> = QueryOptions<T>;
-type index$e_QueryOrderBy<T> = QueryOrderBy<T>;
-type index$e_QueryWhere<T> = QueryWhere<T>;
-declare namespace index$e {
-  export type { index$e_APIResponse as APIResponse, index$e_QueryFilterOp as QueryFilterOp, index$e_QueryOptions as QueryOptions, index$e_QueryOrderBy as QueryOrderBy, index$e_QueryWhere as QueryWhere };
+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 };
 }
 
-interface IAPI$c {
+interface IAPI$d {
     getUserInfo: (context: Context) => Promise<User>;
     isEmailAvaliable: (email: string) => Promise<boolean>;
     sendValidationCode: (email: string) => Promise<boolean>;
@@ -899,7 +899,7 @@ interface IAPI$c {
     search: (ctx: Context, query: QueryOptions<User>) => Promise<APIResponse<User>>;
     createUser: (data: Create$2) => Promise<User>;
 }
-declare const Endpoints$b: {
+declare const Endpoints$c: {
     ChangeEmail: {
         uri: string;
         method: string;
@@ -966,11 +966,11 @@ declare const Endpoints$b: {
     };
 };
 
-type index$d_System = System;
-declare const index$d_System: typeof System;
-declare const index$d_UserSchema: typeof UserSchema;
-declare namespace index$d {
-  export { type Create$2 as Create, Endpoints$b as Endpoints, type User as Entity, type IAPI$c as IAPI, type Preferences$1 as Preferences, PreferencesSchema$1 as PreferencesSchema, Role$1 as Role, index$d_System as System, type Update$2 as Update, index$d_UserSchema as UserSchema };
+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 };
 }
 
 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$b {
+interface IAPI$c {
     getByInviteCode: (code: string, context?: Context) => Promise<Tenant | null>;
     create: (tenant: Tenant, context: Context) => Promise<boolean>;
     list: (context: Context) => Promise<Tenant[]>;
@@ -1719,7 +1719,7 @@ interface IAPI$b {
     update: (tenantId: string, data: TenantUpdate, context: Context) => Promise<boolean>;
     updateMembers: (tenantId: string, memberUpdate: MemberUpdate, context: Context) => Promise<boolean>;
 }
-declare const Endpoints$a: {
+declare const Endpoints$b: {
     GetByInviteCode: {
         uri: string;
         method: string;
@@ -1754,17 +1754,17 @@ declare const Endpoints$a: {
     };
 };
 
-type index$c_Member = Member;
-declare const index$c_MemberSchema: typeof MemberSchema;
-type index$c_MemberUpdate = MemberUpdate;
-declare const index$c_MemberUpdateSchema: typeof MemberUpdateSchema;
-type index$c_Preferences = Preferences;
-declare const index$c_PreferencesSchema: typeof PreferencesSchema;
-declare const index$c_TenantSchema: typeof TenantSchema;
-type index$c_TenantUpdate = TenantUpdate;
-declare const index$c_TenantUpdateSchema: typeof TenantUpdateSchema;
-declare namespace index$c {
-  export { Action$1 as Action, Endpoints$a as Endpoints, type Tenant as Entity, type IAPI$b as IAPI, type index$c_Member as Member, index$c_MemberSchema as MemberSchema, type index$c_MemberUpdate as MemberUpdate, index$c_MemberUpdateSchema as MemberUpdateSchema, type index$c_Preferences as Preferences, index$c_PreferencesSchema as PreferencesSchema, index$c_TenantSchema as TenantSchema, type index$c_TenantUpdate as TenantUpdate, index$c_TenantUpdateSchema as TenantUpdateSchema };
+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_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 };
 }
 
 declare const TrackParamSchema: z.ZodObject<{
@@ -1811,21 +1811,21 @@ declare const TrackSchema: z.ZodObject<{
 type Track = z.infer<typeof TrackSchema>;
 type TrackParam = z.infer<typeof TrackParamSchema>;
 
-interface IAPI$a {
+interface IAPI$b {
     send: (t: Track) => Promise<boolean>;
 }
-declare const Endpoints$9: {
+declare const Endpoints$a: {
     Track: {
         uri: string;
         method: string;
     };
 };
 
-type index$b_TrackParam = TrackParam;
-declare const index$b_TrackParamSchema: typeof TrackParamSchema;
-declare const index$b_TrackSchema: typeof TrackSchema;
-declare namespace index$b {
-  export { Endpoints$9 as Endpoints, type Track as Entity, type IAPI$a as IAPI, type index$b_TrackParam as TrackParam, index$b_TrackParamSchema as TrackParamSchema, index$b_TrackSchema as TrackSchema };
+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 };
 }
 
 declare const EmailSchema: z.ZodObject<{
@@ -1843,19 +1843,19 @@ declare const EmailSchema: z.ZodObject<{
 }>;
 type Email = z.infer<typeof EmailSchema>;
 
-interface IAPI$9 {
+interface IAPI$a {
     send: (email: Email, ctx?: Context) => Promise<boolean>;
 }
-declare const Endpoints$8: {
+declare const Endpoints$9: {
     SendEmail: {
         uri: string;
         method: string;
     };
 };
 
-declare const index$a_EmailSchema: typeof EmailSchema;
-declare namespace index$a {
-  export { index$a_EmailSchema as EmailSchema, Endpoints$8 as Endpoints, type Email as Entity, type IAPI$9 as IAPI };
+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 enum Status$1 {
@@ -2261,7 +2261,7 @@ type Feedback = z.infer<typeof FeedbackSchema>;
 type Rating = z.infer<typeof RatingSchema>;
 type RatingInput = Pick<Rating, "score" | "tags" | "comment">;
 
-interface IAPI$8 {
+interface IAPI$9 {
     /** 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>;
@@ -2289,7 +2289,7 @@ interface IAPI$8 {
         isEligibleForFreeProject(context: Context): Promise<boolean>;
     };
 }
-declare const Endpoints$7: {
+declare const Endpoints$8: {
     Reorder: {
         uri: string;
         method: string;
@@ -2420,33 +2420,33 @@ type StatusConfigType = {
 };
 declare const StatusConfig: Record<Status$1, StatusConfigType>;
 
-type index$9_Approve = Approve;
-type index$9_CaptionStyle = CaptionStyle;
-declare const index$9_CaptionStyle: typeof CaptionStyle;
-type index$9_Feedback = Feedback;
-declare const index$9_FeedbackSchema: typeof FeedbackSchema;
-type index$9_Interaction = Interaction;
-declare const index$9_InteractionSchema: typeof InteractionSchema;
-type index$9_InteractionType = InteractionType;
-declare const index$9_InteractionType: typeof InteractionType;
-type index$9_ProjectCreation = ProjectCreation;
-declare const index$9_ProjectSchema: typeof ProjectSchema;
-type index$9_Rating = Rating;
-type index$9_RatingInput = RatingInput;
-declare const index$9_RatingSchema: typeof RatingSchema;
-type index$9_RatingTag = RatingTag;
-declare const index$9_RatingTag: typeof RatingTag;
-type index$9_SendToApproval = SendToApproval;
-declare const index$9_StatusConfig: typeof StatusConfig;
-type index$9_StatusConfigType = StatusConfigType;
-type index$9_StreamTicket = StreamTicket;
-declare const index$9_StreamTicketSchema: typeof StreamTicketSchema;
-type index$9_Style = Style;
-declare const index$9_Styles: typeof Styles;
-type index$9_TimelineItem = TimelineItem;
-declare const index$9_TimelineItemSchema: typeof TimelineItemSchema;
-declare namespace index$9 {
-  export { type index$9_Approve as Approve, index$9_CaptionStyle as CaptionStyle, Endpoints$7 as Endpoints, type Project as Entity, type index$9_Feedback as Feedback, index$9_FeedbackSchema as FeedbackSchema, type IAPI$8 as IAPI, type index$9_Interaction as Interaction, index$9_InteractionSchema as InteractionSchema, index$9_InteractionType as InteractionType, type index$9_ProjectCreation as ProjectCreation, index$9_ProjectSchema as ProjectSchema, type index$9_Rating as Rating, type index$9_RatingInput as RatingInput, index$9_RatingSchema as RatingSchema, index$9_RatingTag as RatingTag, type index$9_SendToApproval as SendToApproval, Status$1 as Status, index$9_StatusConfig as StatusConfig, type index$9_StatusConfigType as StatusConfigType, type index$9_StreamTicket as StreamTicket, index$9_StreamTicketSchema as StreamTicketSchema, type index$9_Style as Style, index$9_Styles as Styles, type index$9_TimelineItem as TimelineItem, index$9_TimelineItemSchema as TimelineItemSchema };
+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 };
 }
 
 declare const DailyMilestoneSchema: z.ZodObject<{
@@ -2518,11 +2518,11 @@ declare const GoalSchema: z.ZodObject<{
 type DailyMilestone = z.infer<typeof DailyMilestoneSchema>;
 type Goal = z.infer<typeof GoalSchema>;
 
-interface IAPI$7 {
+interface IAPI$8 {
     getGoals: (context: Context) => Promise<Goal[]>;
     getEditorGoals: (context: Context, editorId: string) => Promise<Goal[]>;
 }
-declare const Endpoints$6: {
+declare const Endpoints$7: {
     GetGoals: {
         uri: string;
         method: string;
@@ -2533,11 +2533,11 @@ declare const Endpoints$6: {
     };
 };
 
-type index$8_DailyMilestone = DailyMilestone;
-declare const index$8_DailyMilestoneSchema: typeof DailyMilestoneSchema;
-declare const index$8_GoalSchema: typeof GoalSchema;
-declare namespace index$8 {
-  export { type index$8_DailyMilestone as DailyMilestone, index$8_DailyMilestoneSchema as DailyMilestoneSchema, Endpoints$6 as Endpoints, type Goal as Entity, index$8_GoalSchema as GoalSchema, type IAPI$7 as IAPI };
+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 };
 }
 
 declare const EditorSchema: z.ZodObject<{
@@ -2570,11 +2570,11 @@ declare const EditorSchema: z.ZodObject<{
 }>;
 type Editor = z.infer<typeof EditorSchema>;
 
-interface IAPI$6 {
+interface IAPI$7 {
     getAll(context: Context): Promise<Editor[]>;
     getById(context: Context, editorId: string): Promise<Editor>;
 }
-declare const Endpoints$5: {
+declare const Endpoints$6: {
     GetAll: {
         uri: string;
         method: string;
@@ -2585,9 +2585,9 @@ declare const Endpoints$5: {
     };
 };
 
-declare const index$7_EditorSchema: typeof EditorSchema;
-declare namespace index$7 {
-  export { index$7_EditorSchema as EditorSchema, Endpoints$5 as Endpoints, type Editor as Entity, type IAPI$6 as IAPI };
+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 enum Frequency {
@@ -3088,7 +3088,7 @@ type RecurrenceRule = z.infer<typeof RecurrenceRuleSchema>;
 type History = z.infer<typeof HistorySchema>;
 type Criteria = z.infer<typeof CriteriaSchema>;
 
-interface IAPI$5 {
+interface IAPI$6 {
     getTriggers: (ctx: Context) => Promise<APIResponse<Trigger>>;
     createTrigger: (ctx: Context, t: Trigger) => Promise<Trigger>;
     deleteTrigger: (ctx: Context, triggerId: string) => Promise<boolean>;
@@ -3098,7 +3098,7 @@ interface IAPI$5 {
     markAsRead: (ctx: Context, id: string) => Promise<boolean>;
     clearNotifications: (ctx: Context) => Promise<boolean>;
 }
-declare const Endpoints$4: {
+declare const Endpoints$5: {
     Create: {
         uri: string;
         method: string;
@@ -3133,35 +3133,35 @@ declare const Endpoints$4: {
     };
 };
 
-type index$6_Criteria = Criteria;
-declare const index$6_CriteriaSchema: typeof CriteriaSchema;
-type index$6_CriteriaType = CriteriaType;
-declare const index$6_CriteriaType: typeof CriteriaType;
-type index$6_Frequency = Frequency;
-declare const index$6_Frequency: typeof Frequency;
-type index$6_History = History;
-declare const index$6_HistorySchema: typeof HistorySchema;
-type index$6_NotificationDetail = NotificationDetail;
-declare const index$6_NotificationDetailSchema: typeof NotificationDetailSchema;
-type index$6_NotificationItem = NotificationItem;
-declare const index$6_NotificationItemSchema: typeof NotificationItemSchema;
-type index$6_NotificationType = NotificationType;
-declare const index$6_NotificationType: typeof NotificationType;
-type index$6_RecurrenceRule = RecurrenceRule;
-declare const index$6_RecurrenceRuleSchema: typeof RecurrenceRuleSchema;
-type index$6_Status = Status;
-declare const index$6_Status: typeof Status;
-type index$6_TransportType = TransportType;
-declare const index$6_TransportType: typeof TransportType;
-type index$6_Trigger = Trigger;
-declare const index$6_TriggerSchema: typeof TriggerSchema;
-type index$6_WeekDay = WeekDay;
-declare const index$6_WeekDay: typeof WeekDay;
-declare namespace index$6 {
-  export { type index$6_Criteria as Criteria, index$6_CriteriaSchema as CriteriaSchema, index$6_CriteriaType as CriteriaType, Endpoints$4 as Endpoints, index$6_Frequency as Frequency, type index$6_History as History, index$6_HistorySchema as HistorySchema, type IAPI$5 as IAPI, type index$6_NotificationDetail as NotificationDetail, index$6_NotificationDetailSchema as NotificationDetailSchema, type index$6_NotificationItem as NotificationItem, index$6_NotificationItemSchema as NotificationItemSchema, index$6_NotificationType as NotificationType, type index$6_RecurrenceRule as RecurrenceRule, index$6_RecurrenceRuleSchema as RecurrenceRuleSchema, index$6_Status as Status, index$6_TransportType as TransportType, type index$6_Trigger as Trigger, index$6_TriggerSchema as TriggerSchema, index$6_WeekDay as WeekDay };
+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 };
 }
 
-interface IAPI$4 {
+interface IAPI$5 {
     version: () => Promise<string>;
 }
 
@@ -3305,13 +3305,13 @@ declare const NoteSchema: z.ZodObject<{
 type Note = z.infer<typeof NoteSchema>;
 type NoteHistory = z.infer<typeof NoteHistorySchema>;
 
-interface IAPI$3 {
+interface IAPI$4 {
     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$3: {
+declare const Endpoints$4: {
     GetNotes: {
         uri: string;
         method: string;
@@ -3330,11 +3330,11 @@ declare const Endpoints$3: {
     };
 };
 
-type index$5_NoteHistory = NoteHistory;
-declare const index$5_NoteHistorySchema: typeof NoteHistorySchema;
-declare const index$5_NoteSchema: typeof NoteSchema;
-declare namespace index$5 {
-  export { Endpoints$3 as Endpoints, type Note as Entity, type IAPI$3 as IAPI, type index$5_NoteHistory as NoteHistory, index$5_NoteHistorySchema as NoteHistorySchema, index$5_NoteSchema as NoteSchema };
+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 };
 }
 
 declare const SpecialOfferSchema: z.ZodObject<{
@@ -3451,7 +3451,7 @@ type UserOfferDetails = z.infer<typeof UserOfferDetailsSchema>;
 type Create$1 = z.infer<typeof CreateSpecialOfferSchema>;
 type Update$1 = z.infer<typeof UpdateSpecialOfferSchema>;
 
-interface IAPI$2 {
+interface IAPI$3 {
     list: (ctx: Context) => Promise<SpecialOffer[]>;
     getActive: (ctx: Context) => Promise<SpecialOffer[]>;
     create: (ctx: Context, data: Create$1) => Promise<SpecialOffer>;
@@ -3461,7 +3461,7 @@ interface IAPI$2 {
     getMyOffer: (ctx: Context) => Promise<UserOfferDetails | null>;
     claim: (ctx: Context, callbackUrl?: string) => Promise<string>;
 }
-declare const Endpoints$2: {
+declare const Endpoints$3: {
     List: {
         uri: string;
         method: string;
@@ -3496,13 +3496,13 @@ declare const Endpoints$2: {
     };
 };
 
-declare const index$4_CreateSpecialOfferSchema: typeof CreateSpecialOfferSchema;
-declare const index$4_SpecialOfferSchema: typeof SpecialOfferSchema;
-declare const index$4_UpdateSpecialOfferSchema: typeof UpdateSpecialOfferSchema;
-type index$4_UserOfferDetails = UserOfferDetails;
-declare const index$4_UserOfferDetailsSchema: typeof UserOfferDetailsSchema;
-declare namespace index$4 {
-  export { type Create$1 as Create, index$4_CreateSpecialOfferSchema as CreateSpecialOfferSchema, Endpoints$2 as Endpoints, type SpecialOffer as Entity, type IAPI$2 as IAPI, index$4_SpecialOfferSchema as SpecialOfferSchema, type Update$1 as Update, index$4_UpdateSpecialOfferSchema as UpdateSpecialOfferSchema, type index$4_UserOfferDetails as UserOfferDetails, index$4_UserOfferDetailsSchema as UserOfferDetailsSchema };
+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 };
 }
 
 /**
@@ -4165,7 +4165,60 @@ declare const SetShredUSessionRecordingSchema: z.ZodObject<{
     recordingDurationSeconds: number;
     recordingThumbnailUrl?: string | undefined;
 }>;
+declare const ShredUStageRuleSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    /** How long before the session starts this goes out. 0 means at start. */
+    leadMs: z.ZodNumber;
+    transport: z.ZodNativeEnum<typeof TransportType>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    label: string;
+    leadMs: number;
+    transport: TransportType;
+}, {
+    id: string;
+    label: string;
+    leadMs: number;
+    transport: TransportType;
+}>;
+declare const ShredUDispatchRulesSchema: z.ZodObject<{
+    /** Furthest ahead first, the order they fire in. */
+    stages: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        /** How long before the session starts this goes out. 0 means at start. */
+        leadMs: z.ZodNumber;
+        transport: z.ZodNativeEnum<typeof TransportType>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        label: string;
+        leadMs: number;
+        transport: TransportType;
+    }, {
+        id: string;
+        label: string;
+        leadMs: number;
+        transport: TransportType;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    stages: {
+        id: string;
+        label: string;
+        leadMs: number;
+        transport: TransportType;
+    }[];
+}, {
+    stages: {
+        id: string;
+        label: string;
+        leadMs: number;
+        transport: TransportType;
+    }[];
+}>;
 type SessionAsset = z.infer<typeof SessionAssetSchema>;
+type ShredUStageRule = z.infer<typeof ShredUStageRuleSchema>;
+type ShredUDispatchRules = z.infer<typeof ShredUDispatchRulesSchema>;
 type Brief = z.infer<typeof ShredUBriefSchema>;
 type ShredUSessionStatus = z.infer<typeof ShredUSessionStatusSchema>;
 type ShredUSession = z.infer<typeof ShredUSessionSchema>;
@@ -4176,7 +4229,7 @@ type Update = z.infer<typeof UpdateShredUSessionSchema>;
 type SetRecording = z.infer<typeof SetShredUSessionRecordingSchema>;
 type PreviewEmail = z.infer<typeof PreviewShredUEmailSchema>;
 
-interface IAPI$1 {
+interface IAPI$2 {
     list: (ctx: Context) => Promise<ShredUSession[]>;
     getUpcoming: (ctx: Context) => Promise<ShredUSessionCustomer[]>;
     getLibrary: (ctx: Context) => Promise<ShredUSessionCustomer[]>;
@@ -4187,8 +4240,10 @@ interface IAPI$1 {
     cancel: (ctx: Context, id: string) => Promise<void>;
     setRecording: (ctx: Context, id: string, data: SetRecording) => Promise<void>;
     previewEmail: (ctx: Context, data: PreviewEmail) => Promise<void>;
+    /** The lead times the dispatch job runs on. Static: fetch once, not per keystroke. */
+    getDispatchRules: (ctx: Context) => Promise<ShredUDispatchRules>;
 }
-declare const Endpoints$1: {
+declare const Endpoints$2: {
     List: {
         uri: string;
         method: string;
@@ -4229,30 +4284,659 @@ declare const Endpoints$1: {
         uri: string;
         method: string;
     };
+    GetDispatchRules: {
+        uri: string;
+        method: string;
+    };
+};
+
+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_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_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 };
+}
+
+/** The metrics served today. The list grows, so it never gates parsing — see ScoreMetricSchema. */
+declare const ScoreMetricKeySchema: z.ZodEnum<["submissions", "interactions", "attendance"]>;
+/** A labelled range over 0-100. Serves both the overall bands and the per-metric ratings. */
+declare const ScoreBandSchema: z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    min: z.ZodNumber;
+    max: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    label: string;
+    min: number;
+    max: number;
+    key: string;
+}, {
+    label: string;
+    min: number;
+    max: number;
+    key: string;
+}>;
+declare const ScoreMetricSchema: z.ZodObject<{
+    /**
+     * Deliberately not the enum: a metric added API-side must not break a client that
+     * predates it. Render the array generically and switch on ScoreMetricKey only where
+     * a known metric needs special treatment.
+     */
+    key: z.ZodString;
+    /** The share this metric actually carried, after unavailable ones were left out. */
+    weight: z.ZodNumber;
+    value: z.ZodNumber;
+    target: z.ZodNumber;
+    ratio: z.ZodNumber;
+    available: z.ZodBoolean;
+    rating: z.ZodOptional<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        min: z.ZodNumber;
+        max: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        min: number;
+        max: number;
+        key: string;
+    }, {
+        label: string;
+        min: number;
+        max: number;
+        key: string;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    value: number;
+    key: string;
+    target: number;
+    weight: number;
+    ratio: number;
+    available: boolean;
+    rating?: {
+        label: string;
+        min: number;
+        max: number;
+        key: string;
+    } | undefined;
+}, {
+    value: number;
+    key: string;
+    target: number;
+    weight: number;
+    ratio: number;
+    available: boolean;
+    rating?: {
+        label: string;
+        min: number;
+        max: number;
+        key: string;
+    } | undefined;
+}>;
+declare const ScoreSchema: z.ZodObject<{
+    value: z.ZodNumber;
+    hasData: z.ZodBoolean;
+    period: z.ZodString;
+    periodLabel: z.ZodString;
+    band: z.ZodOptional<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        min: z.ZodNumber;
+        max: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        min: number;
+        max: number;
+        key: string;
+    }, {
+        label: string;
+        min: number;
+        max: number;
+        key: string;
+    }>>;
+    nextBand: z.ZodOptional<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        min: z.ZodNumber;
+        max: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        min: number;
+        max: number;
+        key: string;
+    }, {
+        label: string;
+        min: number;
+        max: number;
+        key: string;
+    }>>;
+    pointsToNextBand: z.ZodOptional<z.ZodNumber>;
+    trend: z.ZodOptional<z.ZodNumber>;
+    computedAt: z.ZodNumber;
+    metrics: z.ZodArray<z.ZodObject<{
+        /**
+         * Deliberately not the enum: a metric added API-side must not break a client that
+         * predates it. Render the array generically and switch on ScoreMetricKey only where
+         * a known metric needs special treatment.
+         */
+        key: z.ZodString;
+        /** The share this metric actually carried, after unavailable ones were left out. */
+        weight: z.ZodNumber;
+        value: z.ZodNumber;
+        target: z.ZodNumber;
+        ratio: z.ZodNumber;
+        available: z.ZodBoolean;
+        rating: z.ZodOptional<z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodString;
+            min: z.ZodNumber;
+            max: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            label: string;
+            min: number;
+            max: number;
+            key: string;
+        }, {
+            label: string;
+            min: number;
+            max: number;
+            key: string;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        value: number;
+        key: string;
+        target: number;
+        weight: number;
+        ratio: number;
+        available: boolean;
+        rating?: {
+            label: string;
+            min: number;
+            max: number;
+            key: string;
+        } | undefined;
+    }, {
+        value: number;
+        key: string;
+        target: number;
+        weight: number;
+        ratio: number;
+        available: boolean;
+        rating?: {
+            label: string;
+            min: number;
+            max: number;
+            key: string;
+        } | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    value: number;
+    hasData: boolean;
+    period: string;
+    periodLabel: string;
+    computedAt: number;
+    metrics: {
+        value: number;
+        key: string;
+        target: number;
+        weight: number;
+        ratio: number;
+        available: boolean;
+        rating?: {
+            label: string;
+            min: number;
+            max: number;
+            key: string;
+        } | undefined;
+    }[];
+    band?: {
+        label: string;
+        min: number;
+        max: number;
+        key: string;
+    } | undefined;
+    nextBand?: {
+        label: string;
+        min: number;
+        max: number;
+        key: string;
+    } | undefined;
+    pointsToNextBand?: number | undefined;
+    trend?: number | undefined;
+}, {
+    value: number;
+    hasData: boolean;
+    period: string;
+    periodLabel: string;
+    computedAt: number;
+    metrics: {
+        value: number;
+        key: string;
+        target: number;
+        weight: number;
+        ratio: number;
+        available: boolean;
+        rating?: {
+            label: string;
+            min: number;
+            max: number;
+            key: string;
+        } | undefined;
+    }[];
+    band?: {
+        label: string;
+        min: number;
+        max: number;
+        key: string;
+    } | undefined;
+    nextBand?: {
+        label: string;
+        min: number;
+        max: number;
+        key: string;
+    } | undefined;
+    pointsToNextBand?: number | undefined;
+    trend?: number | undefined;
+}>;
+declare const ScoreHistoryEntrySchema: z.ZodObject<{
+    period: z.ZodString;
+    label: z.ZodString;
+    value: z.ZodNumber;
+    band: z.ZodOptional<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        min: z.ZodNumber;
+        max: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        min: number;
+        max: number;
+        key: string;
+    }, {
+        label: string;
+        min: number;
+        max: number;
+        key: string;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    value: number;
+    label: string;
+    period: string;
+    band?: {
+        label: string;
+        min: number;
+        max: number;
+        key: string;
+    } | undefined;
+}, {
+    value: number;
+    label: string;
+    period: string;
+    band?: {
+        label: string;
+        min: number;
+        max: number;
+        key: string;
+    } | undefined;
+}>;
+declare const ScoreRecapSchema: z.ZodObject<{
+    current: z.ZodObject<{
+        value: z.ZodNumber;
+        hasData: z.ZodBoolean;
+        period: z.ZodString;
+        periodLabel: z.ZodString;
+        band: z.ZodOptional<z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodString;
+            min: z.ZodNumber;
+            max: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            label: string;
+            min: number;
+            max: number;
+            key: string;
+        }, {
+            label: string;
+            min: number;
+            max: number;
+            key: string;
+        }>>;
+        nextBand: z.ZodOptional<z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodString;
+            min: z.ZodNumber;
+            max: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            label: string;
+            min: number;
+            max: number;
+            key: string;
+        }, {
+            label: string;
+            min: number;
+            max: number;
+            key: string;
+        }>>;
+        pointsToNextBand: z.ZodOptional<z.ZodNumber>;
+        trend: z.ZodOptional<z.ZodNumber>;
+        computedAt: z.ZodNumber;
+        metrics: z.ZodArray<z.ZodObject<{
+            /**
+             * Deliberately not the enum: a metric added API-side must not break a client that
+             * predates it. Render the array generically and switch on ScoreMetricKey only where
+             * a known metric needs special treatment.
+             */
+            key: z.ZodString;
+            /** The share this metric actually carried, after unavailable ones were left out. */
+            weight: z.ZodNumber;
+            value: z.ZodNumber;
+            target: z.ZodNumber;
+            ratio: z.ZodNumber;
+            available: z.ZodBoolean;
+            rating: z.ZodOptional<z.ZodObject<{
+                key: z.ZodString;
+                label: z.ZodString;
+                min: z.ZodNumber;
+                max: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                label: string;
+                min: number;
+                max: number;
+                key: string;
+            }, {
+                label: string;
+                min: number;
+                max: number;
+                key: string;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            value: number;
+            key: string;
+            target: number;
+            weight: number;
+            ratio: number;
+            available: boolean;
+            rating?: {
+                label: string;
+                min: number;
+                max: number;
+                key: string;
+            } | undefined;
+        }, {
+            value: number;
+            key: string;
+            target: number;
+            weight: number;
+            ratio: number;
+            available: boolean;
+            rating?: {
+                label: string;
+                min: number;
+                max: number;
+                key: string;
+            } | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        value: number;
+        hasData: boolean;
+        period: string;
+        periodLabel: string;
+        computedAt: number;
+        metrics: {
+            value: number;
+            key: string;
+            target: number;
+            weight: number;
+            ratio: number;
+            available: boolean;
+            rating?: {
+                label: string;
+                min: number;
+                max: number;
+                key: string;
+            } | undefined;
+        }[];
+        band?: {
+            label: string;
+            min: number;
+            max: number;
+            key: string;
+        } | undefined;
+        nextBand?: {
+            label: string;
+            min: number;
+            max: number;
+            key: string;
+        } | undefined;
+        pointsToNextBand?: number | undefined;
+        trend?: number | undefined;
+    }, {
+        value: number;
+        hasData: boolean;
+        period: string;
+        periodLabel: string;
+        computedAt: number;
+        metrics: {
+            value: number;
+            key: string;
+            target: number;
+            weight: number;
+            ratio: number;
+            available: boolean;
+            rating?: {
+                label: string;
+                min: number;
+                max: number;
+                key: string;
+            } | undefined;
+        }[];
+        band?: {
+            label: string;
+            min: number;
+            max: number;
+            key: string;
+        } | undefined;
+        nextBand?: {
+            label: string;
+            min: number;
+            max: number;
+            key: string;
+        } | undefined;
+        pointsToNextBand?: number | undefined;
+        trend?: number | undefined;
+    }>;
+    /** Oldest first. Months before the customer's first project are absent, not zero. */
+    history: z.ZodArray<z.ZodObject<{
+        period: z.ZodString;
+        label: z.ZodString;
+        value: z.ZodNumber;
+        band: z.ZodOptional<z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodString;
+            min: z.ZodNumber;
+            max: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            label: string;
+            min: number;
+            max: number;
+            key: string;
+        }, {
+            label: string;
+            min: number;
+            max: number;
+            key: string;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        value: number;
+        label: string;
+        period: string;
+        band?: {
+            label: string;
+            min: number;
+            max: number;
+            key: string;
+        } | undefined;
+    }, {
+        value: number;
+        label: string;
+        period: string;
+        band?: {
+            label: string;
+            min: number;
+            max: number;
+            key: string;
+        } | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    history: {
+        value: number;
+        label: string;
+        period: string;
+        band?: {
+            label: string;
+            min: number;
+            max: number;
+            key: string;
+        } | undefined;
+    }[];
+    current: {
+        value: number;
+        hasData: boolean;
+        period: string;
+        periodLabel: string;
+        computedAt: number;
+        metrics: {
+            value: number;
+            key: string;
+            target: number;
+            weight: number;
+            ratio: number;
+            available: boolean;
+            rating?: {
+                label: string;
+                min: number;
+                max: number;
+                key: string;
+            } | undefined;
+        }[];
+        band?: {
+            label: string;
+            min: number;
+            max: number;
+            key: string;
+        } | undefined;
+        nextBand?: {
+            label: string;
+            min: number;
+            max: number;
+            key: string;
+        } | undefined;
+        pointsToNextBand?: number | undefined;
+        trend?: number | undefined;
+    };
+}, {
+    history: {
+        value: number;
+        label: string;
+        period: string;
+        band?: {
+            label: string;
+            min: number;
+            max: number;
+            key: string;
+        } | undefined;
+    }[];
+    current: {
+        value: number;
+        hasData: boolean;
+        period: string;
+        periodLabel: string;
+        computedAt: number;
+        metrics: {
+            value: number;
+            key: string;
+            target: number;
+            weight: number;
+            ratio: number;
+            available: boolean;
+            rating?: {
+                label: string;
+                min: number;
+                max: number;
+                key: string;
+            } | undefined;
+        }[];
+        band?: {
+            label: string;
+            min: number;
+            max: number;
+            key: string;
+        } | undefined;
+        nextBand?: {
+            label: string;
+            min: number;
+            max: number;
+            key: string;
+        } | undefined;
+        pointsToNextBand?: number | undefined;
+        trend?: number | undefined;
+    };
+}>;
+type ScoreMetricKey = z.infer<typeof ScoreMetricKeySchema>;
+type ScoreBand = z.infer<typeof ScoreBandSchema>;
+type ScoreMetric = z.infer<typeof ScoreMetricSchema>;
+type Score = z.infer<typeof ScoreSchema>;
+type ScoreHistoryEntry = z.infer<typeof ScoreHistoryEntrySchema>;
+type ScoreRecap = z.infer<typeof ScoreRecapSchema>;
+
+interface IAPI$1 {
+    /**
+     * 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`
+     * and a month still being lived is rejected.
+     */
+    getRecap: (context: Context, period?: string) => Promise<ScoreRecap>;
+}
+declare const Endpoints$1: {
+    GetRecap: {
+        uri: string;
+        method: string;
+    };
 };
 
-type index$3_Brief = Brief;
-type index$3_Create = Create;
-declare const index$3_CreateShredUBriefSchema: typeof CreateShredUBriefSchema;
-declare const index$3_CreateShredUSessionSchema: typeof CreateShredUSessionSchema;
-type index$3_Join = Join;
-type index$3_PreviewEmail = PreviewEmail;
-declare const index$3_PreviewShredUEmailSchema: typeof PreviewShredUEmailSchema;
-type index$3_SessionAsset = SessionAsset;
-declare const index$3_SessionAssetSchema: typeof SessionAssetSchema;
-type index$3_SetRecording = SetRecording;
-declare const index$3_SetShredUSessionRecordingSchema: typeof SetShredUSessionRecordingSchema;
-declare const index$3_ShredUBriefSchema: typeof ShredUBriefSchema;
-declare const index$3_ShredUJoinSchema: typeof ShredUJoinSchema;
-type index$3_ShredUSessionCustomer = ShredUSessionCustomer;
-declare const index$3_ShredUSessionCustomerSchema: typeof ShredUSessionCustomerSchema;
-declare const index$3_ShredUSessionSchema: typeof ShredUSessionSchema;
-type index$3_ShredUSessionStatus = ShredUSessionStatus;
-declare const index$3_ShredUSessionStatusSchema: typeof ShredUSessionStatusSchema;
-type index$3_Update = Update;
-declare const index$3_UpdateShredUSessionSchema: typeof UpdateShredUSessionSchema;
+type index$3_Score = Score;
+type index$3_ScoreBand = ScoreBand;
+declare const index$3_ScoreBandSchema: typeof ScoreBandSchema;
+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;
+declare const index$3_ScoreRecapSchema: typeof ScoreRecapSchema;
+declare const index$3_ScoreSchema: typeof ScoreSchema;
 declare namespace index$3 {
-  export { type index$3_Brief as Brief, type index$3_Create as Create, index$3_CreateShredUBriefSchema as CreateShredUBriefSchema, index$3_CreateShredUSessionSchema as CreateShredUSessionSchema, Endpoints$1 as Endpoints, type ShredUSession as Entity, type IAPI$1 as IAPI, type index$3_Join as Join, type index$3_PreviewEmail as PreviewEmail, index$3_PreviewShredUEmailSchema as PreviewShredUEmailSchema, type index$3_SessionAsset as SessionAsset, index$3_SessionAssetSchema as SessionAssetSchema, type index$3_SetRecording as SetRecording, index$3_SetShredUSessionRecordingSchema as SetShredUSessionRecordingSchema, index$3_ShredUBriefSchema as ShredUBriefSchema, index$3_ShredUJoinSchema as ShredUJoinSchema, type index$3_ShredUSessionCustomer as ShredUSessionCustomer, index$3_ShredUSessionCustomerSchema as ShredUSessionCustomerSchema, index$3_ShredUSessionSchema as ShredUSessionSchema, type index$3_ShredUSessionStatus as ShredUSessionStatus, index$3_ShredUSessionStatusSchema as ShredUSessionStatusSchema, type index$3_Update as Update, index$3_UpdateShredUSessionSchema as UpdateShredUSessionSchema };
+  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_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, index$3_ScoreRecapSchema as ScoreRecapSchema, index$3_ScoreSchema as ScoreSchema };
 }
 
 /**
@@ -4617,20 +5301,21 @@ declare namespace index$2 {
 }
 
 declare class ShredAPI {
-    user: IAPI$c;
-    goal: IAPI$7;
-    editor: IAPI$6;
-    subscription: IAPI$d;
-    prompt: IAPI$e;
-    pushNotification: IAPI$5;
-    email: IAPI$9;
-    tenant: IAPI$b;
-    app: IAPI$4;
-    project: IAPI$8;
-    track: IAPI$a;
-    note: IAPI$3;
-    specialOffer: IAPI$2;
-    shredu: IAPI$1;
+    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;
     rbac: IAPI;
     constructor(env: Environment);
 }
@@ -4723,4 +5408,4 @@ declare namespace index {
   export { index_AssetSchema as AssetSchema, type Asset as Entity };
 }
 
-export { index as Asset, index$e as Core, index$7 as Editor, index$a as Email, index$1 as Exceptions, index$8 as Goal, index$5 as Note, index$6 as Notification, index$9 as Project, index$g as Prompt, index$2 as RBAC, ShredAPI, index$3 as ShredU, index$4 as SpecialOffer, index$f as Subscription, index$c as Tenant, index$b as Track, index$d as User, ShredAPI as default };
+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 };