shred-api-client 2.4.14 → 2.5.0

package/dist/index.d.ts

@@ -197,7 +197,7 @@ type Context = {
     requestId?: string;
 };
 
-interface IAPI$a {
+interface IAPI$b {
     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$a {
     generateScript: (c: Context, data: ScriptIARequest) => Promise<string>;
     updateScript: (c: Context, id: string, script: Partial<Script>) => Promise<boolean>;
 }
-declare const Endpoints$9: {
+declare const Endpoints$a: {
     GetPrompt: {
         uri: string;
         method: string;
@@ -232,15 +232,15 @@ declare const Endpoints$9: {
     };
 };
 
-type index$c_Category = Category;
-declare const index$c_CategorySchema: typeof CategorySchema;
-declare const index$c_PromptSchema: typeof PromptSchema;
-type index$c_Script = Script;
-type index$c_ScriptIARequest = ScriptIARequest;
-declare const index$c_ScriptIARequestSchema: typeof ScriptIARequestSchema;
-declare const index$c_ScriptSchema: typeof ScriptSchema;
-declare namespace index$c {
-  export { type index$c_Category as Category, index$c_CategorySchema as CategorySchema, Endpoints$9 as Endpoints, type Prompt as Entity, type IAPI$a as IAPI, index$c_PromptSchema as PromptSchema, type index$c_Script as Script, type index$c_ScriptIARequest as ScriptIARequest, index$c_ScriptIARequestSchema as ScriptIARequestSchema, index$c_ScriptSchema as ScriptSchema };
+type index$d_Category = Category;
+declare const index$d_CategorySchema: typeof CategorySchema;
+declare const index$d_PromptSchema: typeof PromptSchema;
+type index$d_Script = Script;
+type index$d_ScriptIARequest = ScriptIARequest;
+declare const index$d_ScriptIARequestSchema: typeof ScriptIARequestSchema;
+declare const index$d_ScriptSchema: typeof ScriptSchema;
+declare namespace index$d {
+  export { type index$d_Category as Category, index$d_CategorySchema as CategorySchema, Endpoints$a as Endpoints, type Prompt as Entity, type IAPI$b as IAPI, index$d_PromptSchema as PromptSchema, type index$d_Script as Script, type index$d_ScriptIARequest as ScriptIARequest, index$d_ScriptIARequestSchema as ScriptIARequestSchema, index$d_ScriptSchema as ScriptSchema };
 }
 
 declare enum Type {
@@ -270,34 +270,6 @@ declare const PlanSchema: z.ZodObject<{
     currency: string;
     subscriptionItemId: string;
 }>;
-declare const SpecialOfferSchema: z.ZodObject<{
-    id: z.ZodString;
-    freeProjectsAllowed: z.ZodDefault<z.ZodNumber>;
-    windowHours: z.ZodNumber;
-    couponId: z.ZodString;
-    title: z.ZodString;
-    description: z.ZodString;
-    ctaLabel: z.ZodString;
-    enabled: z.ZodDefault<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    title: string;
-    description: string;
-    freeProjectsAllowed: number;
-    windowHours: number;
-    couponId: string;
-    ctaLabel: string;
-    enabled: boolean;
-}, {
-    id: string;
-    title: string;
-    description: string;
-    windowHours: number;
-    couponId: string;
-    ctaLabel: string;
-    freeProjectsAllowed?: number | undefined;
-    enabled?: boolean | undefined;
-}>;
 declare const ProductSchema: z.ZodObject<{
     id: z.ZodString;
     name: z.ZodString;
@@ -595,13 +567,12 @@ declare const SubscriptionSummarySchema: z.ZodObject<{
     productName: string;
 }>;
 type Subscription = z.infer<typeof SubscriptionSchema>;
-type SpecialOffer = z.infer<typeof SpecialOfferSchema>;
 type SubscriptionSummary = z.infer<typeof SubscriptionSummarySchema>;
 type Charge = z.infer<typeof ChargeSchema>;
 type Plan = z.infer<typeof PlanSchema>;
 type Product = z.infer<typeof ProductSchema>;
 
-interface IAPI$9 {
+interface IAPI$a {
     getCharges: (ctx: Context) => Promise<Charge[]>;
     getPortalUrl: (ctx: Context) => Promise<string>;
     getSubscription: (context: Context, userId?: string) => Promise<Subscription | null>;
@@ -613,9 +584,8 @@ interface IAPI$9 {
     updatePlan: (ctx: Context, planId: string) => Promise<boolean>;
     createCheckout: (planId: string | null, ctx: Context, callbackUrl?: string) => Promise<string>;
     getSubscriptionsSummary: (ctx: Context) => Promise<SubscriptionSummary[]>;
-    getSpecialOffer: (ctx: Context) => Promise<SpecialOffer | null>;
 }
-declare const Endpoints$8: {
+declare const Endpoints$9: {
     GetPortal: {
         uri: string;
         method: string;
@@ -628,10 +598,6 @@ declare const Endpoints$8: {
         uri: string;
         method: string;
     };
-    GetSpecialOffer: {
-        uri: string;
-        method: string;
-    };
     GetCharges: {
         uri: string;
         method: string;
@@ -674,19 +640,18 @@ declare const Endpoints$8: {
     };
 };
 
-type index$b_Charge = Charge;
-declare const index$b_ChargeSchema: typeof ChargeSchema;
-type index$b_Plan = Plan;
-declare const index$b_PlanSchema: typeof PlanSchema;
-type index$b_Product = Product;
-declare const index$b_ProductSchema: typeof ProductSchema;
-type index$b_SpecialOffer = SpecialOffer;
-declare const index$b_SubscriptionSchema: typeof SubscriptionSchema;
-declare const index$b_SubscriptionTypeSchema: typeof SubscriptionTypeSchema;
-type index$b_Type = Type;
-declare const index$b_Type: typeof Type;
-declare namespace index$b {
-  export { type index$b_Charge as Charge, index$b_ChargeSchema as ChargeSchema, Endpoints$8 as Endpoints, type Subscription as Entity, type IAPI$9 as IAPI, type index$b_Plan as Plan, index$b_PlanSchema as PlanSchema, type index$b_Product as Product, index$b_ProductSchema as ProductSchema, type index$b_SpecialOffer as SpecialOffer, index$b_SubscriptionSchema as SubscriptionSchema, index$b_SubscriptionTypeSchema as SubscriptionTypeSchema, type SubscriptionSummary as Summary, index$b_Type as Type };
+type index$c_Charge = Charge;
+declare const index$c_ChargeSchema: typeof ChargeSchema;
+type index$c_Plan = Plan;
+declare const index$c_PlanSchema: typeof PlanSchema;
+type index$c_Product = Product;
+declare const index$c_ProductSchema: typeof ProductSchema;
+declare const index$c_SubscriptionSchema: typeof SubscriptionSchema;
+declare const index$c_SubscriptionTypeSchema: typeof SubscriptionTypeSchema;
+type index$c_Type = Type;
+declare const index$c_Type: typeof Type;
+declare namespace index$c {
+  export { type index$c_Charge as Charge, index$c_ChargeSchema as ChargeSchema, Endpoints$9 as Endpoints, type Subscription as Entity, type IAPI$a as IAPI, type index$c_Plan as Plan, index$c_PlanSchema as PlanSchema, type index$c_Product as Product, index$c_ProductSchema as ProductSchema, index$c_SubscriptionSchema as SubscriptionSchema, index$c_SubscriptionTypeSchema as SubscriptionTypeSchema, type SubscriptionSummary as Summary, index$c_Type as Type };
 }
 
 declare enum Role {
@@ -843,8 +808,8 @@ declare const UserSchema: z.ZodObject<{
 }>;
 type User = z.infer<typeof UserSchema>;
 type Preferences$1 = z.infer<typeof PreferencesSchema$1>;
-type Update = Pick<User, "name" | "profession" | "preferences" | "photoUrl" | "fcmToken" | "timezone" | "experienceId">;
-type Create = Pick<User, "name" | "email"> & {
+type Update$1 = Pick<User, "name" | "profession" | "preferences" | "photoUrl" | "fcmToken" | "timezone" | "experienceId">;
+type Create$1 = Pick<User, "name" | "email"> & {
     password?: string;
     passwordConfirmation?: string;
     invitationCode?: string;
@@ -879,16 +844,16 @@ type APIResponse<T> = {
     perPage?: number;
 };
 
-type index$a_APIResponse<T> = APIResponse<T>;
-type index$a_QueryFilterOp = QueryFilterOp;
-type index$a_QueryOptions<T> = QueryOptions<T>;
-type index$a_QueryOrderBy<T> = QueryOrderBy<T>;
-type index$a_QueryWhere<T> = QueryWhere<T>;
-declare namespace index$a {
-  export type { index$a_APIResponse as APIResponse, index$a_QueryFilterOp as QueryFilterOp, index$a_QueryOptions as QueryOptions, index$a_QueryOrderBy as QueryOrderBy, index$a_QueryWhere as QueryWhere };
+type index$b_APIResponse<T> = APIResponse<T>;
+type index$b_QueryFilterOp = QueryFilterOp;
+type index$b_QueryOptions<T> = QueryOptions<T>;
+type index$b_QueryOrderBy<T> = QueryOrderBy<T>;
+type index$b_QueryWhere<T> = QueryWhere<T>;
+declare namespace index$b {
+  export type { index$b_APIResponse as APIResponse, index$b_QueryFilterOp as QueryFilterOp, index$b_QueryOptions as QueryOptions, index$b_QueryOrderBy as QueryOrderBy, index$b_QueryWhere as QueryWhere };
 }
 
-interface IAPI$8 {
+interface IAPI$9 {
     getUserInfo: (context: Context) => Promise<User>;
     isEmailAvaliable: (email: string) => Promise<boolean>;
     sendValidationCode: (email: string) => Promise<boolean>;
@@ -896,16 +861,16 @@ interface IAPI$8 {
     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) => Promise<string>;
-    update: (context: Context, update: Partial<Update>) => Promise<boolean>;
+    update: (context: Context, update: Partial<Update$1>) => 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) => Promise<User>;
+    createUser: (data: Create$1) => Promise<User>;
 }
-declare const Endpoints$7: {
+declare const Endpoints$8: {
     ChangeEmail: {
         uri: string;
         method: string;
@@ -972,15 +937,13 @@ declare const Endpoints$7: {
     };
 };
 
-type index$9_Create = Create;
-type index$9_Role = Role;
-declare const index$9_Role: typeof Role;
-type index$9_System = System;
-declare const index$9_System: typeof System;
-type index$9_Update = Update;
-declare const index$9_UserSchema: typeof UserSchema;
-declare namespace index$9 {
-  export { type index$9_Create as Create, Endpoints$7 as Endpoints, type User as Entity, type IAPI$8 as IAPI, type Preferences$1 as Preferences, PreferencesSchema$1 as PreferencesSchema, index$9_Role as Role, index$9_System as System, type index$9_Update as Update, index$9_UserSchema as UserSchema };
+type index$a_Role = Role;
+declare const index$a_Role: typeof Role;
+type index$a_System = System;
+declare const index$a_System: typeof System;
+declare const index$a_UserSchema: typeof UserSchema;
+declare namespace index$a {
+  export { type Create$1 as Create, Endpoints$8 as Endpoints, type User as Entity, type IAPI$9 as IAPI, type Preferences$1 as Preferences, PreferencesSchema$1 as PreferencesSchema, index$a_Role as Role, index$a_System as System, type Update$1 as Update, index$a_UserSchema as UserSchema };
 }
 
 declare const PreferencesSchema: z.ZodObject<{
@@ -1362,6 +1325,8 @@ declare const TenantSchema: z.ZodObject<{
     }>>>;
     totalSubscriptions: z.ZodOptional<z.ZodNumber>;
     totalUsers: z.ZodOptional<z.ZodNumber>;
+    reportUrl: z.ZodOptional<z.ZodString>;
+    reportViewers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
     id: string;
     name: string;
@@ -1438,6 +1403,8 @@ declare const TenantSchema: z.ZodObject<{
     } | undefined;
     totalSubscriptions?: number | undefined;
     totalUsers?: number | undefined;
+    reportUrl?: string | undefined;
+    reportViewers?: string[] | undefined;
 }, {
     id: string;
     name: string;
@@ -1514,6 +1481,8 @@ declare const TenantSchema: z.ZodObject<{
     } | undefined;
     totalSubscriptions?: number | undefined;
     totalUsers?: number | undefined;
+    reportUrl?: string | undefined;
+    reportViewers?: string[] | undefined;
 }>;
 declare const MemberSchema: z.ZodObject<{
     name: z.ZodString;
@@ -1531,19 +1500,35 @@ declare const MemberSchema: z.ZodObject<{
     name: string;
     isActive: boolean;
 }>;
+declare enum Action {
+    ADD = "add",
+    REMOVE = "remove"
+}
+declare const ReportViewerUpdateSchema: z.ZodObject<{
+    userId: z.ZodString;
+    action: z.ZodNativeEnum<typeof Action>;
+}, "strip", z.ZodTypeAny, {
+    userId: string;
+    action: Action;
+}, {
+    userId: string;
+    action: Action;
+}>;
+type ReportViewerUpdate = z.infer<typeof ReportViewerUpdateSchema>;
 type Tenant = z.infer<typeof TenantSchema>;
 type Member = z.infer<typeof MemberSchema>;
 type Preferences = z.infer<typeof PreferencesSchema>;
 
-interface IAPI$7 {
+interface IAPI$8 {
     getByInviteCode: (code: string, context?: Context) => Promise<Tenant | null>;
     create: (tenant: Tenant, context: Context) => Promise<boolean>;
     list: (context: Context) => Promise<Tenant[]>;
     getTenant: (context: Context, tenantId?: string) => Promise<Tenant | null>;
     getMembers: (context: Context, tenantId: string) => Promise<Member[]>;
     update: (tenantId: string, data: Pick<Tenant, "preferences">, context: Context) => Promise<boolean>;
+    updateReportViewers: (tenantId: string, reportViewerUpdate: ReportViewerUpdate, context: Context) => Promise<boolean>;
 }
-declare const Endpoints$6: {
+declare const Endpoints$7: {
     GetByInviteCode: {
         uri: string;
         method: string;
@@ -1572,15 +1557,23 @@ declare const Endpoints$6: {
         uri: string;
         method: string;
     };
+    UpdateReportViewers: {
+        uri: string;
+        method: string;
+    };
 };
 
-type index$8_Member = Member;
-declare const index$8_MemberSchema: typeof MemberSchema;
-type index$8_Preferences = Preferences;
-declare const index$8_PreferencesSchema: typeof PreferencesSchema;
-declare const index$8_TenantSchema: typeof TenantSchema;
-declare namespace index$8 {
-  export { Endpoints$6 as Endpoints, type Tenant as Entity, type IAPI$7 as IAPI, type index$8_Member as Member, index$8_MemberSchema as MemberSchema, type index$8_Preferences as Preferences, index$8_PreferencesSchema as PreferencesSchema, index$8_TenantSchema as TenantSchema };
+type index$9_Action = Action;
+declare const index$9_Action: typeof Action;
+type index$9_Member = Member;
+declare const index$9_MemberSchema: typeof MemberSchema;
+type index$9_Preferences = Preferences;
+declare const index$9_PreferencesSchema: typeof PreferencesSchema;
+type index$9_ReportViewerUpdate = ReportViewerUpdate;
+declare const index$9_ReportViewerUpdateSchema: typeof ReportViewerUpdateSchema;
+declare const index$9_TenantSchema: typeof TenantSchema;
+declare namespace index$9 {
+  export { index$9_Action as Action, Endpoints$7 as Endpoints, type Tenant as Entity, type IAPI$8 as IAPI, type index$9_Member as Member, index$9_MemberSchema as MemberSchema, type index$9_Preferences as Preferences, index$9_PreferencesSchema as PreferencesSchema, type index$9_ReportViewerUpdate as ReportViewerUpdate, index$9_ReportViewerUpdateSchema as ReportViewerUpdateSchema, index$9_TenantSchema as TenantSchema };
 }
 
 declare const TrackParamSchema: z.ZodObject<{
@@ -1609,16 +1602,16 @@ declare const TrackSchema: z.ZodObject<{
     }>, "many">>;
 }, "strip", z.ZodTypeAny, {
     label: string;
-    category: string;
     action: string;
+    category: string;
     params?: {
         value: string | number;
         name: string;
     }[] | undefined;
 }, {
     label: string;
-    category: string;
     action: string;
+    category: string;
     params?: {
         value: string | number;
         name: string;
@@ -1627,21 +1620,21 @@ declare const TrackSchema: z.ZodObject<{
 type Track = z.infer<typeof TrackSchema>;
 type TrackParam = z.infer<typeof TrackParamSchema>;
 
-interface IAPI$6 {
+interface IAPI$7 {
     send: (t: Track) => Promise<boolean>;
 }
-declare const Endpoints$5: {
+declare const Endpoints$6: {
     Track: {
         uri: string;
         method: string;
     };
 };
 
-type index$7_TrackParam = TrackParam;
-declare const index$7_TrackParamSchema: typeof TrackParamSchema;
-declare const index$7_TrackSchema: typeof TrackSchema;
-declare namespace index$7 {
-  export { Endpoints$5 as Endpoints, type Track as Entity, type IAPI$6 as IAPI, type index$7_TrackParam as TrackParam, index$7_TrackParamSchema as TrackParamSchema, index$7_TrackSchema as TrackSchema };
+type index$8_TrackParam = TrackParam;
+declare const index$8_TrackParamSchema: typeof TrackParamSchema;
+declare const index$8_TrackSchema: typeof TrackSchema;
+declare namespace index$8 {
+  export { Endpoints$6 as Endpoints, type Track as Entity, type IAPI$7 as IAPI, type index$8_TrackParam as TrackParam, index$8_TrackParamSchema as TrackParamSchema, index$8_TrackSchema as TrackSchema };
 }
 
 declare const EmailSchema: z.ZodObject<{
@@ -1659,19 +1652,19 @@ declare const EmailSchema: z.ZodObject<{
 }>;
 type Email = z.infer<typeof EmailSchema>;
 
-interface IAPI$5 {
+interface IAPI$6 {
     send: (email: Email, ctx?: Context) => Promise<boolean>;
 }
-declare const Endpoints$4: {
+declare const Endpoints$5: {
     SendEmail: {
         uri: string;
         method: string;
     };
 };
 
-declare const index$6_EmailSchema: typeof EmailSchema;
-declare namespace index$6 {
-  export { index$6_EmailSchema as EmailSchema, Endpoints$4 as Endpoints, type Email as Entity, type IAPI$5 as IAPI };
+declare const index$7_EmailSchema: typeof EmailSchema;
+declare namespace index$7 {
+  export { index$7_EmailSchema as EmailSchema, Endpoints$5 as Endpoints, type Email as Entity, type IAPI$6 as IAPI };
 }
 
 declare enum Status$1 {
@@ -1971,7 +1964,7 @@ type Project = z.infer<typeof ProjectSchema>;
 type TimelineItem = z.infer<typeof TimelineItemSchema>;
 type Feedback = z.infer<typeof FeedbackSchema>;
 
-interface IAPI$4 {
+interface IAPI$5 {
     reorder: (context: Context, projectId: string, position: number) => Promise<boolean>;
     find: (context: Context, projectId: string) => Promise<Project>;
     create: (context: Context, data: ProjectCreation) => Promise<Project>;
@@ -1992,7 +1985,7 @@ interface IAPI$4 {
         isEligibleForFreeProject(context: Context): Promise<boolean>;
     };
 }
-declare const Endpoints$3: {
+declare const Endpoints$4: {
     Reorder: {
         uri: string;
         method: string;
@@ -2099,22 +2092,22 @@ type StatusConfigType = {
 };
 declare const StatusConfig: Record<Status$1, StatusConfigType>;
 
-type index$5_Approve = Approve;
-type index$5_CaptionStyle = CaptionStyle;
-declare const index$5_CaptionStyle: typeof CaptionStyle;
-type index$5_Feedback = Feedback;
-declare const index$5_FeedbackSchema: typeof FeedbackSchema;
-type index$5_ProjectCreation = ProjectCreation;
-declare const index$5_ProjectSchema: typeof ProjectSchema;
-type index$5_SendToApproval = SendToApproval;
-declare const index$5_StatusConfig: typeof StatusConfig;
-type index$5_StatusConfigType = StatusConfigType;
-type index$5_Style = Style;
-declare const index$5_Styles: typeof Styles;
-type index$5_TimelineItem = TimelineItem;
-declare const index$5_TimelineItemSchema: typeof TimelineItemSchema;
-declare namespace index$5 {
-  export { type index$5_Approve as Approve, index$5_CaptionStyle as CaptionStyle, Endpoints$3 as Endpoints, type Project as Entity, type index$5_Feedback as Feedback, index$5_FeedbackSchema as FeedbackSchema, type IAPI$4 as IAPI, type index$5_ProjectCreation as ProjectCreation, index$5_ProjectSchema as ProjectSchema, type index$5_SendToApproval as SendToApproval, Status$1 as Status, index$5_StatusConfig as StatusConfig, type index$5_StatusConfigType as StatusConfigType, type index$5_Style as Style, index$5_Styles as Styles, type index$5_TimelineItem as TimelineItem, index$5_TimelineItemSchema as TimelineItemSchema };
+type index$6_Approve = Approve;
+type index$6_CaptionStyle = CaptionStyle;
+declare const index$6_CaptionStyle: typeof CaptionStyle;
+type index$6_Feedback = Feedback;
+declare const index$6_FeedbackSchema: typeof FeedbackSchema;
+type index$6_ProjectCreation = ProjectCreation;
+declare const index$6_ProjectSchema: typeof ProjectSchema;
+type index$6_SendToApproval = SendToApproval;
+declare const index$6_StatusConfig: typeof StatusConfig;
+type index$6_StatusConfigType = StatusConfigType;
+type index$6_Style = Style;
+declare const index$6_Styles: typeof Styles;
+type index$6_TimelineItem = TimelineItem;
+declare const index$6_TimelineItemSchema: typeof TimelineItemSchema;
+declare namespace index$6 {
+  export { type index$6_Approve as Approve, index$6_CaptionStyle as CaptionStyle, Endpoints$4 as Endpoints, type Project as Entity, type index$6_Feedback as Feedback, index$6_FeedbackSchema as FeedbackSchema, type IAPI$5 as IAPI, type index$6_ProjectCreation as ProjectCreation, index$6_ProjectSchema as ProjectSchema, type index$6_SendToApproval as SendToApproval, Status$1 as Status, index$6_StatusConfig as StatusConfig, type index$6_StatusConfigType as StatusConfigType, type index$6_Style as Style, index$6_Styles as Styles, type index$6_TimelineItem as TimelineItem, index$6_TimelineItemSchema as TimelineItemSchema };
 }
 
 declare const DailyMilestoneSchema: z.ZodObject<{
@@ -2186,11 +2179,11 @@ declare const GoalSchema: z.ZodObject<{
 type DailyMilestone = z.infer<typeof DailyMilestoneSchema>;
 type Goal = z.infer<typeof GoalSchema>;
 
-interface IAPI$3 {
+interface IAPI$4 {
     getGoals: (context: Context) => Promise<Goal[]>;
     getEditorGoals: (context: Context, editorId: string) => Promise<Goal[]>;
 }
-declare const Endpoints$2: {
+declare const Endpoints$3: {
     GetGoals: {
         uri: string;
         method: string;
@@ -2201,11 +2194,11 @@ declare const Endpoints$2: {
     };
 };
 
-type index$4_DailyMilestone = DailyMilestone;
-declare const index$4_DailyMilestoneSchema: typeof DailyMilestoneSchema;
-declare const index$4_GoalSchema: typeof GoalSchema;
-declare namespace index$4 {
-  export { type index$4_DailyMilestone as DailyMilestone, index$4_DailyMilestoneSchema as DailyMilestoneSchema, Endpoints$2 as Endpoints, type Goal as Entity, index$4_GoalSchema as GoalSchema, type IAPI$3 as IAPI };
+type index$5_DailyMilestone = DailyMilestone;
+declare const index$5_DailyMilestoneSchema: typeof DailyMilestoneSchema;
+declare const index$5_GoalSchema: typeof GoalSchema;
+declare namespace index$5 {
+  export { type index$5_DailyMilestone as DailyMilestone, index$5_DailyMilestoneSchema as DailyMilestoneSchema, Endpoints$3 as Endpoints, type Goal as Entity, index$5_GoalSchema as GoalSchema, type IAPI$4 as IAPI };
 }
 
 declare enum Frequency {
@@ -2706,7 +2699,7 @@ type RecurrenceRule = z.infer<typeof RecurrenceRuleSchema>;
 type History = z.infer<typeof HistorySchema>;
 type Criteria = z.infer<typeof CriteriaSchema>;
 
-interface IAPI$2 {
+interface IAPI$3 {
     getTriggers: (ctx: Context) => Promise<APIResponse<Trigger>>;
     createTrigger: (ctx: Context, t: Trigger) => Promise<Trigger>;
     deleteTrigger: (ctx: Context, triggerId: string) => Promise<boolean>;
@@ -2716,7 +2709,7 @@ interface IAPI$2 {
     markAsRead: (ctx: Context, id: string) => Promise<boolean>;
     clearNotifications: (ctx: Context) => Promise<boolean>;
 }
-declare const Endpoints$1: {
+declare const Endpoints$2: {
     Create: {
         uri: string;
         method: string;
@@ -2751,35 +2744,35 @@ declare const Endpoints$1: {
     };
 };
 
-type index$3_Criteria = Criteria;
-declare const index$3_CriteriaSchema: typeof CriteriaSchema;
-type index$3_CriteriaType = CriteriaType;
-declare const index$3_CriteriaType: typeof CriteriaType;
-type index$3_Frequency = Frequency;
-declare const index$3_Frequency: typeof Frequency;
-type index$3_History = History;
-declare const index$3_HistorySchema: typeof HistorySchema;
-type index$3_NotificationDetail = NotificationDetail;
-declare const index$3_NotificationDetailSchema: typeof NotificationDetailSchema;
-type index$3_NotificationItem = NotificationItem;
-declare const index$3_NotificationItemSchema: typeof NotificationItemSchema;
-type index$3_NotificationType = NotificationType;
-declare const index$3_NotificationType: typeof NotificationType;
-type index$3_RecurrenceRule = RecurrenceRule;
-declare const index$3_RecurrenceRuleSchema: typeof RecurrenceRuleSchema;
-type index$3_Status = Status;
-declare const index$3_Status: typeof Status;
-type index$3_TransportType = TransportType;
-declare const index$3_TransportType: typeof TransportType;
-type index$3_Trigger = Trigger;
-declare const index$3_TriggerSchema: typeof TriggerSchema;
-type index$3_WeekDay = WeekDay;
-declare const index$3_WeekDay: typeof WeekDay;
-declare namespace index$3 {
-  export { type index$3_Criteria as Criteria, index$3_CriteriaSchema as CriteriaSchema, index$3_CriteriaType as CriteriaType, Endpoints$1 as Endpoints, index$3_Frequency as Frequency, type index$3_History as History, index$3_HistorySchema as HistorySchema, type IAPI$2 as IAPI, type index$3_NotificationDetail as NotificationDetail, index$3_NotificationDetailSchema as NotificationDetailSchema, type index$3_NotificationItem as NotificationItem, index$3_NotificationItemSchema as NotificationItemSchema, index$3_NotificationType as NotificationType, type index$3_RecurrenceRule as RecurrenceRule, index$3_RecurrenceRuleSchema as RecurrenceRuleSchema, index$3_Status as Status, index$3_TransportType as TransportType, type index$3_Trigger as Trigger, index$3_TriggerSchema as TriggerSchema, index$3_WeekDay as WeekDay };
+type index$4_Criteria = Criteria;
+declare const index$4_CriteriaSchema: typeof CriteriaSchema;
+type index$4_CriteriaType = CriteriaType;
+declare const index$4_CriteriaType: typeof CriteriaType;
+type index$4_Frequency = Frequency;
+declare const index$4_Frequency: typeof Frequency;
+type index$4_History = History;
+declare const index$4_HistorySchema: typeof HistorySchema;
+type index$4_NotificationDetail = NotificationDetail;
+declare const index$4_NotificationDetailSchema: typeof NotificationDetailSchema;
+type index$4_NotificationItem = NotificationItem;
+declare const index$4_NotificationItemSchema: typeof NotificationItemSchema;
+type index$4_NotificationType = NotificationType;
+declare const index$4_NotificationType: typeof NotificationType;
+type index$4_RecurrenceRule = RecurrenceRule;
+declare const index$4_RecurrenceRuleSchema: typeof RecurrenceRuleSchema;
+type index$4_Status = Status;
+declare const index$4_Status: typeof Status;
+type index$4_TransportType = TransportType;
+declare const index$4_TransportType: typeof TransportType;
+type index$4_Trigger = Trigger;
+declare const index$4_TriggerSchema: typeof TriggerSchema;
+type index$4_WeekDay = WeekDay;
+declare const index$4_WeekDay: typeof WeekDay;
+declare namespace index$4 {
+  export { type index$4_Criteria as Criteria, index$4_CriteriaSchema as CriteriaSchema, index$4_CriteriaType as CriteriaType, Endpoints$2 as Endpoints, index$4_Frequency as Frequency, type index$4_History as History, index$4_HistorySchema as HistorySchema, type IAPI$3 as IAPI, type index$4_NotificationDetail as NotificationDetail, index$4_NotificationDetailSchema as NotificationDetailSchema, type index$4_NotificationItem as NotificationItem, index$4_NotificationItemSchema as NotificationItemSchema, index$4_NotificationType as NotificationType, type index$4_RecurrenceRule as RecurrenceRule, index$4_RecurrenceRuleSchema as RecurrenceRuleSchema, index$4_Status as Status, index$4_TransportType as TransportType, type index$4_Trigger as Trigger, index$4_TriggerSchema as TriggerSchema, index$4_WeekDay as WeekDay };
 }
 
-interface IAPI$1 {
+interface IAPI$2 {
     version: () => Promise<string>;
 }
 
@@ -2923,13 +2916,13 @@ declare const NoteSchema: z.ZodObject<{
 type Note = z.infer<typeof NoteSchema>;
 type NoteHistory = z.infer<typeof NoteHistorySchema>;
 
-interface IAPI {
+interface IAPI$1 {
     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: {
+declare const Endpoints$1: {
     GetNotes: {
         uri: string;
         method: string;
@@ -2948,27 +2941,189 @@ declare const Endpoints: {
     };
 };
 
+type index$3_NoteHistory = NoteHistory;
+declare const index$3_NoteHistorySchema: typeof NoteHistorySchema;
+declare const index$3_NoteSchema: typeof NoteSchema;
+declare namespace index$3 {
+  export { Endpoints$1 as Endpoints, type Note as Entity, type IAPI$1 as IAPI, type index$3_NoteHistory as NoteHistory, index$3_NoteHistorySchema as NoteHistorySchema, index$3_NoteSchema as NoteSchema };
+}
+
+declare const SpecialOfferSchema: z.ZodObject<{
+    id: z.ZodString;
+    freeProjectsAllowed: z.ZodNumber;
+    windowHours: z.ZodNumber;
+    planId: z.ZodString;
+    couponId: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    ctaLabel: z.ZodString;
+    enabled: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    title: string;
+    description: string;
+    freeProjectsAllowed: number;
+    windowHours: number;
+    planId: string;
+    couponId: string;
+    ctaLabel: string;
+    enabled: boolean;
+}, {
+    id: string;
+    title: string;
+    description: string;
+    freeProjectsAllowed: number;
+    windowHours: number;
+    planId: string;
+    couponId: string;
+    ctaLabel: string;
+    enabled: boolean;
+}>;
+declare const UserOfferDetailsSchema: z.ZodObject<{
+    offerId: z.ZodString;
+    expiresAt: z.ZodNumber;
+    title: z.ZodString;
+    description: z.ZodString;
+    ctaLabel: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    description: string;
+    expiresAt: number;
+    ctaLabel: string;
+    offerId: string;
+}, {
+    title: string;
+    description: string;
+    expiresAt: number;
+    ctaLabel: string;
+    offerId: string;
+}>;
+declare const CreateSpecialOfferSchema: z.ZodObject<{
+    freeProjectsAllowed: z.ZodOptional<z.ZodNumber>;
+    windowHours: z.ZodNumber;
+    planId: z.ZodString;
+    couponId: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    ctaLabel: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    description: string;
+    windowHours: number;
+    planId: string;
+    couponId: string;
+    ctaLabel: string;
+    freeProjectsAllowed?: number | undefined;
+}, {
+    title: string;
+    description: string;
+    windowHours: number;
+    planId: string;
+    couponId: string;
+    ctaLabel: string;
+    freeProjectsAllowed?: number | undefined;
+}>;
+declare const UpdateSpecialOfferSchema: z.ZodObject<{
+    freeProjectsAllowed: z.ZodOptional<z.ZodNumber>;
+    windowHours: z.ZodOptional<z.ZodNumber>;
+    planId: z.ZodOptional<z.ZodString>;
+    couponId: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    ctaLabel: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    title?: string | undefined;
+    description?: string | undefined;
+    freeProjectsAllowed?: number | undefined;
+    windowHours?: number | undefined;
+    planId?: string | undefined;
+    couponId?: string | undefined;
+    ctaLabel?: string | undefined;
+}, {
+    title?: string | undefined;
+    description?: string | undefined;
+    freeProjectsAllowed?: number | undefined;
+    windowHours?: number | undefined;
+    planId?: string | undefined;
+    couponId?: string | undefined;
+    ctaLabel?: string | undefined;
+}>;
+type SpecialOffer = z.infer<typeof SpecialOfferSchema>;
+type UserOfferDetails = z.infer<typeof UserOfferDetailsSchema>;
+type Create = z.infer<typeof CreateSpecialOfferSchema>;
+type Update = z.infer<typeof UpdateSpecialOfferSchema>;
+
+interface IAPI {
+    list: (ctx: Context) => Promise<SpecialOffer[]>;
+    getActive: (ctx: Context) => Promise<SpecialOffer | null>;
+    create: (ctx: Context, data: Create) => Promise<SpecialOffer>;
+    update: (ctx: Context, id: string, data: Update) => 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: {
+    List: {
+        uri: string;
+        method: string;
+    };
+    GetActive: {
+        uri: string;
+        method: string;
+    };
+    Create: {
+        uri: string;
+        method: string;
+    };
+    Update: {
+        uri: string;
+        method: string;
+    };
+    Enable: {
+        uri: string;
+        method: string;
+    };
+    Disable: {
+        uri: string;
+        method: string;
+    };
+    GetMyOffer: {
+        uri: string;
+        method: string;
+    };
+    Claim: {
+        uri: string;
+        method: string;
+    };
+};
+
+type index$2_Create = Create;
+declare const index$2_CreateSpecialOfferSchema: typeof CreateSpecialOfferSchema;
 declare const index$2_Endpoints: typeof Endpoints;
 type index$2_IAPI = IAPI;
-type index$2_NoteHistory = NoteHistory;
-declare const index$2_NoteHistorySchema: typeof NoteHistorySchema;
-declare const index$2_NoteSchema: typeof NoteSchema;
+declare const index$2_SpecialOfferSchema: typeof SpecialOfferSchema;
+type index$2_Update = Update;
+declare const index$2_UpdateSpecialOfferSchema: typeof UpdateSpecialOfferSchema;
+type index$2_UserOfferDetails = UserOfferDetails;
+declare const index$2_UserOfferDetailsSchema: typeof UserOfferDetailsSchema;
 declare namespace index$2 {
-  export { index$2_Endpoints as Endpoints, type Note as Entity, type index$2_IAPI as IAPI, type index$2_NoteHistory as NoteHistory, index$2_NoteHistorySchema as NoteHistorySchema, index$2_NoteSchema as NoteSchema };
+  export { type index$2_Create as Create, index$2_CreateSpecialOfferSchema as CreateSpecialOfferSchema, index$2_Endpoints as Endpoints, type SpecialOffer as Entity, type index$2_IAPI as IAPI, index$2_SpecialOfferSchema as SpecialOfferSchema, type index$2_Update as Update, index$2_UpdateSpecialOfferSchema as UpdateSpecialOfferSchema, type index$2_UserOfferDetails as UserOfferDetails, index$2_UserOfferDetailsSchema as UserOfferDetailsSchema };
 }
 
 declare class ShredAPI {
-    user: IAPI$8;
-    goal: IAPI$3;
-    subscription: IAPI$9;
-    prompt: IAPI$a;
-    pushNotification: IAPI$2;
-    email: IAPI$5;
-    tenant: IAPI$7;
-    app: IAPI$1;
-    project: IAPI$4;
-    track: IAPI$6;
-    note: IAPI;
+    user: IAPI$9;
+    goal: IAPI$4;
+    subscription: IAPI$a;
+    prompt: IAPI$b;
+    pushNotification: IAPI$3;
+    email: IAPI$6;
+    tenant: IAPI$8;
+    app: IAPI$2;
+    project: IAPI$5;
+    track: IAPI$7;
+    note: IAPI$1;
+    specialOffer: IAPI;
     constructor(env: Environment);
 }
 
@@ -2997,15 +3152,6 @@ declare class ForbiddenException extends ShredException {
     constructor(message: string);
 }
 
-declare const Exceptions: {
-    ConflictException: typeof ConflictException;
-    InvalidArgumentException: typeof InvalidArgumentException;
-    ResourceNotFoundException: typeof ResourceNotFoundException;
-    ShredException: typeof ShredException;
-    UnauthorizedException: typeof UnauthorizedException;
-    ForbiddenException: typeof ForbiddenException;
-};
-
 type index$1_ConflictException = ConflictException;
 declare const index$1_ConflictException: typeof ConflictException;
 type index$1_ForbiddenException = ForbiddenException;
@@ -3019,7 +3165,7 @@ declare const index$1_ShredException: typeof ShredException;
 type index$1_UnauthorizedException = UnauthorizedException;
 declare const index$1_UnauthorizedException: typeof UnauthorizedException;
 declare namespace index$1 {
-  export { index$1_ConflictException as ConflictException, index$1_ForbiddenException as ForbiddenException, index$1_InvalidArgumentException as InvalidArgumentException, index$1_ResourceNotFoundException as ResourceNotFoundException, index$1_ShredException as ShredException, index$1_UnauthorizedException as UnauthorizedException, Exceptions as default };
+  export { index$1_ConflictException as ConflictException, index$1_ForbiddenException as ForbiddenException, index$1_InvalidArgumentException as InvalidArgumentException, index$1_ResourceNotFoundException as ResourceNotFoundException, index$1_ShredException as ShredException, index$1_UnauthorizedException as UnauthorizedException };
 }
 
 declare const AssetSchema: z.ZodObject<{
@@ -3069,4 +3215,4 @@ declare namespace index {
   export { index_AssetSchema as AssetSchema, type Asset as Entity };
 }
 
-export { index as Asset, index$a as Core, index$6 as Email, index$1 as Exceptions, index$4 as Goal, index$2 as Note, index$3 as Notification, index$5 as Project, index$c as Prompt, ShredAPI, index$b as Subscription, index$8 as Tenant, index$7 as Track, index$9 as User, ShredAPI as default };
+export { index as Asset, index$b as Core, index$7 as Email, index$1 as Exceptions, index$5 as Goal, index$3 as Note, index$4 as Notification, index$6 as Project, index$d as Prompt, ShredAPI, index$2 as SpecialOffer, index$c as Subscription, index$9 as Tenant, index$8 as Track, index$a as User, ShredAPI as default };