shred-api-client 2.0.8 → 2.0.10-rc.0

package/dist/index.mjs

@@ -0,0 +1,1732 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/util/HTTPClient.ts
+import axios, { isAxiosError } from "axios";
+var HOSTS = {
+  prod: "https://api.shreditapp.com",
+  staging: "https://api.staging.shreditapp.com",
+  local: "https://api.staging.shreditapp.com"
+};
+var OLD_HOSTS = {
+  prod: "https://api.shredmedia.co",
+  staging: "https://api-staging.shredmedia.co",
+  local: "https://api-staging.shredmedia.co"
+};
+var HTTPClient = class {
+  async makeRequest(env, uri, method, data, context, useLegacyApi) {
+    const hostDict = useLegacyApi ? OLD_HOSTS : HOSTS;
+    const host = hostDict[env] || hostDict.staging;
+    const config = {
+      method,
+      url: host + uri,
+      headers: {
+        Authorization: context?.token && `Bearer ${context.token}`,
+        "X-Request-ID": context?.requestId && context.requestId || "",
+        "Content-Type": useLegacyApi ? "application/x-www-form-urlencoded" : "application/json"
+      }
+    };
+    if (method !== "GET" && data) {
+      config.data = data;
+    }
+    try {
+      const response = await axios(config);
+      return response.data;
+    } catch (error) {
+      if (isAxiosError(error)) {
+        const axiosError = error;
+        throw axiosError.response?.data || axiosError;
+      } else {
+        throw error;
+      }
+    }
+  }
+};
+
+// src/model/notification/index.ts
+var notification_exports = {};
+__export(notification_exports, {
+  CriteriaSchema: () => CriteriaSchema,
+  CriteriaType: () => CriteriaType,
+  Endpoints: () => Endpoints,
+  Frequency: () => Frequency,
+  HistorySchema: () => HistorySchema,
+  NotificationDetailSchema: () => NotificationDetailSchema,
+  NotificationItemSchema: () => NotificationItemSchema,
+  RecurrenceRuleSchema: () => RecurrenceRuleSchema,
+  Status: () => Status,
+  TransportType: () => TransportType,
+  TriggerSchema: () => TriggerSchema,
+  WeekDay: () => WeekDay
+});
+
+// src/model/notification/Notification.schema.ts
+import { z } from "zod";
+var Frequency = /* @__PURE__ */ ((Frequency2) => {
+  Frequency2["DAILY"] = "daily";
+  Frequency2["WEEKLY"] = "weekly";
+  Frequency2["MONTHLY"] = "monthly";
+  return Frequency2;
+})(Frequency || {});
+var WeekDay = /* @__PURE__ */ ((WeekDay2) => {
+  WeekDay2[WeekDay2["MONDAY"] = 1] = "MONDAY";
+  WeekDay2[WeekDay2["TUESDAY"] = 2] = "TUESDAY";
+  WeekDay2[WeekDay2["WEDNESDAY"] = 3] = "WEDNESDAY";
+  WeekDay2[WeekDay2["THURSDAY"] = 4] = "THURSDAY";
+  WeekDay2[WeekDay2["FRIDAY"] = 5] = "FRIDAY";
+  WeekDay2[WeekDay2["SATURDAY"] = 6] = "SATURDAY";
+  WeekDay2[WeekDay2["SUNDAY"] = 7] = "SUNDAY";
+  return WeekDay2;
+})(WeekDay || {});
+var CriteriaType = /* @__PURE__ */ ((CriteriaType2) => {
+  CriteriaType2["AllUsers"] = "allUsers";
+  CriteriaType2["NoProjects"] = "noProjects";
+  CriteriaType2["NoSubscription"] = "noSubscription";
+  CriteriaType2["UsersFromTier"] = "usersFromTier";
+  return CriteriaType2;
+})(CriteriaType || {});
+var TransportType = /* @__PURE__ */ ((TransportType2) => {
+  TransportType2["Push"] = "push";
+  TransportType2["Email"] = "email";
+  return TransportType2;
+})(TransportType || {});
+var Status = /* @__PURE__ */ ((Status3) => {
+  Status3["SCHEDULED"] = "scheduled";
+  Status3["RUNNING"] = "running";
+  Status3["COMPLETED"] = "completed";
+  Status3["FAILED"] = "failed";
+  Status3["PAUSED"] = "paused";
+  Status3["CANCELLED"] = "cancelled";
+  Status3["ACTIVE"] = "active";
+  Status3["EXPIRED"] = "expired";
+  return Status3;
+})(Status || {});
+var NotificationItemSchema = z.object({
+  id: z.string(),
+  userId: z.string(),
+  triggerId: z.string().optional(),
+  title: z.string(),
+  body: z.string(),
+  status: z.enum(["failed", "delivered", "deleted"]),
+  deliveredAt: z.number(),
+  openedAt: z.number().optional(),
+  deletedAt: z.number().optional(),
+  cta: z.object({ label: z.string(), url: z.string().url() }).optional(),
+  metadata: z.record(z.union([z.string(), z.number()])),
+  error: z.string().optional()
+});
+var NotificationDetailSchema = NotificationItemSchema.pick({
+  title: true,
+  body: true,
+  userId: true,
+  metadata: true
+});
+var CriteriaSchema = z.object({
+  type: z.nativeEnum(CriteriaType),
+  params: z.record(z.any())
+});
+var HistorySchema = z.object({
+  batchId: z.string(),
+  executedAt: z.number(),
+  timezone: z.string(),
+  status: z.enum(["success", "failed", "info", "warn"]),
+  users: z.object({
+    total: z.number(),
+    success: z.number(),
+    error: z.number()
+  }),
+  errorList: z.array(
+    z.object({
+      token: z.string(),
+      error: z.string()
+    })
+  ).optional(),
+  executionTimeDuration: z.number().optional()
+});
+var RecurrenceRuleSchema = z.object({
+  frequency: z.nativeEnum(Frequency),
+  interval: z.number(),
+  weekDays: z.array(z.nativeEnum(WeekDay)).optional(),
+  dayOfMonth: z.number().optional(),
+  endDate: z.string().optional(),
+  ocurrences: z.number().optional()
+});
+var TriggerSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  description: z.string(),
+  transportType: z.array(z.nativeEnum(TransportType)),
+  notification: NotificationDetailSchema,
+  history: z.array(HistorySchema).optional(),
+  status: z.nativeEnum(Status),
+  recurrence: RecurrenceRuleSchema.optional(),
+  timezone: z.string().nullable().optional(),
+  tenantIds: z.array(z.string()).optional(),
+  executionDate: z.string().optional(),
+  timeOfDay: z.string(),
+  criteria: CriteriaSchema,
+  nextExecution: z.number().optional(),
+  createdAt: z.number().optional(),
+  modified: z.number().optional()
+});
+
+// src/model/notification/Notification.api.ts
+var Endpoints = {
+  Create: { uri: "/notifications/trigger/", method: "POST" },
+  List: { uri: "/notifications/trigger/list/", method: "GET" },
+  Update: { uri: "/notifications/trigger/:id/", method: "PUT" },
+  Delete: { uri: "/notifications/trigger/:id/", method: "DELETE" },
+  Push: { uri: "/notifications/push/", method: "POST" },
+  ListNotifications: { uri: "/notifications/list/", method: "GET" },
+  MarkAsRead: { uri: "/notifications/:id/read/", method: "PUT" },
+  ClearNotifications: { uri: "/notifications/clear/", method: "DELETE" }
+};
+
+// src/api/Notification.api.ts
+var NotificationAPI = class {
+  constructor(env) {
+    this.env = env;
+    this.clientHTTP = new HTTPClient();
+  }
+  async clearNotifications(ctx) {
+    const endpointData = Endpoints.ClearNotifications;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpointData.uri,
+      endpointData.method,
+      null,
+      ctx
+    );
+    return data;
+  }
+  async markAsRead(ctx, id) {
+    const endpointData = Endpoints.MarkAsRead;
+    const endpoint = endpointData.uri.replace(":id", id);
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpoint,
+      endpointData.method,
+      null,
+      ctx
+    );
+    return data;
+  }
+  async getNotifications(ctx) {
+    const endpointData = Endpoints.ListNotifications;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpointData.uri,
+      endpointData.method,
+      null,
+      ctx
+    );
+    return data;
+  }
+  async deleteTrigger(ctx, triggerId) {
+    const endpointData = Endpoints.Delete;
+    const endpoint = endpointData.uri.replace(":id", triggerId);
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpoint,
+      endpointData.method,
+      null,
+      ctx
+    );
+    return data;
+  }
+  async updateTrigger(ctx, triggerId, t) {
+    const endpointData = Endpoints.Update;
+    const endpoint = endpointData.uri.replace(":id", triggerId);
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpoint,
+      endpointData.method,
+      t,
+      ctx
+    );
+    return data;
+  }
+  async createTrigger(ctx, t) {
+    const endpointData = Endpoints.Create;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpointData.uri,
+      endpointData.method,
+      t,
+      ctx
+    );
+    return data;
+  }
+  async getTriggers(ctx) {
+    const endpointInfo = Endpoints.List;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpointInfo.uri,
+      endpointInfo.method,
+      null,
+      ctx
+    );
+    return data;
+  }
+  async push(ctx, notification) {
+    const endpointInfo = Endpoints.Push;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpointInfo.uri,
+      endpointInfo.method,
+      notification,
+      ctx
+    );
+    return data.success;
+  }
+};
+var Notification_api_default = NotificationAPI;
+
+// src/api/Prompt.api.ts
+var PromptAPI = class {
+  constructor(env) {
+    this.env = env;
+    this.clientHTTP = new HTTPClient();
+  }
+  async getPrompt(context) {
+    const endpointInfo = prompt_exports.Endpoints.GetPrompt;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpointInfo.uri,
+      endpointInfo.method,
+      null,
+      context
+    );
+    return data;
+  }
+  async getScripts(context) {
+    const endpointInfo = prompt_exports.Endpoints.ListScript;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpointInfo.uri,
+      endpointInfo.method,
+      null,
+      context
+    );
+    return data;
+  }
+  async updateScript(c, id, script) {
+    const endpointData = prompt_exports.Endpoints.UpdateScript;
+    const endpoint = endpointData.uri.replace(":id", id);
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpoint,
+      endpointData.method,
+      { ...script },
+      c
+    );
+    return data;
+  }
+  async addScript(c, script) {
+    const endpointInfo = prompt_exports.Endpoints.AddScript;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpointInfo.uri,
+      endpointInfo.method,
+      { ...script },
+      c
+    );
+    return data;
+  }
+  async deleteScript(c, id) {
+    const endpointData = prompt_exports.Endpoints.DeleteScript;
+    const endpoint = endpointData.uri.replace(":id", id);
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpoint,
+      endpointData.method,
+      null,
+      c
+    );
+    return data;
+  }
+};
+var Prompt_api_default = PromptAPI;
+
+// src/api/Subscription.api.ts
+var SubscriptionAPI = class {
+  constructor(env) {
+    this.env = env;
+    this.clientHTTP = new HTTPClient();
+  }
+  async updatePlan(ctx, planId) {
+    const endpointInfo = subscription_exports.Endpoints.UpdatePlan;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpointInfo.uri,
+      endpointInfo.method,
+      { planId },
+      ctx
+    );
+    return data;
+  }
+  async getProduct(id, context) {
+    const endpointInfo = subscription_exports.Endpoints.GetProduct;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      `${endpointInfo.uri}/${id}`,
+      endpointInfo.method,
+      null,
+      context
+    );
+    return data;
+  }
+  async getCharges(ctx) {
+    const endpointInfo = subscription_exports.Endpoints.GetCharges;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      `${endpointInfo.uri}`,
+      endpointInfo.method,
+      null,
+      ctx
+    );
+    return data;
+  }
+  async getSubscription(context, userId) {
+    const endpointInfo = subscription_exports.Endpoints.GetActiveSubscription;
+    let uri = endpointInfo.uri;
+    let method = endpointInfo.method;
+    if (userId) {
+      const endpointData = subscription_exports.Endpoints.GetUserActiveSubscription;
+      const endpoint = endpointData.uri.replace(":userId", userId);
+      uri = endpoint;
+      method = endpointData.method;
+    }
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      uri,
+      method,
+      null,
+      context
+    );
+    return data;
+  }
+  async charge(ctx) {
+    const endpointInfo = subscription_exports.Endpoints.Charge;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpointInfo.uri,
+      endpointInfo.method,
+      null,
+      ctx
+    );
+    return data.success;
+  }
+  async pause(ctx) {
+    const endpointInfo = subscription_exports.Endpoints.Pause;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpointInfo.uri,
+      endpointInfo.method,
+      null,
+      ctx
+    );
+    return data;
+  }
+  async resume(ctx) {
+    const endpointInfo = subscription_exports.Endpoints.Resume;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpointInfo.uri,
+      endpointInfo.method,
+      null,
+      ctx
+    );
+    return data;
+  }
+  async getProducts(ctx) {
+    const endpointInfo = ctx ? subscription_exports.Endpoints.GetProductsByUser : subscription_exports.Endpoints.GetProducts;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpointInfo.uri,
+      endpointInfo.method,
+      null,
+      ctx
+    );
+    return data;
+  }
+  async createCheckout(planId, ctx) {
+    const endpointInfo = subscription_exports.Endpoints.Checkout;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpointInfo.uri,
+      endpointInfo.method,
+      { planId },
+      ctx
+    );
+    return data.url;
+  }
+};
+var Subscription_api_default = SubscriptionAPI;
+
+// src/api/Tenant.api.ts
+var TenantAPI = class {
+  constructor(env) {
+    this.env = env;
+    this.clientHTTP = new HTTPClient();
+  }
+  async getByInviteCode(inviteCode, context) {
+    const endpointInfo = tenant_exports.Endpoints.GetByInviteCode;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      `${endpointInfo.uri}/${inviteCode}`,
+      endpointInfo.method,
+      null,
+      context
+    );
+    return data;
+  }
+  async getTenant(context, tenantId) {
+    const endpointInfo = tenant_exports.Endpoints.GetTenant;
+    let uri = endpointInfo.uri;
+    let method = endpointInfo.method;
+    if (tenantId) {
+      const endpointData = tenant_exports.Endpoints.GetTenantById;
+      const endpoint = endpointData.uri.replace(":tenantId", tenantId);
+      uri = endpoint;
+      method = endpointData.method;
+    }
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      uri,
+      method,
+      null,
+      context
+    );
+    return data;
+  }
+  async create(t, context) {
+    const endpointInfo = tenant_exports.Endpoints.CreateTenant;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      `${endpointInfo.uri}`,
+      endpointInfo.method,
+      { ...t },
+      context
+    );
+    return data;
+  }
+  async list(context) {
+    const endpointInfo = tenant_exports.Endpoints.ListAll;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      `${endpointInfo.uri}`,
+      endpointInfo.method,
+      null,
+      context
+    );
+    return data;
+  }
+  async update(tenantId, updateData, context) {
+    const endpointInfo = tenant_exports.Endpoints.UpdateTenant;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      `${endpointInfo.uri}`,
+      endpointInfo.method,
+      { tenantId, data: updateData },
+      context
+    );
+    return data;
+  }
+};
+var Tenant_api_default = TenantAPI;
+
+// src/util/parseQuery.ts
+var buildQueryString = (query) => {
+  const params = {};
+  if (query.perPage) {
+    params["perPage"] = [String(query.perPage)];
+  }
+  if (query.cursor !== void 0 && query.cursor !== null) {
+    params["cursor"] = [String(query.cursor)];
+  }
+  if (query.orderBy) {
+    params["orderBy"] = [
+      `${String(query.orderBy.field)}:${query.orderBy.direction}`
+    ];
+  }
+  if (query.wheres && query.wheres.length > 0) {
+    params["wheres"] = query.wheres.map(
+      (w) => `${String(w.field)}:${String(w.operation)}:${String(w.value)}`
+    );
+  }
+  const queryString = Object.entries(params).flatMap(
+    ([key, values]) => values.map((value) => `${key}=${encodeURIComponent(value)}`)
+  ).join("&");
+  return queryString ? `?${queryString}` : "";
+};
+
+// src/api/User.api.ts
+var UserAPI = class {
+  constructor(env) {
+    this.env = env;
+    this.clientHTTP = new HTTPClient();
+  }
+  async search(ctx, query) {
+    const endpointData = user_exports.Endpoints.Search;
+    const qs = buildQueryString(query);
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      `${endpointData.uri}${qs}`,
+      endpointData.method,
+      null,
+      ctx
+    );
+    return data;
+  }
+  async deleteAccount(ctx) {
+    const endpointData = user_exports.Endpoints.DeleteAccount;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpointData.uri,
+      endpointData.method,
+      null,
+      ctx
+    );
+    return data.success;
+  }
+  async createIntegrationToken(ctx) {
+    const endpointData = user_exports.Endpoints.CreateToken;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      `${endpointData.uri}`,
+      endpointData.method,
+      null,
+      ctx
+    );
+    return data.token;
+  }
+  async getIntegrationToken(ctx) {
+    const endpointData = user_exports.Endpoints.GetIntegrationToken;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      `${endpointData.uri}`,
+      endpointData.method,
+      null,
+      ctx
+    );
+    return data.token;
+  }
+  async sendValidationCode(email) {
+    const endpointData = user_exports.Endpoints.SendValidationCode;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      `${endpointData.uri}?email=${email}`,
+      endpointData.method
+    );
+    return data.success;
+  }
+  async changePassword(email, pass, passConfirm, code) {
+    const endpointData = user_exports.Endpoints.ChangePassword;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpointData.uri,
+      endpointData.method,
+      { email, pass, passConfirm, code }
+    );
+    return data.success;
+  }
+  async changeEmail(ctx, email, code) {
+    const endpointData = user_exports.Endpoints.ChangeEmail;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpointData.uri,
+      endpointData.method,
+      { email, code },
+      ctx
+    );
+    return data.success;
+  }
+  async confirmCode(email, code, keepCode) {
+    const endpointData = user_exports.Endpoints.ConfirmCode;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      `${endpointData.uri}?email=${email}&code=${code}&keepCode=${keepCode}`,
+      endpointData.method
+    );
+    return data.success;
+  }
+  async isEmailAvaliable(email) {
+    const endpointData = user_exports.Endpoints.IsEmailAvaliable;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      `${endpointData.uri}?email=${email}`,
+      endpointData.method
+    );
+    return data.isValid;
+  }
+  async update(context, update) {
+    const endpointData = user_exports.Endpoints.UpdateUser;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      `${endpointData.uri}`,
+      endpointData.method,
+      { ...update },
+      context
+    );
+    return data.isValid;
+  }
+  async getBindedUsers(context) {
+    const endpointData = user_exports.Endpoints.GetBindedUsers;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      `${endpointData.uri}`,
+      endpointData.method,
+      null,
+      context
+    );
+    return data;
+  }
+  async setup(context) {
+    const endpointData = user_exports.Endpoints.Setup;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      `${endpointData.uri}`,
+      endpointData.method,
+      null,
+      context
+    );
+    return data.success;
+  }
+  async authenticate(email, password, system) {
+    const endpointData = user_exports.Endpoints.Authenticate;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      `${endpointData.uri}`,
+      endpointData.method,
+      { system, email, password }
+    );
+    return data.token;
+  }
+  async createUser(email, name, password, passwordConfirmation, profession, invitationCode) {
+    const endpointData = user_exports.Endpoints.CreateUser;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpointData.uri,
+      endpointData.method,
+      {
+        email,
+        name,
+        password,
+        passwordConfirmation,
+        profession,
+        invitationCode
+      },
+      null
+    );
+    return data;
+  }
+  async getUserInfo(context) {
+    const endpointData = user_exports.Endpoints.GetUserInfo;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpointData.uri,
+      endpointData.method,
+      null,
+      context
+    );
+    return data;
+  }
+};
+var User_api_default = UserAPI;
+
+// src/api/Track.api.ts
+var TrackAPI = class {
+  constructor(env) {
+    this.env = env;
+    this.clientHTTP = new HTTPClient();
+  }
+  async send(t) {
+    const endpointInfo = track_exports.Endpoints.Track;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      `${endpointInfo.uri}`,
+      endpointInfo.method,
+      t
+    );
+    return data;
+  }
+};
+var Track_api_default = TrackAPI;
+
+// src/model/email/index.ts
+var email_exports = {};
+__export(email_exports, {
+  EmailSchema: () => EmailSchema,
+  Endpoints: () => Endpoints2
+});
+
+// src/model/email/Email.schema.ts
+import { z as z2 } from "zod";
+var EmailSchema = z2.object({
+  to: z2.string().email().optional(),
+  subject: z2.string(),
+  body: z2.string()
+});
+
+// src/model/email/Email.api.ts
+var Endpoints2 = {
+  SendEmail: {
+    uri: "/emails/public/send",
+    method: "POST"
+  }
+};
+
+// src/api/Email.api.ts
+var EmailAPI = class {
+  constructor(env) {
+    this.env = env;
+    this.clientHTTP = new HTTPClient();
+  }
+  async send(email, ctx) {
+    const endpointInfo = Endpoints2.SendEmail;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpointInfo.uri,
+      endpointInfo.method,
+      email,
+      ctx
+    );
+    return data.result;
+  }
+};
+var Email_api_default = EmailAPI;
+
+// src/model/project/index.ts
+var project_exports = {};
+__export(project_exports, {
+  CaptionStyle: () => CaptionStyle,
+  Endpoints: () => Endpoints3,
+  ProjectSchema: () => ProjectSchema,
+  Status: () => Status2,
+  Styles: () => Styles,
+  TimelineItemSchema: () => TimelineItemSchema
+});
+
+// src/model/project/Project.schema.ts
+import { z as z4 } from "zod";
+
+// src/model/asset/index.ts
+var asset_exports = {};
+__export(asset_exports, {
+  AssetSchema: () => AssetSchema
+});
+
+// src/model/asset/Asset.schema.ts
+import { z as z3 } from "zod";
+var AssetSchema = z3.object({
+  assetId: z3.string(),
+  fileName: z3.string(),
+  extension: z3.string(),
+  fileSize: z3.number(),
+  assetUrl: z3.string().url(),
+  thumbnailUrl: z3.string().url(),
+  type: z3.string(),
+  duration: z3.number().optional(),
+  progress: z3.number().optional(),
+  error: z3.string().optional(),
+  authorId: z3.string(),
+  uploadedAt: z3.number()
+});
+
+// src/model/project/Project.schema.ts
+var Status2 = /* @__PURE__ */ ((Status3) => {
+  Status3[Status3["SUBMITTED"] = 0] = "SUBMITTED";
+  Status3[Status3["EDITING"] = 1] = "EDITING";
+  Status3[Status3["COMPLETED"] = 2] = "COMPLETED";
+  Status3[Status3["WAITING_APPROVE"] = 3] = "WAITING_APPROVE";
+  Status3[Status3["DENIED"] = 4] = "DENIED";
+  Status3[Status3["REVISIONING"] = 5] = "REVISIONING";
+  Status3[Status3["CANCELLED"] = 6] = "CANCELLED";
+  Status3[Status3["SCHEDULED"] = 7] = "SCHEDULED";
+  return Status3;
+})(Status2 || {});
+var CaptionStyle = /* @__PURE__ */ ((CaptionStyle2) => {
+  CaptionStyle2[CaptionStyle2["ONE_LINE"] = 1] = "ONE_LINE";
+  CaptionStyle2[CaptionStyle2["ONE_LINE_EMOJIS"] = 2] = "ONE_LINE_EMOJIS";
+  CaptionStyle2[CaptionStyle2["TWO_LINES"] = 5] = "TWO_LINES";
+  CaptionStyle2[CaptionStyle2["TWO_LINES_EMOJIS"] = 3] = "TWO_LINES_EMOJIS";
+  CaptionStyle2[CaptionStyle2["HOME_HIGHLIGHT"] = 4] = "HOME_HIGHLIGHT";
+  return CaptionStyle2;
+})(CaptionStyle || {});
+var StatusSchema = z4.nativeEnum(Status2);
+var CaptionStyleStatus = z4.nativeEnum(CaptionStyle);
+var Styles = [
+  { value: 1 /* ONE_LINE */, label: "One Line" },
+  { value: 2 /* ONE_LINE_EMOJIS */, label: "One Line + Emojis" },
+  { value: 5 /* TWO_LINES */, label: "Two Lines" },
+  { value: 3 /* TWO_LINES_EMOJIS */, label: "Two Lines + Emojis" },
+  { value: 4 /* HOME_HIGHLIGHT */, label: "Home Tour" }
+];
+var TimelineItemSchema = z4.object({
+  status: z4.nativeEnum(Status2),
+  title: z4.string(),
+  description: z4.string(),
+  timestamp: z4.number(),
+  metadata: z4.record(z4.any())
+});
+var ProjectSchema = z4.object({
+  id: z4.string(),
+  title: z4.string(),
+  instructions: z4.string(),
+  submitMonth: z4.string(),
+  captionStyle: z4.nativeEnum(CaptionStyle),
+  finalVideoId: z4.string().optional(),
+  thumbnailUrl: z4.string().optional(),
+  modified: z4.number(),
+  captionSuggestion: z4.string().optional(),
+  editorId: z4.string(),
+  userId: z4.string(),
+  assets: z4.array(AssetSchema).optional(),
+  expirationTimestamp: z4.number(),
+  isFree: z4.boolean().optional(),
+  timeline: z4.array(TimelineItemSchema),
+  submitTimestamp: z4.number(),
+  tenantId: z4.string().optional(),
+  status: z4.nativeEnum(Status2)
+});
+
+// src/model/project/Project.api.ts
+var Endpoints3 = {
+  List: { uri: "/projects/list", method: "GET" },
+  GetNext: { uri: "/projects/:userId/next", method: "GET" },
+  CreateProject: { uri: "/projects/create", method: "POST" },
+  FindOne: { uri: `/projects/:projectId/`, method: "GET" },
+  GetGoals: { uri: `/projects/goals/list/`, method: "GET" },
+  Review: { uri: "/projects/:projectId/review/", method: "POST" },
+  Cancel: { uri: "/projects/:projectId/cancel/", method: "DELETE" },
+  StartEdition: { uri: "/projects/:projectId/start/", method: "PUT" },
+  SendToApproval: {
+    uri: "/projects/:projectId/sendToApproval/",
+    method: "PUT"
+  },
+  IsEligibleForFreeProject: {
+    uri: "/projects/free/allowed/",
+    method: "GET"
+  },
+  Approve: { uri: "/projects/:projectId/approve/", method: "POST" },
+  Unschedule: { uri: "/projects/:projectId/unschedule/", method: "POST" },
+  Rollback: { uri: "/projects/:projectId/rollback/", method: "POST" },
+  Deny: { uri: "/projects/:projectId/deny/", method: "POST" },
+  GetUserHistory: { uri: "/projects/user/:userId/history/", method: "GET" }
+};
+
+// src/api/Project.api.ts
+var ProjectAPI = class {
+  constructor(env) {
+    this.permissions = {
+      isEligibleForFreeProject: async (ctx) => {
+        const endpointData = Endpoints3.IsEligibleForFreeProject;
+        const data = await this.clientHTTP.makeRequest(
+          this.env,
+          endpointData.uri,
+          endpointData.method,
+          null,
+          ctx
+        );
+        return data.canCreate;
+      }
+    };
+    this.env = env;
+    this.clientHTTP = new HTTPClient();
+  }
+  async getNext(ctx, userId) {
+    const endpointData = Endpoints3.GetNext;
+    const endpoint = endpointData.uri.replace(":userId", userId);
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpoint,
+      endpointData.method,
+      null,
+      ctx
+    );
+    return data;
+  }
+  async getUserHistory(context, userId) {
+    const endpointData = Endpoints3.GetUserHistory;
+    const endpoint = endpointData.uri.replace(":userId", userId);
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpoint,
+      endpointData.method,
+      null,
+      context
+    );
+    return data;
+  }
+  async find(context, projectId) {
+    const endpointData = Endpoints3.FindOne;
+    const endpoint = endpointData.uri.replace(":projectId", projectId);
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpoint,
+      endpointData.method,
+      null,
+      context
+    );
+    return data;
+  }
+  async create(context, createData) {
+    const endpointData = Endpoints3.CreateProject;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpointData.uri,
+      endpointData.method,
+      createData,
+      context
+    );
+    return data;
+  }
+  async review(ctx, pId, revision) {
+    const endpointData = Endpoints3.Review;
+    const endpoint = endpointData.uri.replace(":projectId", pId);
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpoint,
+      endpointData.method,
+      { revision },
+      ctx
+    );
+    return data.success;
+  }
+  async cancel(ctx, projectId) {
+    const endpointData = Endpoints3.Cancel;
+    const endpoint = endpointData.uri.replace(":projectId", projectId);
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpoint,
+      endpointData.method,
+      null,
+      ctx
+    );
+    return data.success;
+  }
+  async list(context, query) {
+    const endpointData = Endpoints3.List;
+    const qs = buildQueryString(query);
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      `${endpointData.uri}${qs}`,
+      endpointData.method,
+      null,
+      context
+    );
+    return data;
+  }
+  async deny(ctx, pId, denyFB, categories) {
+    const endpointData = Endpoints3.Deny;
+    const endpoint = endpointData.uri.replace(":projectId", pId);
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpoint,
+      endpointData.method,
+      { denyFeedback: denyFB, categories: categories || [] },
+      ctx
+    );
+    return data.success;
+  }
+  async unschedule(context, projectId) {
+    const endpointData = Endpoints3.Unschedule;
+    const endpoint = endpointData.uri.replace(":projectId", projectId);
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpoint,
+      endpointData.method,
+      null,
+      context
+    );
+    return data.success;
+  }
+  async rollback(context, projectId) {
+    const endpointData = Endpoints3.Rollback;
+    const endpoint = endpointData.uri.replace(":projectId", projectId);
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpoint,
+      endpointData.method,
+      null,
+      context
+    );
+    return data.success;
+  }
+  async start(context, projectId) {
+    const endpointData = Endpoints3.StartEdition;
+    const endpoint = endpointData.uri.replace(":projectId", projectId);
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpoint,
+      endpointData.method,
+      null,
+      context
+    );
+    return data.success;
+  }
+  async approve(ctx, pId, approve) {
+    const endpointData = Endpoints3.Approve;
+    const endpoint = endpointData.uri.replace(":projectId", pId);
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpoint,
+      endpointData.method,
+      approve,
+      ctx
+    );
+    return data.success;
+  }
+  async sendToApproval(context, projectId, approval) {
+    const endpointData = Endpoints3.SendToApproval;
+    const endpoint = endpointData.uri.replace(":projectId", projectId);
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpoint,
+      endpointData.method,
+      approval,
+      context
+    );
+    return data.success;
+  }
+};
+var Project_api_default = ProjectAPI;
+
+// src/model/goal/index.ts
+var goal_exports = {};
+__export(goal_exports, {
+  DailyMilestoneSchema: () => DailyMilestoneSchema,
+  Endpoints: () => Endpoints4,
+  GoalSchema: () => GoalSchema,
+  WeeklyMilestoneSchema: () => WeeklyMilestoneSchema
+});
+
+// src/model/goal/Goal.schema.ts
+import { z as z5 } from "zod";
+var DailyMilestoneSchema = z5.object({
+  id: z5.string(),
+  date: z5.string(),
+  target: z5.number(),
+  progress: z5.number()
+});
+var WeeklyMilestoneSchema = z5.object({
+  id: z5.string(),
+  week: z5.string(),
+  target: z5.number(),
+  progress: z5.number(),
+  dailyMilestones: z5.array(DailyMilestoneSchema)
+});
+var GoalSchema = z5.object({
+  id: z5.string(),
+  editorId: z5.string(),
+  month: z5.string(),
+  // ex: "2024-04"
+  target: z5.number(),
+  progress: z5.number(),
+  createdAt: z5.number(),
+  weeklyMilestones: z5.array(WeeklyMilestoneSchema)
+});
+
+// src/model/goal/Goal.api.ts
+var Endpoints4 = {
+  GetGoals: { uri: `/projects/goals/list/`, method: "GET" }
+};
+
+// src/api/Goal.api.ts
+var GoalAPI = class {
+  constructor(env) {
+    this.env = env;
+    this.clientHTTP = new HTTPClient();
+  }
+  async getGoals(context) {
+    const endpointData = Endpoints4.GetGoals;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpointData.uri,
+      endpointData.method,
+      null,
+      context
+    );
+    return data;
+  }
+};
+var Goal_api_default = GoalAPI;
+
+// src/model/app-config/AppConfig.api.ts
+var Endpoints5 = {
+  Version: {
+    uri: "/app-config/public/version/latest",
+    method: "GET"
+  }
+};
+
+// src/api/AppConfig.api.ts
+var AppConfigAPI = class {
+  constructor(env) {
+    this.env = env;
+    this.clientHTTP = new HTTPClient();
+  }
+  async version() {
+    const endpointInfo = Endpoints5.Version;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpointInfo.uri,
+      endpointInfo.method
+    );
+    return data.version;
+  }
+};
+var AppConfig_api_default = AppConfigAPI;
+
+// src/model/note/index.ts
+var note_exports = {};
+__export(note_exports, {
+  Endpoints: () => Endpoints6,
+  NoteHistorySchema: () => NoteHistorySchema,
+  NoteSchema: () => NoteSchema
+});
+
+// src/model/note/Note.schema.ts
+import { z as z6 } from "zod";
+var NoteHistorySchema = z6.object({
+  type: z6.enum([
+    "created",
+    "updated",
+    "deleted",
+    "asset-added",
+    "asset-removed"
+  ]),
+  actorEmail: z6.string().email(),
+  timestamp: z6.number(),
+  details: z6.string().optional()
+});
+var NoteSchema = z6.object({
+  id: z6.string(),
+  userId: z6.string(),
+  authorEmail: z6.string().email(),
+  assets: z6.array(AssetSchema),
+  title: z6.string(),
+  content: z6.string(),
+  createdAt: z6.number(),
+  modified: z6.number(),
+  history: z6.array(NoteHistorySchema).optional()
+});
+
+// src/model/note/Note.api.ts
+var Endpoints6 = {
+  GetNotes: {
+    uri: "/user-context/notes/user/:userId/",
+    method: "GET"
+  },
+  AddNote: {
+    uri: "/user-context/notes/",
+    method: "PUT"
+  },
+  DeleteNote: {
+    uri: "/user-context/notes/:id/",
+    method: "DELETE"
+  },
+  UpdateNote: {
+    uri: "/user-context/notes/:id/",
+    method: "POST"
+  }
+};
+
+// src/api/Note.api.ts
+var NoteAPI = class {
+  constructor(env) {
+    this.env = env;
+    this.clientHTTP = new HTTPClient();
+  }
+  async list(c, userId) {
+    const endpointData = Endpoints6.GetNotes;
+    const endpoint = endpointData.uri.replace(":userId", userId);
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpoint,
+      endpointData.method,
+      null,
+      c
+    );
+    return data;
+  }
+  async add(c, note) {
+    const endpointData = Endpoints6.AddNote;
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpointData.uri,
+      endpointData.method,
+      note,
+      c
+    );
+    return data;
+  }
+  async update(c, id, toUpdate) {
+    const endpointData = Endpoints6.UpdateNote;
+    const endpoint = endpointData.uri.replace(":id", id);
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpoint,
+      endpointData.method,
+      toUpdate,
+      c
+    );
+    return data;
+  }
+  async delete(c, id) {
+    const endpointData = Endpoints6.DeleteNote;
+    const endpoint = endpointData.uri.replace(":id", id);
+    const data = await this.clientHTTP.makeRequest(
+      this.env,
+      endpoint,
+      endpointData.method,
+      null,
+      c
+    );
+    return data;
+  }
+};
+var Note_api_default = NoteAPI;
+
+// src/model/Api.ts
+var ShredAPI = class {
+  constructor(env) {
+    this.user = new User_api_default(env);
+    this.goal = new Goal_api_default(env);
+    this.prompt = new Prompt_api_default(env);
+    this.subscription = new Subscription_api_default(env);
+    this.pushNotification = new Notification_api_default(env);
+    this.email = new Email_api_default(env);
+    this.tenant = new Tenant_api_default(env);
+    this.project = new Project_api_default(env);
+    this.app = new AppConfig_api_default(env);
+    this.track = new Track_api_default(env);
+    this.note = new Note_api_default(env);
+  }
+};
+
+// src/model/exceptions/index.ts
+var exceptions_exports = {};
+__export(exceptions_exports, {
+  default: () => exceptions_default
+});
+
+// src/model/exceptions/ShredException.ts
+var ShredException = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.name = "ShredException";
+    this.status = status;
+  }
+};
+
+// src/model/exceptions/ConflictException.ts
+var ConflictException = class extends ShredException {
+  constructor(message) {
+    super(message, 409);
+    this.name = "ConflictException";
+  }
+};
+
+// src/model/exceptions/InvalidArgumentException.ts
+var InvalidArgumentException = class extends ShredException {
+  constructor(message) {
+    super(message, 400);
+    this.name = "InvalidArgumentException";
+  }
+};
+
+// src/model/exceptions/ResourceNotFoundException.ts
+var ResourceNotFoundException = class extends ShredException {
+  constructor(message) {
+    super(message, 404);
+    this.name = "ResourceNotFoundException";
+  }
+};
+
+// src/model/exceptions/UnauthorizedException.ts
+var UnauthorizedException = class extends ShredException {
+  constructor(message) {
+    super(message, 401);
+    this.name = "UnauthorizedException";
+  }
+};
+
+// src/model/exceptions/ForbiddenException.ts
+var ForbiddenException = class extends ShredException {
+  constructor(message) {
+    super(message, 403);
+    this.name = "ForbiddenException";
+  }
+};
+
+// src/model/exceptions/index.ts
+var Exceptions = {
+  ConflictException,
+  InvalidArgumentException,
+  ResourceNotFoundException,
+  ShredException,
+  UnauthorizedException,
+  ForbiddenException
+};
+var exceptions_default = Exceptions;
+
+// src/model/prompt/index.ts
+var prompt_exports = {};
+__export(prompt_exports, {
+  CategorySchema: () => CategorySchema,
+  Endpoints: () => Endpoints7,
+  PromptSchema: () => PromptSchema,
+  ScriptSchema: () => ScriptSchema
+});
+
+// src/model/prompt/Prompt.schema.ts
+import { z as z7 } from "zod";
+var ScriptSchema = z7.object({
+  id: z7.string(),
+  title: z7.string(),
+  content: z7.string(),
+  tags: z7.array(z7.string()).optional(),
+  userId: z7.string().optional()
+});
+var CategorySchema = z7.object({
+  id: z7.string(),
+  title: z7.string(),
+  pictureUrl: z7.string().url(),
+  backgroundColor: z7.string(),
+  active: z7.boolean(),
+  scripts: z7.array(ScriptSchema)
+});
+var PromptSchema = z7.object({
+  id: z7.string(),
+  tenantId: z7.string(),
+  categories: z7.array(CategorySchema)
+});
+
+// src/model/prompt/Prompt.api.ts
+var Endpoints7 = {
+  GetPrompt: {
+    uri: "/prompts/getPrompt",
+    method: "GET"
+  },
+  AddScript: {
+    uri: "/prompts/script/new/",
+    method: "POST"
+  },
+  DeleteScript: {
+    uri: "/prompts/script/:id/delete/",
+    method: "DELETE"
+  },
+  ListScript: {
+    uri: "/prompts/script/list/",
+    method: "GET"
+  },
+  UpdateScript: {
+    uri: "/prompts/script/:id/update/",
+    method: "PUT"
+  }
+};
+
+// src/model/tenant/index.ts
+var tenant_exports = {};
+__export(tenant_exports, {
+  Endpoints: () => Endpoints8,
+  PreferencesSchema: () => PreferencesSchema,
+  TenantSchema: () => TenantSchema
+});
+
+// src/model/tenant/Tenant.schema.ts
+import { z as z9 } from "zod";
+
+// src/model/subscription/Subscription.schema.ts
+import { z as z8 } from "zod";
+var Type = /* @__PURE__ */ ((Type2) => {
+  Type2[Type2["CUSTOMER_SUBSCRIPTION"] = 0] = "CUSTOMER_SUBSCRIPTION";
+  Type2[Type2["TENANT_SUBSCRIPTION"] = 1] = "TENANT_SUBSCRIPTION";
+  return Type2;
+})(Type || {});
+var SubscriptionTypeSchema = z8.nativeEnum(Type);
+var PlanSchema = z8.object({
+  id: z8.string(),
+  currency: z8.string(),
+  price: z8.string(),
+  interval: z8.string(),
+  metadata: z8.record(z8.string()),
+  subscriptionItemId: z8.string()
+});
+var DescriptionSchema = z8.object({
+  description: z8.string(),
+  subtitle: z8.string()
+});
+var ProductSchema = z8.object({
+  id: z8.string(),
+  name: z8.string(),
+  descriptions: z8.array(DescriptionSchema),
+  metadata: z8.any(),
+  plans: z8.array(PlanSchema)
+});
+var ChargeSchema = z8.object({
+  id: z8.number(),
+  created: z8.number(),
+  paid: z8.boolean(),
+  receiptUrl: z8.string(),
+  status: z8.string(),
+  price: z8.string(),
+  paymentType: z8.string(),
+  last4: z8.string().optional(),
+  brand: z8.string().optional()
+});
+var SubscriptionSchema = z8.object({
+  id: z8.string(),
+  status: z8.string(),
+  startDate: z8.number().optional(),
+  daysUntilDue: z8.number().optional(),
+  renewAutomatically: z8.boolean().optional(),
+  currentPeriodStart: z8.number().optional(),
+  currentPeriodEnd: z8.number().optional(),
+  paymentMethodId: z8.string().optional(),
+  product: ProductSchema,
+  type: z8.nativeEnum(Type).optional(),
+  plan: PlanSchema.optional()
+});
+
+// src/model/tenant/Tenant.schema.ts
+var PreferencesSchema = z9.object({
+  iconUrl: z9.string().url(),
+  logoUrl: z9.string().url(),
+  primaryColor: z9.string(),
+  secondaryColor: z9.string(),
+  guidelinesUrl: z9.string().url().optional()
+});
+var TenantSchema = z9.object({
+  id: z9.string(),
+  name: z9.string(),
+  isActive: z9.boolean(),
+  isSubscriptionActive: z9.boolean(),
+  preferences: PreferencesSchema,
+  inviteCode: z9.string(),
+  totalUsersAllowed: z9.number(),
+  currentUsersSize: z9.number().optional(),
+  chargeByEmail: z9.boolean(),
+  defaultProductId: z9.string().optional(),
+  defaultPlanId: z9.string().optional(),
+  defaultCoupomCode: z9.string().optional(),
+  allowedProducts: z9.array(z9.string()).optional(),
+  useOwnScripts: z9.boolean().optional(),
+  subscription: z9.optional(z9.lazy(() => SubscriptionSchema))
+});
+
+// src/model/tenant/Tenant.api.ts
+var Endpoints8 = {
+  GetByInviteCode: {
+    uri: "/tenants/public/invitation/",
+    method: "GET"
+  },
+  CreateTenant: {
+    uri: "/tenants/create",
+    method: "PUT"
+  },
+  GetTenant: {
+    uri: "/tenants/me",
+    method: "GET"
+  },
+  GetTenantById: {
+    uri: "/tenants/:tenantId/find",
+    method: "GET"
+  },
+  UpdateTenant: {
+    uri: "/tenants/update",
+    method: "POST"
+  },
+  ListAll: {
+    uri: "/tenants/list",
+    method: "GET"
+  }
+};
+
+// src/model/user/index.ts
+var user_exports = {};
+__export(user_exports, {
+  Endpoints: () => Endpoints9,
+  PreferencesSchema: () => PreferencesSchema2,
+  Role: () => Role,
+  System: () => System,
+  UserSchema: () => UserSchema
+});
+
+// src/model/user/User.schema.ts
+import { z as z10 } from "zod";
+var Role = /* @__PURE__ */ ((Role2) => {
+  Role2["USER"] = "User";
+  Role2["EDITOR"] = "Editor";
+  Role2["QA"] = "QA";
+  Role2["ADMIN"] = "ADMIN";
+  Role2["SYSTEM"] = "SYSTEM";
+  return Role2;
+})(Role || {});
+var System = /* @__PURE__ */ ((System2) => {
+  System2["APP"] = "APP";
+  System2["EDITOR"] = "EDITOR";
+  System2["QA"] = "QA";
+  System2["ADMIN"] = "ADMIN";
+  return System2;
+})(System || {});
+var PreferencesSchema2 = z10.object({
+  primaryColor: z10.string().optional(),
+  secondaryColor: z10.string().optional(),
+  facebookLink: z10.string().optional(),
+  instagramLink: z10.string().optional(),
+  bRoll: z10.boolean().optional(),
+  logo: z10.string().optional()
+});
+var UserSchema = z10.object({
+  id: z10.string(),
+  name: z10.string(),
+  email: z10.string().email(),
+  fcmToken: z10.string().optional(),
+  profession: z10.string().optional(),
+  photoUrl: z10.string().optional(),
+  preferences: PreferencesSchema2.optional(),
+  tenantId: z10.string().optional(),
+  editorId: z10.string().optional(),
+  timezone: z10.string().optional(),
+  experienceId: z10.string().optional(),
+  customerId: z10.string(),
+  role: z10.nativeEnum(Role)
+});
+
+// src/model/user/User.api.ts
+var Endpoints9 = {
+  ChangeEmail: { uri: "/accounts/user/changeEmail", method: "PUT" },
+  GetUserInfo: { uri: "/accounts/user/info", method: "GET" },
+  GetBindedUsers: { uri: "/accounts/binded/list", method: "GET" },
+  EnableUser: { uri: "/api/user/register", method: "POST" },
+  ChangePassword: { uri: "/accounts/public/changePassword/", method: "POST" },
+  IsEmailAvaliable: { uri: "/accounts/public/email/avaliable", method: "GET" },
+  GetIntegrationToken: { uri: "/accounts/user/getToken/", method: "GET" },
+  CreateToken: { uri: "/accounts/user/createToken/", method: "POST" },
+  ConfirmCode: { uri: "/accounts/public/email/validate", method: "POST" },
+  DeleteAccount: { uri: "/accounts/user/delete/", method: "DELETE" },
+  SendValidationCode: { uri: "/accounts/public/email/send", method: "POST" },
+  Authenticate: { uri: "/accounts/public/login", method: "POST" },
+  CreateUser: { uri: "/accounts/public/create", method: "POST" },
+  UpdateUser: { uri: "/accounts/user/update", method: "PUT" },
+  Setup: { uri: "/accounts/user/setup/", method: "POST" },
+  Search: { uri: "/accounts/users/search/", method: "GET" }
+};
+
+// src/model/subscription/index.ts
+var subscription_exports = {};
+__export(subscription_exports, {
+  ChargeSchema: () => ChargeSchema,
+  Endpoints: () => Endpoints10,
+  PlanSchema: () => PlanSchema,
+  ProductSchema: () => ProductSchema,
+  SubscriptionSchema: () => SubscriptionSchema,
+  SubscriptionTypeSchema: () => SubscriptionTypeSchema,
+  Type: () => Type
+});
+
+// src/model/subscription/Subscription.api.ts
+var Endpoints10 = {
+  GetProduct: {
+    uri: "/subscriptions/products/public/retrieve/",
+    method: "GET"
+  },
+  GetActiveSubscription: {
+    uri: "/subscriptions/active/",
+    method: "GET"
+  },
+  GetCharges: {
+    uri: "/subscriptions/payment/charge/list/",
+    method: "GET"
+  },
+  GetUserActiveSubscription: {
+    uri: "/subscriptions/:userId/find/",
+    method: "GET"
+  },
+  GetProducts: {
+    uri: "/subscriptions/products/public/list/",
+    method: "GET"
+  },
+  GetProductsByUser: {
+    uri: "/subscriptions/products/list/",
+    method: "GET"
+  },
+  Checkout: {
+    uri: "/subscriptions/payment/checkout/",
+    method: "POST"
+  },
+  Charge: {
+    uri: "/subscriptions/payment/charge/",
+    method: "POST"
+  },
+  Pause: {
+    uri: "/subscriptions/pause/",
+    method: "PUT"
+  },
+  Resume: {
+    uri: "/subscriptions/resume/",
+    method: "PUT"
+  },
+  UpdatePlan: {
+    uri: "/subscriptions/plan/update/",
+    method: "PUT"
+  }
+};
+
+// src/model/track/index.ts
+var track_exports = {};
+__export(track_exports, {
+  Endpoints: () => Endpoints11,
+  TrackParamSchema: () => TrackParamSchema,
+  TrackSchema: () => TrackSchema
+});
+
+// src/model/track/Track.schema.ts
+import { z as z11 } from "zod";
+var TrackParamSchema = z11.object({
+  name: z11.string(),
+  value: z11.union([z11.string(), z11.number()])
+});
+var TrackSchema = z11.object({
+  category: z11.string(),
+  label: z11.string(),
+  action: z11.string(),
+  params: z11.array(TrackParamSchema).optional()
+});
+
+// src/model/track/Track.api.ts
+var Endpoints11 = {
+  Track: {
+    uri: "/track/public/send/",
+    method: "POST"
+  }
+};
+
+// src/model/core/index.ts
+var core_exports = {};
+
+// src/index.ts
+var src_default = ShredAPI;
+export {
+  asset_exports as Asset,
+  core_exports as Core,
+  email_exports as Email,
+  exceptions_exports as Exceptions,
+  goal_exports as Goal,
+  note_exports as Note,
+  notification_exports as Notification,
+  project_exports as Project,
+  prompt_exports as Prompt,
+  subscription_exports as Subscription,
+  tenant_exports as Tenant,
+  track_exports as Track,
+  user_exports as User,
+  src_default as default
+};
+//# sourceMappingURL=index.mjs.map