shred-api-client 2.9.13 → 2.10.0

package/dist/index.d.ts

@@ -197,7 +197,7 @@ type Context = {
     requestId?: string;
 };
 
-interface IAPI$d {
+interface IAPI$e {
     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$d {
     generateScript: (c: Context, data: ScriptIARequest) => Promise<string>;
     updateScript: (c: Context, id: string, script: Partial<Script>) => Promise<boolean>;
 }
-declare const Endpoints$c: {
+declare const Endpoints$d: {
     GetPrompt: {
         uri: string;
         method: string;
@@ -232,15 +232,15 @@ declare const Endpoints$c: {
     };
 };
 
-type index$f_Category = Category;
-declare const index$f_CategorySchema: typeof CategorySchema;
-declare const index$f_PromptSchema: typeof PromptSchema;
-type index$f_Script = Script;
-type index$f_ScriptIARequest = ScriptIARequest;
-declare const index$f_ScriptIARequestSchema: typeof ScriptIARequestSchema;
-declare const index$f_ScriptSchema: typeof ScriptSchema;
-declare namespace index$f {
-  export { type index$f_Category as Category, index$f_CategorySchema as CategorySchema, Endpoints$c as Endpoints, type Prompt as Entity, type IAPI$d as IAPI, index$f_PromptSchema as PromptSchema, type index$f_Script as Script, type index$f_ScriptIARequest as ScriptIARequest, index$f_ScriptIARequestSchema as ScriptIARequestSchema, index$f_ScriptSchema as ScriptSchema };
+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 };
 }
 
 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$c {
+interface IAPI$d {
     getCharges: (ctx: Context) => Promise<Charge[]>;
     getPortalUrl: (ctx: Context) => Promise<string>;
     getSubscription: (context: Context, userId?: string) => Promise<Subscription | null>;
@@ -609,7 +609,7 @@ interface IAPI$c {
     getSubscriptionsSummary: (ctx: Context) => Promise<SubscriptionSummary[]>;
     listPromoCodes: (ctx: Context) => Promise<PromoCode[]>;
 }
-declare const Endpoints$b: {
+declare const Endpoints$c: {
     GetPortal: {
         uri: string;
         method: string;
@@ -668,19 +668,19 @@ declare const Endpoints$b: {
     };
 };
 
-type index$e_Charge = Charge;
-declare const index$e_ChargeSchema: typeof ChargeSchema;
-type index$e_Plan = Plan;
-declare const index$e_PlanSchema: typeof PlanSchema;
-type index$e_Product = Product;
-declare const index$e_ProductSchema: typeof ProductSchema;
-type index$e_PromoCode = PromoCode;
-declare const index$e_SubscriptionSchema: typeof SubscriptionSchema;
-declare const index$e_SubscriptionTypeSchema: typeof SubscriptionTypeSchema;
-type index$e_Type = Type;
-declare const index$e_Type: typeof Type;
-declare namespace index$e {
-  export { type index$e_Charge as Charge, index$e_ChargeSchema as ChargeSchema, Endpoints$b as Endpoints, type Subscription as Entity, type IAPI$c as IAPI, type index$e_Plan as Plan, index$e_PlanSchema as PlanSchema, type index$e_Product as Product, index$e_ProductSchema as ProductSchema, type index$e_PromoCode as PromoCode, index$e_SubscriptionSchema as SubscriptionSchema, index$e_SubscriptionTypeSchema as SubscriptionTypeSchema, type SubscriptionSummary as Summary, index$e_Type as Type };
+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 };
 }
 
 declare enum Role$1 {
@@ -837,8 +837,8 @@ declare const UserSchema: z.ZodObject<{
 }>;
 type User = z.infer<typeof UserSchema>;
 type Preferences$1 = z.infer<typeof PreferencesSchema$1>;
-type Update$1 = Pick<User, "name" | "profession" | "preferences" | "photoUrl" | "fcmToken" | "timezone" | "experienceId">;
-type Create$1 = Pick<User, "name" | "email"> & {
+type Update$2 = Pick<User, "name" | "profession" | "preferences" | "photoUrl" | "fcmToken" | "timezone" | "experienceId">;
+type Create$2 = Pick<User, "name" | "email"> & {
     password?: string;
     passwordConfirmation?: string;
     invitationCode?: string;
@@ -873,16 +873,16 @@ type APIResponse<T> = {
     perPage?: number;
 };
 
-type index$d_APIResponse<T> = APIResponse<T>;
-type index$d_QueryFilterOp = QueryFilterOp;
-type index$d_QueryOptions<T> = QueryOptions<T>;
-type index$d_QueryOrderBy<T> = QueryOrderBy<T>;
-type index$d_QueryWhere<T> = QueryWhere<T>;
-declare namespace index$d {
-  export type { index$d_APIResponse as APIResponse, index$d_QueryFilterOp as QueryFilterOp, index$d_QueryOptions as QueryOptions, index$d_QueryOrderBy as QueryOrderBy, index$d_QueryWhere as QueryWhere };
+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 };
 }
 
-interface IAPI$b {
+interface IAPI$c {
     getUserInfo: (context: Context) => Promise<User>;
     isEmailAvaliable: (email: string) => Promise<boolean>;
     sendValidationCode: (email: string) => Promise<boolean>;
@@ -890,16 +890,16 @@ interface IAPI$b {
     changePassword: (email: string, pass: string, passConfirm: string, code: number) => Promise<boolean>;
     changeEmail: (ctx: Context, email: string, code: number) => Promise<boolean>;
     authenticate: (email: string, password: string, system: System | System[]) => Promise<string>;
-    update: (context: Context, update: Partial<Update$1>) => Promise<boolean>;
+    update: (context: Context, update: Partial<Update$2>) => Promise<boolean>;
     setup: (context: Context) => Promise<boolean>;
     getBindedUsers: (ctx: Context) => Promise<User[]>;
     deleteAccount: (ctx: Context) => Promise<boolean>;
     getIntegrationToken: (ctx: Context) => Promise<string | null>;
     createIntegrationToken: (ctx: Context) => Promise<string>;
     search: (ctx: Context, query: QueryOptions<User>) => Promise<APIResponse<User>>;
-    createUser: (data: Create$1) => Promise<User>;
+    createUser: (data: Create$2) => Promise<User>;
 }
-declare const Endpoints$a: {
+declare const Endpoints$b: {
     ChangeEmail: {
         uri: string;
         method: string;
@@ -966,11 +966,11 @@ declare const Endpoints$a: {
     };
 };
 
-type index$c_System = System;
-declare const index$c_System: typeof System;
-declare const index$c_UserSchema: typeof UserSchema;
-declare namespace index$c {
-  export { type Create$1 as Create, Endpoints$a as Endpoints, type User as Entity, type IAPI$b as IAPI, type Preferences$1 as Preferences, PreferencesSchema$1 as PreferencesSchema, Role$1 as Role, index$c_System as System, type Update$1 as Update, index$c_UserSchema as UserSchema };
+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 };
 }
 
 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$a {
+interface IAPI$b {
     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$a {
     update: (tenantId: string, data: TenantUpdate, context: Context) => Promise<boolean>;
     updateMembers: (tenantId: string, memberUpdate: MemberUpdate, context: Context) => Promise<boolean>;
 }
-declare const Endpoints$9: {
+declare const Endpoints$a: {
     GetByInviteCode: {
         uri: string;
         method: string;
@@ -1754,17 +1754,17 @@ declare const Endpoints$9: {
     };
 };
 
-type index$b_Member = Member;
-declare const index$b_MemberSchema: typeof MemberSchema;
-type index$b_MemberUpdate = MemberUpdate;
-declare const index$b_MemberUpdateSchema: typeof MemberUpdateSchema;
-type index$b_Preferences = Preferences;
-declare const index$b_PreferencesSchema: typeof PreferencesSchema;
-declare const index$b_TenantSchema: typeof TenantSchema;
-type index$b_TenantUpdate = TenantUpdate;
-declare const index$b_TenantUpdateSchema: typeof TenantUpdateSchema;
-declare namespace index$b {
-  export { Action$1 as Action, Endpoints$9 as Endpoints, type Tenant as Entity, type IAPI$a as IAPI, type index$b_Member as Member, index$b_MemberSchema as MemberSchema, type index$b_MemberUpdate as MemberUpdate, index$b_MemberUpdateSchema as MemberUpdateSchema, type index$b_Preferences as Preferences, index$b_PreferencesSchema as PreferencesSchema, index$b_TenantSchema as TenantSchema, type index$b_TenantUpdate as TenantUpdate, index$b_TenantUpdateSchema as TenantUpdateSchema };
+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 };
 }
 
 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$9 {
+interface IAPI$a {
     send: (t: Track) => Promise<boolean>;
 }
-declare const Endpoints$8: {
+declare const Endpoints$9: {
     Track: {
         uri: string;
         method: string;
     };
 };
 
-type index$a_TrackParam = TrackParam;
-declare const index$a_TrackParamSchema: typeof TrackParamSchema;
-declare const index$a_TrackSchema: typeof TrackSchema;
-declare namespace index$a {
-  export { Endpoints$8 as Endpoints, type Track as Entity, type IAPI$9 as IAPI, type index$a_TrackParam as TrackParam, index$a_TrackParamSchema as TrackParamSchema, index$a_TrackSchema as TrackSchema };
+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 };
 }
 
 declare const EmailSchema: z.ZodObject<{
@@ -1843,19 +1843,19 @@ declare const EmailSchema: z.ZodObject<{
 }>;
 type Email = z.infer<typeof EmailSchema>;
 
-interface IAPI$8 {
+interface IAPI$9 {
     send: (email: Email, ctx?: Context) => Promise<boolean>;
 }
-declare const Endpoints$7: {
+declare const Endpoints$8: {
     SendEmail: {
         uri: string;
         method: string;
     };
 };
 
-declare const index$9_EmailSchema: typeof EmailSchema;
-declare namespace index$9 {
-  export { index$9_EmailSchema as EmailSchema, Endpoints$7 as Endpoints, type Email as Entity, type IAPI$8 as IAPI };
+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 enum Status$1 {
@@ -2253,7 +2253,7 @@ type Feedback = z.infer<typeof FeedbackSchema>;
 type Rating = z.infer<typeof RatingSchema>;
 type RatingInput = Pick<Rating, "score" | "tags" | "comment">;
 
-interface IAPI$7 {
+interface IAPI$8 {
     reorder: (context: Context, projectId: string, position: number) => Promise<boolean>;
     find: (context: Context, projectId: string) => Promise<Project>;
     create: (context: Context, data: ProjectCreation) => Promise<Project>;
@@ -2279,7 +2279,7 @@ interface IAPI$7 {
         isEligibleForFreeProject(context: Context): Promise<boolean>;
     };
 }
-declare const Endpoints$6: {
+declare const Endpoints$7: {
     Reorder: {
         uri: string;
         method: string;
@@ -2406,31 +2406,31 @@ type StatusConfigType = {
 };
 declare const StatusConfig: Record<Status$1, StatusConfigType>;
 
-type index$8_Approve = Approve;
-type index$8_CaptionStyle = CaptionStyle;
-declare const index$8_CaptionStyle: typeof CaptionStyle;
-type index$8_Feedback = Feedback;
-declare const index$8_FeedbackSchema: typeof FeedbackSchema;
-type index$8_Interaction = Interaction;
-declare const index$8_InteractionSchema: typeof InteractionSchema;
-type index$8_InteractionType = InteractionType;
-declare const index$8_InteractionType: typeof InteractionType;
-type index$8_ProjectCreation = ProjectCreation;
-declare const index$8_ProjectSchema: typeof ProjectSchema;
-type index$8_Rating = Rating;
-type index$8_RatingInput = RatingInput;
-declare const index$8_RatingSchema: typeof RatingSchema;
-type index$8_RatingTag = RatingTag;
-declare const index$8_RatingTag: typeof RatingTag;
-type index$8_SendToApproval = SendToApproval;
-declare const index$8_StatusConfig: typeof StatusConfig;
-type index$8_StatusConfigType = StatusConfigType;
-type index$8_Style = Style;
-declare const index$8_Styles: typeof Styles;
-type index$8_TimelineItem = TimelineItem;
-declare const index$8_TimelineItemSchema: typeof TimelineItemSchema;
-declare namespace index$8 {
-  export { type index$8_Approve as Approve, index$8_CaptionStyle as CaptionStyle, Endpoints$6 as Endpoints, type Project as Entity, type index$8_Feedback as Feedback, index$8_FeedbackSchema as FeedbackSchema, type IAPI$7 as IAPI, type index$8_Interaction as Interaction, index$8_InteractionSchema as InteractionSchema, index$8_InteractionType as InteractionType, type index$8_ProjectCreation as ProjectCreation, index$8_ProjectSchema as ProjectSchema, type index$8_Rating as Rating, type index$8_RatingInput as RatingInput, index$8_RatingSchema as RatingSchema, index$8_RatingTag as RatingTag, type index$8_SendToApproval as SendToApproval, Status$1 as Status, index$8_StatusConfig as StatusConfig, type index$8_StatusConfigType as StatusConfigType, type index$8_Style as Style, index$8_Styles as Styles, type index$8_TimelineItem as TimelineItem, index$8_TimelineItemSchema as TimelineItemSchema };
+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_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_Style as Style, index$9_Styles as Styles, type index$9_TimelineItem as TimelineItem, index$9_TimelineItemSchema as TimelineItemSchema };
 }
 
 declare const DailyMilestoneSchema: z.ZodObject<{
@@ -2502,11 +2502,11 @@ declare const GoalSchema: z.ZodObject<{
 type DailyMilestone = z.infer<typeof DailyMilestoneSchema>;
 type Goal = z.infer<typeof GoalSchema>;
 
-interface IAPI$6 {
+interface IAPI$7 {
     getGoals: (context: Context) => Promise<Goal[]>;
     getEditorGoals: (context: Context, editorId: string) => Promise<Goal[]>;
 }
-declare const Endpoints$5: {
+declare const Endpoints$6: {
     GetGoals: {
         uri: string;
         method: string;
@@ -2517,11 +2517,11 @@ declare const Endpoints$5: {
     };
 };
 
-type index$7_DailyMilestone = DailyMilestone;
-declare const index$7_DailyMilestoneSchema: typeof DailyMilestoneSchema;
-declare const index$7_GoalSchema: typeof GoalSchema;
-declare namespace index$7 {
-  export { type index$7_DailyMilestone as DailyMilestone, index$7_DailyMilestoneSchema as DailyMilestoneSchema, Endpoints$5 as Endpoints, type Goal as Entity, index$7_GoalSchema as GoalSchema, type IAPI$6 as IAPI };
+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 };
 }
 
 declare const EditorSchema: z.ZodObject<{
@@ -2554,11 +2554,11 @@ declare const EditorSchema: z.ZodObject<{
 }>;
 type Editor = z.infer<typeof EditorSchema>;
 
-interface IAPI$5 {
+interface IAPI$6 {
     getAll(context: Context): Promise<Editor[]>;
     getById(context: Context, editorId: string): Promise<Editor>;
 }
-declare const Endpoints$4: {
+declare const Endpoints$5: {
     GetAll: {
         uri: string;
         method: string;
@@ -2569,9 +2569,9 @@ declare const Endpoints$4: {
     };
 };
 
-declare const index$6_EditorSchema: typeof EditorSchema;
-declare namespace index$6 {
-  export { index$6_EditorSchema as EditorSchema, Endpoints$4 as Endpoints, type Editor as Entity, type IAPI$5 as IAPI };
+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 enum Frequency {
@@ -3072,7 +3072,7 @@ type RecurrenceRule = z.infer<typeof RecurrenceRuleSchema>;
 type History = z.infer<typeof HistorySchema>;
 type Criteria = z.infer<typeof CriteriaSchema>;
 
-interface IAPI$4 {
+interface IAPI$5 {
     getTriggers: (ctx: Context) => Promise<APIResponse<Trigger>>;
     createTrigger: (ctx: Context, t: Trigger) => Promise<Trigger>;
     deleteTrigger: (ctx: Context, triggerId: string) => Promise<boolean>;
@@ -3082,7 +3082,7 @@ interface IAPI$4 {
     markAsRead: (ctx: Context, id: string) => Promise<boolean>;
     clearNotifications: (ctx: Context) => Promise<boolean>;
 }
-declare const Endpoints$3: {
+declare const Endpoints$4: {
     Create: {
         uri: string;
         method: string;
@@ -3117,35 +3117,35 @@ declare const Endpoints$3: {
     };
 };
 
-type index$5_Criteria = Criteria;
-declare const index$5_CriteriaSchema: typeof CriteriaSchema;
-type index$5_CriteriaType = CriteriaType;
-declare const index$5_CriteriaType: typeof CriteriaType;
-type index$5_Frequency = Frequency;
-declare const index$5_Frequency: typeof Frequency;
-type index$5_History = History;
-declare const index$5_HistorySchema: typeof HistorySchema;
-type index$5_NotificationDetail = NotificationDetail;
-declare const index$5_NotificationDetailSchema: typeof NotificationDetailSchema;
-type index$5_NotificationItem = NotificationItem;
-declare const index$5_NotificationItemSchema: typeof NotificationItemSchema;
-type index$5_NotificationType = NotificationType;
-declare const index$5_NotificationType: typeof NotificationType;
-type index$5_RecurrenceRule = RecurrenceRule;
-declare const index$5_RecurrenceRuleSchema: typeof RecurrenceRuleSchema;
-type index$5_Status = Status;
-declare const index$5_Status: typeof Status;
-type index$5_TransportType = TransportType;
-declare const index$5_TransportType: typeof TransportType;
-type index$5_Trigger = Trigger;
-declare const index$5_TriggerSchema: typeof TriggerSchema;
-type index$5_WeekDay = WeekDay;
-declare const index$5_WeekDay: typeof WeekDay;
-declare namespace index$5 {
-  export { type index$5_Criteria as Criteria, index$5_CriteriaSchema as CriteriaSchema, index$5_CriteriaType as CriteriaType, Endpoints$3 as Endpoints, index$5_Frequency as Frequency, type index$5_History as History, index$5_HistorySchema as HistorySchema, type IAPI$4 as IAPI, type index$5_NotificationDetail as NotificationDetail, index$5_NotificationDetailSchema as NotificationDetailSchema, type index$5_NotificationItem as NotificationItem, index$5_NotificationItemSchema as NotificationItemSchema, index$5_NotificationType as NotificationType, type index$5_RecurrenceRule as RecurrenceRule, index$5_RecurrenceRuleSchema as RecurrenceRuleSchema, index$5_Status as Status, index$5_TransportType as TransportType, type index$5_Trigger as Trigger, index$5_TriggerSchema as TriggerSchema, index$5_WeekDay as WeekDay };
+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 };
 }
 
-interface IAPI$3 {
+interface IAPI$4 {
     version: () => Promise<string>;
 }
 
@@ -3289,13 +3289,13 @@ declare const NoteSchema: z.ZodObject<{
 type Note = z.infer<typeof NoteSchema>;
 type NoteHistory = z.infer<typeof NoteHistorySchema>;
 
-interface IAPI$2 {
+interface IAPI$3 {
     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$2: {
+declare const Endpoints$3: {
     GetNotes: {
         uri: string;
         method: string;
@@ -3314,11 +3314,11 @@ declare const Endpoints$2: {
     };
 };
 
-type index$4_NoteHistory = NoteHistory;
-declare const index$4_NoteHistorySchema: typeof NoteHistorySchema;
-declare const index$4_NoteSchema: typeof NoteSchema;
-declare namespace index$4 {
-  export { Endpoints$2 as Endpoints, type Note as Entity, type IAPI$2 as IAPI, type index$4_NoteHistory as NoteHistory, index$4_NoteHistorySchema as NoteHistorySchema, index$4_NoteSchema as NoteSchema };
+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 };
 }
 
 declare const SpecialOfferSchema: z.ZodObject<{
@@ -3432,20 +3432,20 @@ declare const UpdateSpecialOfferSchema: z.ZodObject<{
 }>;
 type SpecialOffer = z.infer<typeof SpecialOfferSchema>;
 type UserOfferDetails = z.infer<typeof UserOfferDetailsSchema>;
-type Create = z.infer<typeof CreateSpecialOfferSchema>;
-type Update = z.infer<typeof UpdateSpecialOfferSchema>;
+type Create$1 = z.infer<typeof CreateSpecialOfferSchema>;
+type Update$1 = z.infer<typeof UpdateSpecialOfferSchema>;
 
-interface IAPI$1 {
+interface IAPI$2 {
     list: (ctx: Context) => Promise<SpecialOffer[]>;
     getActive: (ctx: Context) => Promise<SpecialOffer[]>;
-    create: (ctx: Context, data: Create) => Promise<SpecialOffer>;
-    update: (ctx: Context, id: string, data: Update) => Promise<void>;
+    create: (ctx: Context, data: Create$1) => Promise<SpecialOffer>;
+    update: (ctx: Context, id: string, data: Update$1) => Promise<void>;
     enable: (ctx: Context, id: string) => Promise<void>;
     disable: (ctx: Context, id: string) => Promise<void>;
     getMyOffer: (ctx: Context) => Promise<UserOfferDetails | null>;
     claim: (ctx: Context, callbackUrl?: string) => Promise<string>;
 }
-declare const Endpoints$1: {
+declare const Endpoints$2: {
     List: {
         uri: string;
         method: string;
@@ -3480,15 +3480,526 @@ declare const Endpoints$1: {
     };
 };
 
+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 };
+}
+
+/**
+ * The API stores session assets under a looser contract than the shared AssetSchema:
+ * type, authorId and uploadedAt are optional there, and a slide deck carries an empty
+ * thumbnailUrl, which is not a URL. Parsing those with the strict schema would throw
+ * on every read, so the differences are spelled out here.
+ */
+declare const SessionAssetSchema: z.ZodObject<{
+    assetId: z.ZodString;
+    fileName: z.ZodString;
+    extension: z.ZodString;
+    fileSize: z.ZodNumber;
+    duration: z.ZodOptional<z.ZodNumber>;
+    progress: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodOptional<z.ZodString>;
+} & {
+    assetUrl: z.ZodString;
+    thumbnailUrl: z.ZodString;
+    type: z.ZodOptional<z.ZodString>;
+    authorId: z.ZodOptional<z.ZodString>;
+    uploadedAt: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    assetId: string;
+    fileName: string;
+    extension: string;
+    fileSize: number;
+    assetUrl: string;
+    thumbnailUrl: string;
+    type?: string | undefined;
+    error?: string | undefined;
+    duration?: number | undefined;
+    progress?: number | undefined;
+    authorId?: string | undefined;
+    uploadedAt?: number | undefined;
+}, {
+    assetId: string;
+    fileName: string;
+    extension: string;
+    fileSize: number;
+    assetUrl: string;
+    thumbnailUrl: string;
+    type?: string | undefined;
+    error?: string | undefined;
+    duration?: number | undefined;
+    progress?: number | undefined;
+    authorId?: string | undefined;
+    uploadedAt?: number | undefined;
+}>;
+declare const ShredUSessionStatusSchema: z.ZodEnum<["scheduled", "cancelled"]>;
+declare const ShredUSessionSchema: z.ZodObject<{
+    id: z.ZodString;
+    topic: z.ZodString;
+    description: z.ZodString;
+    startsAt: z.ZodNumber;
+    durationMin: z.ZodNumber;
+    zoomUrl: z.ZodString;
+    status: z.ZodEnum<["scheduled", "cancelled"]>;
+    recordingId: z.ZodOptional<z.ZodString>;
+    recordingDurationSeconds: z.ZodOptional<z.ZodNumber>;
+    assets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        assetId: z.ZodString;
+        fileName: z.ZodString;
+        extension: z.ZodString;
+        fileSize: z.ZodNumber;
+        duration: z.ZodOptional<z.ZodNumber>;
+        progress: z.ZodOptional<z.ZodNumber>;
+        error: z.ZodOptional<z.ZodString>;
+    } & {
+        assetUrl: z.ZodString;
+        thumbnailUrl: z.ZodString;
+        type: z.ZodOptional<z.ZodString>;
+        authorId: z.ZodOptional<z.ZodString>;
+        uploadedAt: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        assetId: string;
+        fileName: string;
+        extension: string;
+        fileSize: number;
+        assetUrl: string;
+        thumbnailUrl: string;
+        type?: string | undefined;
+        error?: string | undefined;
+        duration?: number | undefined;
+        progress?: number | undefined;
+        authorId?: string | undefined;
+        uploadedAt?: number | undefined;
+    }, {
+        assetId: string;
+        fileName: string;
+        extension: string;
+        fileSize: number;
+        assetUrl: string;
+        thumbnailUrl: string;
+        type?: string | undefined;
+        error?: string | undefined;
+        duration?: number | undefined;
+        progress?: number | undefined;
+        authorId?: string | undefined;
+        uploadedAt?: number | undefined;
+    }>, "many">>;
+    tenantIds: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    status: "scheduled" | "cancelled";
+    description: string;
+    tenantIds: string[];
+    topic: string;
+    startsAt: number;
+    durationMin: number;
+    zoomUrl: string;
+    assets?: {
+        assetId: string;
+        fileName: string;
+        extension: string;
+        fileSize: number;
+        assetUrl: string;
+        thumbnailUrl: string;
+        type?: string | undefined;
+        error?: string | undefined;
+        duration?: number | undefined;
+        progress?: number | undefined;
+        authorId?: string | undefined;
+        uploadedAt?: number | undefined;
+    }[] | undefined;
+    recordingId?: string | undefined;
+    recordingDurationSeconds?: number | undefined;
+}, {
+    id: string;
+    status: "scheduled" | "cancelled";
+    description: string;
+    tenantIds: string[];
+    topic: string;
+    startsAt: number;
+    durationMin: number;
+    zoomUrl: string;
+    assets?: {
+        assetId: string;
+        fileName: string;
+        extension: string;
+        fileSize: number;
+        assetUrl: string;
+        thumbnailUrl: string;
+        type?: string | undefined;
+        error?: string | undefined;
+        duration?: number | undefined;
+        progress?: number | undefined;
+        authorId?: string | undefined;
+        uploadedAt?: number | undefined;
+    }[] | undefined;
+    recordingId?: string | undefined;
+    recordingDurationSeconds?: number | undefined;
+}>;
+/** Subscriber-facing endpoints answer without the Zoom link, nor who else it is for. */
+declare const ShredUSessionCustomerSchema: z.ZodObject<Omit<{
+    id: z.ZodString;
+    topic: z.ZodString;
+    description: z.ZodString;
+    startsAt: z.ZodNumber;
+    durationMin: z.ZodNumber;
+    zoomUrl: z.ZodString;
+    status: z.ZodEnum<["scheduled", "cancelled"]>;
+    recordingId: z.ZodOptional<z.ZodString>;
+    recordingDurationSeconds: z.ZodOptional<z.ZodNumber>;
+    assets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        assetId: z.ZodString;
+        fileName: z.ZodString;
+        extension: z.ZodString;
+        fileSize: z.ZodNumber;
+        duration: z.ZodOptional<z.ZodNumber>;
+        progress: z.ZodOptional<z.ZodNumber>;
+        error: z.ZodOptional<z.ZodString>;
+    } & {
+        assetUrl: z.ZodString;
+        thumbnailUrl: z.ZodString;
+        type: z.ZodOptional<z.ZodString>;
+        authorId: z.ZodOptional<z.ZodString>;
+        uploadedAt: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        assetId: string;
+        fileName: string;
+        extension: string;
+        fileSize: number;
+        assetUrl: string;
+        thumbnailUrl: string;
+        type?: string | undefined;
+        error?: string | undefined;
+        duration?: number | undefined;
+        progress?: number | undefined;
+        authorId?: string | undefined;
+        uploadedAt?: number | undefined;
+    }, {
+        assetId: string;
+        fileName: string;
+        extension: string;
+        fileSize: number;
+        assetUrl: string;
+        thumbnailUrl: string;
+        type?: string | undefined;
+        error?: string | undefined;
+        duration?: number | undefined;
+        progress?: number | undefined;
+        authorId?: string | undefined;
+        uploadedAt?: number | undefined;
+    }>, "many">>;
+    tenantIds: z.ZodArray<z.ZodString, "many">;
+}, "tenantIds" | "zoomUrl">, "strip", z.ZodTypeAny, {
+    id: string;
+    status: "scheduled" | "cancelled";
+    description: string;
+    topic: string;
+    startsAt: number;
+    durationMin: number;
+    assets?: {
+        assetId: string;
+        fileName: string;
+        extension: string;
+        fileSize: number;
+        assetUrl: string;
+        thumbnailUrl: string;
+        type?: string | undefined;
+        error?: string | undefined;
+        duration?: number | undefined;
+        progress?: number | undefined;
+        authorId?: string | undefined;
+        uploadedAt?: number | undefined;
+    }[] | undefined;
+    recordingId?: string | undefined;
+    recordingDurationSeconds?: number | undefined;
+}, {
+    id: string;
+    status: "scheduled" | "cancelled";
+    description: string;
+    topic: string;
+    startsAt: number;
+    durationMin: number;
+    assets?: {
+        assetId: string;
+        fileName: string;
+        extension: string;
+        fileSize: number;
+        assetUrl: string;
+        thumbnailUrl: string;
+        type?: string | undefined;
+        error?: string | undefined;
+        duration?: number | undefined;
+        progress?: number | undefined;
+        authorId?: string | undefined;
+        uploadedAt?: number | undefined;
+    }[] | undefined;
+    recordingId?: string | undefined;
+    recordingDurationSeconds?: number | undefined;
+}>;
+declare const CreateShredUSessionSchema: z.ZodObject<{
+    topic: z.ZodString;
+    description: z.ZodString;
+    startsAt: z.ZodNumber;
+    durationMin: z.ZodNumber;
+    zoomUrl: z.ZodString;
+    assets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        assetId: z.ZodString;
+        fileName: z.ZodString;
+        extension: z.ZodString;
+        fileSize: z.ZodNumber;
+        duration: z.ZodOptional<z.ZodNumber>;
+        progress: z.ZodOptional<z.ZodNumber>;
+        error: z.ZodOptional<z.ZodString>;
+    } & {
+        assetUrl: z.ZodString;
+        thumbnailUrl: z.ZodString;
+        type: z.ZodOptional<z.ZodString>;
+        authorId: z.ZodOptional<z.ZodString>;
+        uploadedAt: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        assetId: string;
+        fileName: string;
+        extension: string;
+        fileSize: number;
+        assetUrl: string;
+        thumbnailUrl: string;
+        type?: string | undefined;
+        error?: string | undefined;
+        duration?: number | undefined;
+        progress?: number | undefined;
+        authorId?: string | undefined;
+        uploadedAt?: number | undefined;
+    }, {
+        assetId: string;
+        fileName: string;
+        extension: string;
+        fileSize: number;
+        assetUrl: string;
+        thumbnailUrl: string;
+        type?: string | undefined;
+        error?: string | undefined;
+        duration?: number | undefined;
+        progress?: number | undefined;
+        authorId?: string | undefined;
+        uploadedAt?: number | undefined;
+    }>, "many">>;
+    tenantIds: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    tenantIds: string[];
+    topic: string;
+    startsAt: number;
+    durationMin: number;
+    zoomUrl: string;
+    assets?: {
+        assetId: string;
+        fileName: string;
+        extension: string;
+        fileSize: number;
+        assetUrl: string;
+        thumbnailUrl: string;
+        type?: string | undefined;
+        error?: string | undefined;
+        duration?: number | undefined;
+        progress?: number | undefined;
+        authorId?: string | undefined;
+        uploadedAt?: number | undefined;
+    }[] | undefined;
+}, {
+    description: string;
+    tenantIds: string[];
+    topic: string;
+    startsAt: number;
+    durationMin: number;
+    zoomUrl: string;
+    assets?: {
+        assetId: string;
+        fileName: string;
+        extension: string;
+        fileSize: number;
+        assetUrl: string;
+        thumbnailUrl: string;
+        type?: string | undefined;
+        error?: string | undefined;
+        duration?: number | undefined;
+        progress?: number | undefined;
+        authorId?: string | undefined;
+        uploadedAt?: number | undefined;
+    }[] | undefined;
+}>;
+declare const UpdateShredUSessionSchema: z.ZodObject<{
+    topic: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    startsAt: z.ZodOptional<z.ZodNumber>;
+    durationMin: z.ZodOptional<z.ZodNumber>;
+    zoomUrl: z.ZodOptional<z.ZodString>;
+    assets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        assetId: z.ZodString;
+        fileName: z.ZodString;
+        extension: z.ZodString;
+        fileSize: z.ZodNumber;
+        duration: z.ZodOptional<z.ZodNumber>;
+        progress: z.ZodOptional<z.ZodNumber>;
+        error: z.ZodOptional<z.ZodString>;
+    } & {
+        assetUrl: z.ZodString;
+        thumbnailUrl: z.ZodString;
+        type: z.ZodOptional<z.ZodString>;
+        authorId: z.ZodOptional<z.ZodString>;
+        uploadedAt: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        assetId: string;
+        fileName: string;
+        extension: string;
+        fileSize: number;
+        assetUrl: string;
+        thumbnailUrl: string;
+        type?: string | undefined;
+        error?: string | undefined;
+        duration?: number | undefined;
+        progress?: number | undefined;
+        authorId?: string | undefined;
+        uploadedAt?: number | undefined;
+    }, {
+        assetId: string;
+        fileName: string;
+        extension: string;
+        fileSize: number;
+        assetUrl: string;
+        thumbnailUrl: string;
+        type?: string | undefined;
+        error?: string | undefined;
+        duration?: number | undefined;
+        progress?: number | undefined;
+        authorId?: string | undefined;
+        uploadedAt?: number | undefined;
+    }>, "many">>;
+    tenantIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    description?: string | undefined;
+    tenantIds?: string[] | undefined;
+    assets?: {
+        assetId: string;
+        fileName: string;
+        extension: string;
+        fileSize: number;
+        assetUrl: string;
+        thumbnailUrl: string;
+        type?: string | undefined;
+        error?: string | undefined;
+        duration?: number | undefined;
+        progress?: number | undefined;
+        authorId?: string | undefined;
+        uploadedAt?: number | undefined;
+    }[] | undefined;
+    topic?: string | undefined;
+    startsAt?: number | undefined;
+    durationMin?: number | undefined;
+    zoomUrl?: string | undefined;
+}, {
+    description?: string | undefined;
+    tenantIds?: string[] | undefined;
+    assets?: {
+        assetId: string;
+        fileName: string;
+        extension: string;
+        fileSize: number;
+        assetUrl: string;
+        thumbnailUrl: string;
+        type?: string | undefined;
+        error?: string | undefined;
+        duration?: number | undefined;
+        progress?: number | undefined;
+        authorId?: string | undefined;
+        uploadedAt?: number | undefined;
+    }[] | undefined;
+    topic?: string | undefined;
+    startsAt?: number | undefined;
+    durationMin?: number | undefined;
+    zoomUrl?: string | undefined;
+}>;
+declare const SetShredUSessionRecordingSchema: z.ZodObject<{
+    recordingId: z.ZodString;
+    recordingDurationSeconds: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    recordingId: string;
+    recordingDurationSeconds: number;
+}, {
+    recordingId: string;
+    recordingDurationSeconds: number;
+}>;
+type SessionAsset = z.infer<typeof SessionAssetSchema>;
+type ShredUSessionStatus = z.infer<typeof ShredUSessionStatusSchema>;
+type ShredUSession = z.infer<typeof ShredUSessionSchema>;
+type ShredUSessionCustomer = z.infer<typeof ShredUSessionCustomerSchema>;
+type Create = z.infer<typeof CreateShredUSessionSchema>;
+type Update = z.infer<typeof UpdateShredUSessionSchema>;
+type SetRecording = z.infer<typeof SetShredUSessionRecordingSchema>;
+
+interface IAPI$1 {
+    list: (ctx: Context) => Promise<ShredUSession[]>;
+    getUpcoming: (ctx: Context) => Promise<ShredUSessionCustomer[]>;
+    getLibrary: (ctx: Context) => Promise<ShredUSessionCustomer[]>;
+    get: (ctx: Context, id: string) => Promise<ShredUSessionCustomer>;
+    create: (ctx: Context, data: Create) => Promise<ShredUSession>;
+    update: (ctx: Context, id: string, data: Update) => Promise<void>;
+    cancel: (ctx: Context, id: string) => Promise<void>;
+    setRecording: (ctx: Context, id: string, data: SetRecording) => Promise<void>;
+}
+declare const Endpoints$1: {
+    List: {
+        uri: string;
+        method: string;
+    };
+    GetUpcoming: {
+        uri: string;
+        method: string;
+    };
+    GetLibrary: {
+        uri: string;
+        method: string;
+    };
+    Get: {
+        uri: string;
+        method: string;
+    };
+    Create: {
+        uri: string;
+        method: string;
+    };
+    Update: {
+        uri: string;
+        method: string;
+    };
+    Cancel: {
+        uri: string;
+        method: string;
+    };
+    SetRecording: {
+        uri: string;
+        method: string;
+    };
+};
+
 type index$3_Create = Create;
-declare const index$3_CreateSpecialOfferSchema: typeof CreateSpecialOfferSchema;
-declare const index$3_SpecialOfferSchema: typeof SpecialOfferSchema;
+declare const index$3_CreateShredUSessionSchema: typeof CreateShredUSessionSchema;
+type index$3_SessionAsset = SessionAsset;
+declare const index$3_SessionAssetSchema: typeof SessionAssetSchema;
+type index$3_SetRecording = SetRecording;
+declare const index$3_SetShredUSessionRecordingSchema: typeof SetShredUSessionRecordingSchema;
+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_UpdateSpecialOfferSchema: typeof UpdateSpecialOfferSchema;
-type index$3_UserOfferDetails = UserOfferDetails;
-declare const index$3_UserOfferDetailsSchema: typeof UserOfferDetailsSchema;
+declare const index$3_UpdateShredUSessionSchema: typeof UpdateShredUSessionSchema;
 declare namespace index$3 {
-  export { type index$3_Create as Create, index$3_CreateSpecialOfferSchema as CreateSpecialOfferSchema, Endpoints$1 as Endpoints, type SpecialOffer as Entity, type IAPI$1 as IAPI, index$3_SpecialOfferSchema as SpecialOfferSchema, type index$3_Update as Update, index$3_UpdateSpecialOfferSchema as UpdateSpecialOfferSchema, type index$3_UserOfferDetails as UserOfferDetails, index$3_UserOfferDetailsSchema as UserOfferDetailsSchema };
+  export { type index$3_Create as Create, index$3_CreateShredUSessionSchema as CreateShredUSessionSchema, Endpoints$1 as Endpoints, type ShredUSession as Entity, type IAPI$1 as IAPI, type index$3_SessionAsset as SessionAsset, index$3_SessionAssetSchema as SessionAssetSchema, type index$3_SetRecording as SetRecording, index$3_SetShredUSessionRecordingSchema as SetShredUSessionRecordingSchema, 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 };
 }
 
 /**
@@ -3852,19 +4363,20 @@ declare namespace index$2 {
 }
 
 declare class ShredAPI {
-    user: IAPI$b;
-    goal: IAPI$6;
-    editor: IAPI$5;
-    subscription: IAPI$c;
-    prompt: IAPI$d;
-    pushNotification: IAPI$4;
-    email: IAPI$8;
-    tenant: IAPI$a;
-    app: IAPI$3;
-    project: IAPI$7;
-    track: IAPI$9;
-    note: IAPI$2;
-    specialOffer: IAPI$1;
+    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;
     rbac: IAPI;
     constructor(env: Environment);
 }
@@ -3957,4 +4469,4 @@ declare namespace index {
   export { index_AssetSchema as AssetSchema, type Asset as Entity };
 }
 
-export { index as Asset, index$d as Core, index$6 as Editor, index$9 as Email, index$1 as Exceptions, index$7 as Goal, index$4 as Note, index$5 as Notification, index$8 as Project, index$f as Prompt, index$2 as RBAC, ShredAPI, index$3 as SpecialOffer, index$e as Subscription, index$b as Tenant, index$a as Track, index$c as User, ShredAPI as default };
+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 };