shred-api-client 2.8.1 → 2.9.1

package/dist/index.d.ts

@@ -197,7 +197,7 @@ type Context = {
     requestId?: string;
 };
 
-interface IAPI$c {
+interface IAPI$d {
     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$c {
     generateScript: (c: Context, data: ScriptIARequest) => Promise<string>;
     updateScript: (c: Context, id: string, script: Partial<Script>) => Promise<boolean>;
 }
-declare const Endpoints$b: {
+declare const Endpoints$c: {
     GetPrompt: {
         uri: string;
         method: string;
@@ -240,7 +240,7 @@ 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$b as Endpoints, type Prompt as Entity, type IAPI$c 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 };
+  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 };
 }
 
 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$b {
+interface IAPI$c {
     getCharges: (ctx: Context) => Promise<Charge[]>;
     getPortalUrl: (ctx: Context) => Promise<string>;
     getSubscription: (context: Context, userId?: string) => Promise<Subscription | null>;
@@ -609,7 +609,7 @@ interface IAPI$b {
     getSubscriptionsSummary: (ctx: Context) => Promise<SubscriptionSummary[]>;
     listPromoCodes: (ctx: Context) => Promise<PromoCode[]>;
 }
-declare const Endpoints$a: {
+declare const Endpoints$b: {
     GetPortal: {
         uri: string;
         method: string;
@@ -680,10 +680,10 @@ 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$a as Endpoints, type Subscription as Entity, type IAPI$b 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 };
+  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 };
 }
 
-declare enum Role {
+declare enum Role$1 {
     USER = "User",
     EDITOR = "Editor",
     QA = "QA",
@@ -777,13 +777,13 @@ declare const UserSchema: z.ZodObject<{
     }>>;
     experienceId: z.ZodOptional<z.ZodString>;
     customerId: z.ZodString;
-    role: z.ZodNativeEnum<typeof Role>;
+    role: z.ZodNativeEnum<typeof Role$1>;
 }, "strip", z.ZodTypeAny, {
     email: string;
     id: string;
     name: string;
     customerId: string;
-    role: Role;
+    role: Role$1;
     timezone?: string | undefined;
     tenantId?: string | undefined;
     preferences?: {
@@ -811,7 +811,7 @@ declare const UserSchema: z.ZodObject<{
     id: string;
     name: string;
     customerId: string;
-    role: Role;
+    role: Role$1;
     timezone?: string | undefined;
     tenantId?: string | undefined;
     preferences?: {
@@ -842,7 +842,7 @@ type Create$1 = Pick<User, "name" | "email"> & {
     password?: string;
     passwordConfirmation?: string;
     invitationCode?: string;
-    role?: Role;
+    role?: Role$1;
     industries?: string[];
 };
 
@@ -882,7 +882,7 @@ 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 };
 }
 
-interface IAPI$a {
+interface IAPI$b {
     getUserInfo: (context: Context) => Promise<User>;
     isEmailAvaliable: (email: string) => Promise<boolean>;
     sendValidationCode: (email: string) => Promise<boolean>;
@@ -899,7 +899,7 @@ interface IAPI$a {
     search: (ctx: Context, query: QueryOptions<User>) => Promise<APIResponse<User>>;
     createUser: (data: Create$1) => Promise<User>;
 }
-declare const Endpoints$9: {
+declare const Endpoints$a: {
     ChangeEmail: {
         uri: string;
         method: string;
@@ -966,13 +966,11 @@ declare const Endpoints$9: {
     };
 };
 
-type index$c_Role = Role;
-declare const index$c_Role: typeof Role;
 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$9 as Endpoints, type User as Entity, type IAPI$a as IAPI, type Preferences$1 as Preferences, PreferencesSchema$1 as PreferencesSchema, index$c_Role as Role, index$c_System as System, type Update$1 as Update, index$c_UserSchema as UserSchema };
+  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 };
 }
 
 declare const PreferencesSchema: z.ZodObject<{
@@ -1714,7 +1712,7 @@ type Tenant = z.infer<typeof TenantSchema>;
 type Member = z.infer<typeof MemberSchema>;
 type Preferences = z.infer<typeof PreferencesSchema>;
 
-interface IAPI$9 {
+interface IAPI$a {
     getByInviteCode: (code: string, context?: Context) => Promise<Tenant | null>;
     create: (tenant: Tenant, context: Context) => Promise<boolean>;
     list: (context: Context) => Promise<Tenant[]>;
@@ -1724,7 +1722,7 @@ interface IAPI$9 {
     updateReportViewers: (tenantId: string, reportViewerUpdate: ReportViewerUpdate, context: Context) => Promise<boolean>;
     updateMembers: (tenantId: string, memberUpdate: MemberUpdate, context: Context) => Promise<boolean>;
 }
-declare const Endpoints$8: {
+declare const Endpoints$9: {
     GetByInviteCode: {
         uri: string;
         method: string;
@@ -1775,7 +1773,7 @@ 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$8 as Endpoints, type Tenant as Entity, type IAPI$9 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, type index$b_ReportViewerUpdate as ReportViewerUpdate, index$b_ReportViewerUpdateSchema as ReportViewerUpdateSchema, index$b_TenantSchema as TenantSchema, type index$b_TenantUpdate as TenantUpdate, index$b_TenantUpdateSchema as TenantUpdateSchema };
+  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, type index$b_ReportViewerUpdate as ReportViewerUpdate, index$b_ReportViewerUpdateSchema as ReportViewerUpdateSchema, index$b_TenantSchema as TenantSchema, type index$b_TenantUpdate as TenantUpdate, index$b_TenantUpdateSchema as TenantUpdateSchema };
 }
 
 declare const TrackParamSchema: z.ZodObject<{
@@ -1822,10 +1820,10 @@ declare const TrackSchema: z.ZodObject<{
 type Track = z.infer<typeof TrackSchema>;
 type TrackParam = z.infer<typeof TrackParamSchema>;
 
-interface IAPI$8 {
+interface IAPI$9 {
     send: (t: Track) => Promise<boolean>;
 }
-declare const Endpoints$7: {
+declare const Endpoints$8: {
     Track: {
         uri: string;
         method: string;
@@ -1836,7 +1834,7 @@ 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$7 as Endpoints, type Track as Entity, type IAPI$8 as IAPI, type index$a_TrackParam as TrackParam, index$a_TrackParamSchema as TrackParamSchema, index$a_TrackSchema as TrackSchema };
+  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 };
 }
 
 declare const EmailSchema: z.ZodObject<{
@@ -1854,10 +1852,10 @@ declare const EmailSchema: z.ZodObject<{
 }>;
 type Email = z.infer<typeof EmailSchema>;
 
-interface IAPI$7 {
+interface IAPI$8 {
     send: (email: Email, ctx?: Context) => Promise<boolean>;
 }
-declare const Endpoints$6: {
+declare const Endpoints$7: {
     SendEmail: {
         uri: string;
         method: string;
@@ -1866,7 +1864,7 @@ declare const Endpoints$6: {
 
 declare const index$9_EmailSchema: typeof EmailSchema;
 declare namespace index$9 {
-  export { index$9_EmailSchema as EmailSchema, Endpoints$6 as Endpoints, type Email as Entity, type IAPI$7 as IAPI };
+  export { index$9_EmailSchema as EmailSchema, Endpoints$7 as Endpoints, type Email as Entity, type IAPI$8 as IAPI };
 }
 
 declare enum Status$1 {
@@ -2200,7 +2198,7 @@ type TimelineItem = z.infer<typeof TimelineItemSchema>;
 type Interaction = z.infer<typeof InteractionSchema>;
 type Feedback = z.infer<typeof FeedbackSchema>;
 
-interface IAPI$6 {
+interface IAPI$7 {
     reorder: (context: Context, projectId: string, position: number) => Promise<boolean>;
     find: (context: Context, projectId: string) => Promise<Project>;
     create: (context: Context, data: ProjectCreation) => Promise<Project>;
@@ -2222,7 +2220,7 @@ interface IAPI$6 {
         isEligibleForFreeProject(context: Context): Promise<boolean>;
     };
 }
-declare const Endpoints$5: {
+declare const Endpoints$6: {
     Reorder: {
         uri: string;
         method: string;
@@ -2352,7 +2350,7 @@ 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$5 as Endpoints, type Project as Entity, type index$8_Feedback as Feedback, index$8_FeedbackSchema as FeedbackSchema, type IAPI$6 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_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 };
+  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_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 };
 }
 
 declare const DailyMilestoneSchema: z.ZodObject<{
@@ -2424,11 +2422,11 @@ declare const GoalSchema: z.ZodObject<{
 type DailyMilestone = z.infer<typeof DailyMilestoneSchema>;
 type Goal = z.infer<typeof GoalSchema>;
 
-interface IAPI$5 {
+interface IAPI$6 {
     getGoals: (context: Context) => Promise<Goal[]>;
     getEditorGoals: (context: Context, editorId: string) => Promise<Goal[]>;
 }
-declare const Endpoints$4: {
+declare const Endpoints$5: {
     GetGoals: {
         uri: string;
         method: string;
@@ -2443,7 +2441,7 @@ 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$4 as Endpoints, type Goal as Entity, index$7_GoalSchema as GoalSchema, type IAPI$5 as IAPI };
+  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 };
 }
 
 declare const EditorSchema: z.ZodObject<{
@@ -2476,11 +2474,11 @@ declare const EditorSchema: z.ZodObject<{
 }>;
 type Editor = z.infer<typeof EditorSchema>;
 
-interface IAPI$4 {
+interface IAPI$5 {
     getAll(context: Context): Promise<Editor[]>;
     getById(context: Context, editorId: string): Promise<Editor>;
 }
-declare const Endpoints$3: {
+declare const Endpoints$4: {
     GetAll: {
         uri: string;
         method: string;
@@ -2493,7 +2491,7 @@ declare const Endpoints$3: {
 
 declare const index$6_EditorSchema: typeof EditorSchema;
 declare namespace index$6 {
-  export { index$6_EditorSchema as EditorSchema, Endpoints$3 as Endpoints, type Editor as Entity, type IAPI$4 as IAPI };
+  export { index$6_EditorSchema as EditorSchema, Endpoints$4 as Endpoints, type Editor as Entity, type IAPI$5 as IAPI };
 }
 
 declare enum Frequency {
@@ -2994,7 +2992,7 @@ type RecurrenceRule = z.infer<typeof RecurrenceRuleSchema>;
 type History = z.infer<typeof HistorySchema>;
 type Criteria = z.infer<typeof CriteriaSchema>;
 
-interface IAPI$3 {
+interface IAPI$4 {
     getTriggers: (ctx: Context) => Promise<APIResponse<Trigger>>;
     createTrigger: (ctx: Context, t: Trigger) => Promise<Trigger>;
     deleteTrigger: (ctx: Context, triggerId: string) => Promise<boolean>;
@@ -3004,7 +3002,7 @@ interface IAPI$3 {
     markAsRead: (ctx: Context, id: string) => Promise<boolean>;
     clearNotifications: (ctx: Context) => Promise<boolean>;
 }
-declare const Endpoints$2: {
+declare const Endpoints$3: {
     Create: {
         uri: string;
         method: string;
@@ -3064,10 +3062,10 @@ 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$2 as Endpoints, index$5_Frequency as Frequency, type index$5_History as History, index$5_HistorySchema as HistorySchema, type IAPI$3 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 };
+  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 };
 }
 
-interface IAPI$2 {
+interface IAPI$3 {
     version: () => Promise<string>;
 }
 
@@ -3211,13 +3209,13 @@ declare const NoteSchema: z.ZodObject<{
 type Note = z.infer<typeof NoteSchema>;
 type NoteHistory = z.infer<typeof NoteHistorySchema>;
 
-interface IAPI$1 {
+interface IAPI$2 {
     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$1: {
+declare const Endpoints$2: {
     GetNotes: {
         uri: string;
         method: string;
@@ -3240,7 +3238,7 @@ 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$1 as Endpoints, type Note as Entity, type IAPI$1 as IAPI, type index$4_NoteHistory as NoteHistory, index$4_NoteHistorySchema as NoteHistorySchema, index$4_NoteSchema as NoteSchema };
+  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 };
 }
 
 declare const SpecialOfferSchema: z.ZodObject<{
@@ -3348,7 +3346,7 @@ type UserOfferDetails = z.infer<typeof UserOfferDetailsSchema>;
 type Create = z.infer<typeof CreateSpecialOfferSchema>;
 type Update = z.infer<typeof UpdateSpecialOfferSchema>;
 
-interface IAPI {
+interface IAPI$1 {
     list: (ctx: Context) => Promise<SpecialOffer[]>;
     getActive: (ctx: Context) => Promise<SpecialOffer | null>;
     create: (ctx: Context, data: Create) => Promise<SpecialOffer>;
@@ -3358,7 +3356,7 @@ interface IAPI {
     getMyOffer: (ctx: Context) => Promise<UserOfferDetails | null>;
     claim: (ctx: Context, callbackUrl?: string) => Promise<string>;
 }
-declare const Endpoints: {
+declare const Endpoints$1: {
     List: {
         uri: string;
         method: string;
@@ -3395,120 +3393,13 @@ declare const Endpoints: {
 
 type index$3_Create = Create;
 declare const index$3_CreateSpecialOfferSchema: typeof CreateSpecialOfferSchema;
-declare const index$3_Endpoints: typeof Endpoints;
-type index$3_IAPI = IAPI;
 declare const index$3_SpecialOfferSchema: typeof SpecialOfferSchema;
 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 namespace index$3 {
-  export { type index$3_Create as Create, index$3_CreateSpecialOfferSchema as CreateSpecialOfferSchema, index$3_Endpoints as Endpoints, type SpecialOffer as Entity, type index$3_IAPI 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 };
-}
-
-declare class ShredAPI {
-    user: IAPI$a;
-    goal: IAPI$5;
-    editor: IAPI$4;
-    subscription: IAPI$b;
-    prompt: IAPI$c;
-    pushNotification: IAPI$3;
-    email: IAPI$7;
-    tenant: IAPI$9;
-    app: IAPI$2;
-    project: IAPI$6;
-    track: IAPI$8;
-    note: IAPI$1;
-    specialOffer: IAPI;
-    constructor(env: Environment);
-}
-
-declare class ShredException extends Error {
-    status: number;
-    constructor(message: string, status: number);
-}
-
-declare class ConflictException extends ShredException {
-    constructor(message: string);
-}
-
-declare class InvalidArgumentException extends ShredException {
-    constructor(message: string);
-}
-
-declare class ResourceNotFoundException extends ShredException {
-    constructor(message: string);
-}
-
-declare class UnauthorizedException extends ShredException {
-    constructor(message: string);
-}
-
-declare class ForbiddenException extends ShredException {
-    constructor(message: string);
-}
-
-type index$2_ConflictException = ConflictException;
-declare const index$2_ConflictException: typeof ConflictException;
-type index$2_ForbiddenException = ForbiddenException;
-declare const index$2_ForbiddenException: typeof ForbiddenException;
-type index$2_InvalidArgumentException = InvalidArgumentException;
-declare const index$2_InvalidArgumentException: typeof InvalidArgumentException;
-type index$2_ResourceNotFoundException = ResourceNotFoundException;
-declare const index$2_ResourceNotFoundException: typeof ResourceNotFoundException;
-type index$2_ShredException = ShredException;
-declare const index$2_ShredException: typeof ShredException;
-type index$2_UnauthorizedException = UnauthorizedException;
-declare const index$2_UnauthorizedException: typeof UnauthorizedException;
-declare namespace index$2 {
-  export { index$2_ConflictException as ConflictException, index$2_ForbiddenException as ForbiddenException, index$2_InvalidArgumentException as InvalidArgumentException, index$2_ResourceNotFoundException as ResourceNotFoundException, index$2_ShredException as ShredException, index$2_UnauthorizedException as UnauthorizedException };
-}
-
-declare const AssetSchema: z.ZodObject<{
-    assetId: z.ZodString;
-    fileName: z.ZodString;
-    extension: z.ZodString;
-    fileSize: z.ZodNumber;
-    assetUrl: z.ZodString;
-    thumbnailUrl: z.ZodString;
-    type: z.ZodString;
-    duration: z.ZodOptional<z.ZodNumber>;
-    progress: z.ZodOptional<z.ZodNumber>;
-    error: z.ZodOptional<z.ZodString>;
-    authorId: z.ZodString;
-    uploadedAt: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    type: string;
-    assetId: string;
-    fileName: string;
-    extension: string;
-    fileSize: number;
-    assetUrl: string;
-    thumbnailUrl: string;
-    authorId: string;
-    uploadedAt: number;
-    error?: string | undefined;
-    duration?: number | undefined;
-    progress?: number | undefined;
-}, {
-    type: string;
-    assetId: string;
-    fileName: string;
-    extension: string;
-    fileSize: number;
-    assetUrl: string;
-    thumbnailUrl: string;
-    authorId: string;
-    uploadedAt: number;
-    error?: string | undefined;
-    duration?: number | undefined;
-    progress?: number | undefined;
-}>;
-type Asset = z.infer<typeof AssetSchema>;
-
-declare const index$1_AssetSchema: typeof AssetSchema;
-declare namespace index$1 {
-  export { index$1_AssetSchema as AssetSchema, type Asset as Entity };
+  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 };
 }
 
 /**
@@ -3622,16 +3513,311 @@ declare const ActionCatalog: Record<Action, ActionMeta>;
 /** The catalog as a flat list of `{ key, label, group }` — e.g. for `GET /actions`. */
 declare function listActionCatalog(): ActionCatalogEntry[];
 
-type index_Action = Action;
-declare const index_ActionCatalog: typeof ActionCatalog;
-type index_ActionCatalogEntry = ActionCatalogEntry;
-type index_ActionGroup = ActionGroup;
-type index_ActionMeta = ActionMeta;
-declare const index_Actions: typeof Actions;
-type index_Scope = Scope;
-declare const index_listActionCatalog: typeof listActionCatalog;
+declare const RoleSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    actions: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    actions: string[];
+}, {
+    id: string;
+    name: string;
+    actions: string[];
+}>;
+type Role = z.infer<typeof RoleSchema>;
+
+declare const ScopeSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"global">;
+}, "strip", z.ZodTypeAny, {
+    type: "global";
+}, {
+    type: "global";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"tenant">;
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "tenant";
+}, {
+    id: string;
+    type: "tenant";
+}>]>;
+declare const RoleGrantSchema: z.ZodObject<{
+    roleId: z.ZodString;
+    scope: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"global">;
+    }, "strip", z.ZodTypeAny, {
+        type: "global";
+    }, {
+        type: "global";
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"tenant">;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        type: "tenant";
+    }, {
+        id: string;
+        type: "tenant";
+    }>]>;
+}, "strip", z.ZodTypeAny, {
+    roleId: string;
+    scope: {
+        type: "global";
+    } | {
+        id: string;
+        type: "tenant";
+    };
+}, {
+    roleId: string;
+    scope: {
+        type: "global";
+    } | {
+        id: string;
+        type: "tenant";
+    };
+}>;
+declare const RoleAssignmentSchema: z.ZodObject<{
+    id: z.ZodString;
+    roles: z.ZodArray<z.ZodObject<{
+        roleId: z.ZodString;
+        scope: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            type: z.ZodLiteral<"global">;
+        }, "strip", z.ZodTypeAny, {
+            type: "global";
+        }, {
+            type: "global";
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"tenant">;
+            id: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            type: "tenant";
+        }, {
+            id: string;
+            type: "tenant";
+        }>]>;
+    }, "strip", z.ZodTypeAny, {
+        roleId: string;
+        scope: {
+            type: "global";
+        } | {
+            id: string;
+            type: "tenant";
+        };
+    }, {
+        roleId: string;
+        scope: {
+            type: "global";
+        } | {
+            id: string;
+            type: "tenant";
+        };
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    roles: {
+        roleId: string;
+        scope: {
+            type: "global";
+        } | {
+            id: string;
+            type: "tenant";
+        };
+    }[];
+}, {
+    id: string;
+    roles: {
+        roleId: string;
+        scope: {
+            type: "global";
+        } | {
+            id: string;
+            type: "tenant";
+        };
+    }[];
+}>;
+type RoleGrant = z.infer<typeof RoleGrantSchema>;
+type RoleAssignment = z.infer<typeof RoleAssignmentSchema>;
+
+type CreateRoleInput = Omit<Role, "id">;
+type UpdateRoleInput = Partial<Omit<Role, "id">>;
+type AssignRoleInput = RoleGrant;
+interface IAPI {
+    getActions: (c: Context) => Promise<ActionCatalogEntry[]>;
+    listRoles: (c: Context) => Promise<Role[]>;
+    createRole: (c: Context, input: CreateRoleInput) => Promise<Role>;
+    updateRole: (c: Context, roleId: string, input: UpdateRoleInput) => Promise<Role>;
+    deleteRole: (c: Context, roleId: string) => Promise<boolean>;
+    getAssignments: (c: Context, uid: string) => Promise<RoleAssignment | null>;
+    assign: (c: Context, uid: string, input: AssignRoleInput) => Promise<RoleAssignment>;
+    unassign: (c: Context, uid: string, input: AssignRoleInput) => Promise<RoleAssignment>;
+}
+declare const Endpoints: {
+    GetActions: {
+        uri: string;
+        method: string;
+    };
+    ListRoles: {
+        uri: string;
+        method: string;
+    };
+    CreateRole: {
+        uri: string;
+        method: string;
+    };
+    UpdateRole: {
+        uri: string;
+        method: string;
+    };
+    DeleteRole: {
+        uri: string;
+        method: string;
+    };
+    GetAssignments: {
+        uri: string;
+        method: string;
+    };
+    Assign: {
+        uri: string;
+        method: string;
+    };
+    Unassign: {
+        uri: string;
+        method: string;
+    };
+};
+
+type index$2_Action = Action;
+declare const index$2_ActionCatalog: typeof ActionCatalog;
+type index$2_ActionCatalogEntry = ActionCatalogEntry;
+type index$2_ActionGroup = ActionGroup;
+type index$2_ActionMeta = ActionMeta;
+declare const index$2_Actions: typeof Actions;
+type index$2_AssignRoleInput = AssignRoleInput;
+type index$2_CreateRoleInput = CreateRoleInput;
+declare const index$2_Endpoints: typeof Endpoints;
+type index$2_IAPI = IAPI;
+type index$2_Role = Role;
+type index$2_RoleAssignment = RoleAssignment;
+declare const index$2_RoleAssignmentSchema: typeof RoleAssignmentSchema;
+type index$2_RoleGrant = RoleGrant;
+declare const index$2_RoleGrantSchema: typeof RoleGrantSchema;
+declare const index$2_RoleSchema: typeof RoleSchema;
+type index$2_Scope = Scope;
+declare const index$2_ScopeSchema: typeof ScopeSchema;
+type index$2_UpdateRoleInput = UpdateRoleInput;
+declare const index$2_listActionCatalog: typeof listActionCatalog;
+declare namespace index$2 {
+  export { type index$2_Action as Action, index$2_ActionCatalog as ActionCatalog, type index$2_ActionCatalogEntry as ActionCatalogEntry, type index$2_ActionGroup as ActionGroup, type index$2_ActionMeta as ActionMeta, index$2_Actions as Actions, type index$2_AssignRoleInput as AssignRoleInput, type index$2_CreateRoleInput as CreateRoleInput, index$2_Endpoints as Endpoints, type index$2_IAPI as IAPI, type index$2_Role as Role, type index$2_RoleAssignment as RoleAssignment, index$2_RoleAssignmentSchema as RoleAssignmentSchema, type index$2_RoleGrant as RoleGrant, index$2_RoleGrantSchema as RoleGrantSchema, index$2_RoleSchema as RoleSchema, type index$2_Scope as Scope, index$2_ScopeSchema as ScopeSchema, type index$2_UpdateRoleInput as UpdateRoleInput, index$2_listActionCatalog as listActionCatalog };
+}
+
+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;
+    rbac: IAPI;
+    constructor(env: Environment);
+}
+
+declare class ShredException extends Error {
+    status: number;
+    constructor(message: string, status: number);
+}
+
+declare class ConflictException extends ShredException {
+    constructor(message: string);
+}
+
+declare class InvalidArgumentException extends ShredException {
+    constructor(message: string);
+}
+
+declare class ResourceNotFoundException extends ShredException {
+    constructor(message: string);
+}
+
+declare class UnauthorizedException extends ShredException {
+    constructor(message: string);
+}
+
+declare class ForbiddenException extends ShredException {
+    constructor(message: string);
+}
+
+type index$1_ConflictException = ConflictException;
+declare const index$1_ConflictException: typeof ConflictException;
+type index$1_ForbiddenException = ForbiddenException;
+declare const index$1_ForbiddenException: typeof ForbiddenException;
+type index$1_InvalidArgumentException = InvalidArgumentException;
+declare const index$1_InvalidArgumentException: typeof InvalidArgumentException;
+type index$1_ResourceNotFoundException = ResourceNotFoundException;
+declare const index$1_ResourceNotFoundException: typeof ResourceNotFoundException;
+type index$1_ShredException = ShredException;
+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 };
+}
+
+declare const AssetSchema: z.ZodObject<{
+    assetId: z.ZodString;
+    fileName: z.ZodString;
+    extension: z.ZodString;
+    fileSize: z.ZodNumber;
+    assetUrl: z.ZodString;
+    thumbnailUrl: z.ZodString;
+    type: z.ZodString;
+    duration: z.ZodOptional<z.ZodNumber>;
+    progress: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodOptional<z.ZodString>;
+    authorId: z.ZodString;
+    uploadedAt: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    assetId: string;
+    fileName: string;
+    extension: string;
+    fileSize: number;
+    assetUrl: string;
+    thumbnailUrl: string;
+    authorId: string;
+    uploadedAt: number;
+    error?: string | undefined;
+    duration?: number | undefined;
+    progress?: number | undefined;
+}, {
+    type: string;
+    assetId: string;
+    fileName: string;
+    extension: string;
+    fileSize: number;
+    assetUrl: string;
+    thumbnailUrl: string;
+    authorId: string;
+    uploadedAt: number;
+    error?: string | undefined;
+    duration?: number | undefined;
+    progress?: number | undefined;
+}>;
+type Asset = z.infer<typeof AssetSchema>;
+
+declare const index_AssetSchema: typeof AssetSchema;
 declare namespace index {
-  export { type index_Action as Action, index_ActionCatalog as ActionCatalog, type index_ActionCatalogEntry as ActionCatalogEntry, type index_ActionGroup as ActionGroup, type index_ActionMeta as ActionMeta, index_Actions as Actions, type index_Scope as Scope, index_listActionCatalog as listActionCatalog };
+  export { index_AssetSchema as AssetSchema, type Asset as Entity };
 }
 
-export { index$1 as Asset, index$d as Core, index$6 as Editor, index$9 as Email, index$2 as Exceptions, index$7 as Goal, index$4 as Note, index$5 as Notification, index$8 as Project, index$f as Prompt, index 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$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 };