shred-api-client 2.0.9 → 2.0.10-rc.1

package/dist/index.js

@@ -1,42 +1,1790 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Asset: () => asset_exports,
+  Core: () => core_exports,
+  Email: () => email_exports,
+  Exceptions: () => exceptions_exports,
+  Goal: () => goal_exports,
+  Note: () => note_exports,
+  Notification: () => notification_exports,
+  Project: () => project_exports,
+  Prompt: () => prompt_exports,
+  Subscription: () => subscription_exports,
+  Tenant: () => tenant_exports,
+  Track: () => track_exports,
+  User: () => user_exports,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/util/HTTPClient.ts
+var import_cross_fetch = __toESM(require("cross-fetch"));
+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 url = host + uri;
+    const headers = {
+      "Content-Type": useLegacyApi ? "application/x-www-form-urlencoded" : "application/json"
+    };
+    if (context?.token) {
+      headers["Authorization"] = `Bearer ${context.token}`;
+    }
+    if (context?.requestId) {
+      headers["X-Request-ID"] = context.requestId;
+    }
+    const fetchOptions = {
+      method,
+      headers
+    };
+    if (method !== "GET" && data) {
+      fetchOptions.body = useLegacyApi ? new URLSearchParams(data).toString() : JSON.stringify(data);
+    }
+    try {
+      const response = await (0, import_cross_fetch.default)(url, fetchOptions);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw {
+          status: response.status,
+          statusText: response.statusText,
+          body: errorText
+        };
+      }
+      try {
+        return await response.json();
+      } catch {
+        return await response.text();
+      }
+    } catch (error) {
+      throw {
+        message: "Network error",
+        original: 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
+var import_zod = require("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 = import_zod.z.object({
+  id: import_zod.z.string(),
+  userId: import_zod.z.string(),
+  triggerId: import_zod.z.string().optional(),
+  title: import_zod.z.string(),
+  body: import_zod.z.string(),
+  status: import_zod.z.enum(["failed", "delivered", "deleted"]),
+  deliveredAt: import_zod.z.number(),
+  openedAt: import_zod.z.number().optional(),
+  deletedAt: import_zod.z.number().optional(),
+  cta: import_zod.z.object({ label: import_zod.z.string(), url: import_zod.z.string().url() }).optional(),
+  metadata: import_zod.z.record(import_zod.z.union([import_zod.z.string(), import_zod.z.number()])),
+  error: import_zod.z.string().optional()
+});
+var NotificationDetailSchema = NotificationItemSchema.pick({
+  title: true,
+  body: true,
+  userId: true,
+  metadata: true
+});
+var CriteriaSchema = import_zod.z.object({
+  type: import_zod.z.nativeEnum(CriteriaType),
+  params: import_zod.z.record(import_zod.z.any())
+});
+var HistorySchema = import_zod.z.object({
+  batchId: import_zod.z.string(),
+  executedAt: import_zod.z.number(),
+  timezone: import_zod.z.string(),
+  status: import_zod.z.enum(["success", "failed", "info", "warn"]),
+  users: import_zod.z.object({
+    total: import_zod.z.number(),
+    success: import_zod.z.number(),
+    error: import_zod.z.number()
+  }),
+  errorList: import_zod.z.array(
+    import_zod.z.object({
+      token: import_zod.z.string(),
+      error: import_zod.z.string()
+    })
+  ).optional(),
+  executionTimeDuration: import_zod.z.number().optional()
+});
+var RecurrenceRuleSchema = import_zod.z.object({
+  frequency: import_zod.z.nativeEnum(Frequency),
+  interval: import_zod.z.number(),
+  weekDays: import_zod.z.array(import_zod.z.nativeEnum(WeekDay)).optional(),
+  dayOfMonth: import_zod.z.number().optional(),
+  endDate: import_zod.z.string().optional(),
+  ocurrences: import_zod.z.number().optional()
+});
+var TriggerSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  title: import_zod.z.string(),
+  description: import_zod.z.string(),
+  transportType: import_zod.z.array(import_zod.z.nativeEnum(TransportType)),
+  notification: NotificationDetailSchema,
+  history: import_zod.z.array(HistorySchema).optional(),
+  status: import_zod.z.nativeEnum(Status),
+  recurrence: RecurrenceRuleSchema.optional(),
+  timezone: import_zod.z.string().nullable().optional(),
+  tenantIds: import_zod.z.array(import_zod.z.string()).optional(),
+  executionDate: import_zod.z.string().optional(),
+  timeOfDay: import_zod.z.string(),
+  criteria: CriteriaSchema,
+  nextExecution: import_zod.z.number().optional(),
+  createdAt: import_zod.z.number().optional(),
+  modified: import_zod.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;
     }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Note = exports.Notification = exports.Goal = exports.Project = exports.Core = exports.Email = exports.Track = exports.Subscription = exports.User = exports.Tenant = exports.Asset = exports.Prompt = exports.Exceptions = void 0;
-const Api_1 = require("./model/Api");
-//V2
-exports.Exceptions = __importStar(require("./model/exceptions"));
-exports.Prompt = __importStar(require("./model/prompt"));
-exports.Asset = __importStar(require("./model/asset"));
-exports.Tenant = __importStar(require("./model/tenant"));
-exports.User = __importStar(require("./model/user"));
-exports.Subscription = __importStar(require("./model/subscription"));
-exports.Track = __importStar(require("./model/track"));
-exports.Email = __importStar(require("./model/email"));
-exports.Core = __importStar(require("./model/core"));
-exports.Project = __importStar(require("./model/project"));
-exports.Goal = __importStar(require("./model/goal"));
-exports.Notification = __importStar(require("./model/notification"));
-exports.Note = __importStar(require("./model/note"));
-exports.default = Api_1.ShredAPI;
+    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
+var import_zod2 = require("zod");
+var EmailSchema = import_zod2.z.object({
+  to: import_zod2.z.string().email().optional(),
+  subject: import_zod2.z.string(),
+  body: import_zod2.z.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
+var import_zod4 = require("zod");
+
+// src/model/asset/index.ts
+var asset_exports = {};
+__export(asset_exports, {
+  AssetSchema: () => AssetSchema
+});
+
+// src/model/asset/Asset.schema.ts
+var import_zod3 = require("zod");
+var AssetSchema = import_zod3.z.object({
+  assetId: import_zod3.z.string(),
+  fileName: import_zod3.z.string(),
+  extension: import_zod3.z.string(),
+  fileSize: import_zod3.z.number(),
+  assetUrl: import_zod3.z.string().url(),
+  thumbnailUrl: import_zod3.z.string().url(),
+  type: import_zod3.z.string(),
+  duration: import_zod3.z.number().optional(),
+  progress: import_zod3.z.number().optional(),
+  error: import_zod3.z.string().optional(),
+  authorId: import_zod3.z.string(),
+  uploadedAt: import_zod3.z.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 = import_zod4.z.nativeEnum(Status2);
+var CaptionStyleStatus = import_zod4.z.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 = import_zod4.z.object({
+  status: import_zod4.z.nativeEnum(Status2),
+  title: import_zod4.z.string(),
+  description: import_zod4.z.string(),
+  timestamp: import_zod4.z.number(),
+  metadata: import_zod4.z.record(import_zod4.z.any())
+});
+var ProjectSchema = import_zod4.z.object({
+  id: import_zod4.z.string(),
+  title: import_zod4.z.string(),
+  instructions: import_zod4.z.string(),
+  submitMonth: import_zod4.z.string(),
+  captionStyle: import_zod4.z.nativeEnum(CaptionStyle),
+  finalVideoId: import_zod4.z.string().optional(),
+  thumbnailUrl: import_zod4.z.string().optional(),
+  modified: import_zod4.z.number(),
+  captionSuggestion: import_zod4.z.string().optional(),
+  editorId: import_zod4.z.string(),
+  userId: import_zod4.z.string(),
+  assets: import_zod4.z.array(AssetSchema).optional(),
+  expirationTimestamp: import_zod4.z.number(),
+  isFree: import_zod4.z.boolean().optional(),
+  timeline: import_zod4.z.array(TimelineItemSchema),
+  submitTimestamp: import_zod4.z.number(),
+  tenantId: import_zod4.z.string().optional(),
+  status: import_zod4.z.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
+var import_zod5 = require("zod");
+var DailyMilestoneSchema = import_zod5.z.object({
+  id: import_zod5.z.string(),
+  date: import_zod5.z.string(),
+  target: import_zod5.z.number(),
+  progress: import_zod5.z.number()
+});
+var WeeklyMilestoneSchema = import_zod5.z.object({
+  id: import_zod5.z.string(),
+  week: import_zod5.z.string(),
+  target: import_zod5.z.number(),
+  progress: import_zod5.z.number(),
+  dailyMilestones: import_zod5.z.array(DailyMilestoneSchema)
+});
+var GoalSchema = import_zod5.z.object({
+  id: import_zod5.z.string(),
+  editorId: import_zod5.z.string(),
+  month: import_zod5.z.string(),
+  // ex: "2024-04"
+  target: import_zod5.z.number(),
+  progress: import_zod5.z.number(),
+  createdAt: import_zod5.z.number(),
+  weeklyMilestones: import_zod5.z.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
+var import_zod6 = require("zod");
+var NoteHistorySchema = import_zod6.z.object({
+  type: import_zod6.z.enum([
+    "created",
+    "updated",
+    "deleted",
+    "asset-added",
+    "asset-removed"
+  ]),
+  actorEmail: import_zod6.z.string().email(),
+  timestamp: import_zod6.z.number(),
+  details: import_zod6.z.string().optional()
+});
+var NoteSchema = import_zod6.z.object({
+  id: import_zod6.z.string(),
+  userId: import_zod6.z.string(),
+  authorEmail: import_zod6.z.string().email(),
+  assets: import_zod6.z.array(AssetSchema),
+  title: import_zod6.z.string(),
+  content: import_zod6.z.string(),
+  createdAt: import_zod6.z.number(),
+  modified: import_zod6.z.number(),
+  history: import_zod6.z.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
+var import_zod7 = require("zod");
+var ScriptSchema = import_zod7.z.object({
+  id: import_zod7.z.string(),
+  title: import_zod7.z.string(),
+  content: import_zod7.z.string(),
+  tags: import_zod7.z.array(import_zod7.z.string()).optional(),
+  userId: import_zod7.z.string().optional()
+});
+var CategorySchema = import_zod7.z.object({
+  id: import_zod7.z.string(),
+  title: import_zod7.z.string(),
+  pictureUrl: import_zod7.z.string().url(),
+  backgroundColor: import_zod7.z.string(),
+  active: import_zod7.z.boolean(),
+  scripts: import_zod7.z.array(ScriptSchema)
+});
+var PromptSchema = import_zod7.z.object({
+  id: import_zod7.z.string(),
+  tenantId: import_zod7.z.string(),
+  categories: import_zod7.z.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
+var import_zod9 = require("zod");
+
+// src/model/subscription/Subscription.schema.ts
+var import_zod8 = require("zod");
+var Type = /* @__PURE__ */ ((Type2) => {
+  Type2[Type2["CUSTOMER_SUBSCRIPTION"] = 0] = "CUSTOMER_SUBSCRIPTION";
+  Type2[Type2["TENANT_SUBSCRIPTION"] = 1] = "TENANT_SUBSCRIPTION";
+  return Type2;
+})(Type || {});
+var SubscriptionTypeSchema = import_zod8.z.nativeEnum(Type);
+var PlanSchema = import_zod8.z.object({
+  id: import_zod8.z.string(),
+  currency: import_zod8.z.string(),
+  price: import_zod8.z.string(),
+  interval: import_zod8.z.string(),
+  metadata: import_zod8.z.record(import_zod8.z.string()),
+  subscriptionItemId: import_zod8.z.string()
+});
+var DescriptionSchema = import_zod8.z.object({
+  description: import_zod8.z.string(),
+  subtitle: import_zod8.z.string()
+});
+var ProductSchema = import_zod8.z.object({
+  id: import_zod8.z.string(),
+  name: import_zod8.z.string(),
+  descriptions: import_zod8.z.array(DescriptionSchema),
+  metadata: import_zod8.z.any(),
+  plans: import_zod8.z.array(PlanSchema)
+});
+var ChargeSchema = import_zod8.z.object({
+  id: import_zod8.z.number(),
+  created: import_zod8.z.number(),
+  paid: import_zod8.z.boolean(),
+  receiptUrl: import_zod8.z.string(),
+  status: import_zod8.z.string(),
+  price: import_zod8.z.string(),
+  paymentType: import_zod8.z.string(),
+  last4: import_zod8.z.string().optional(),
+  brand: import_zod8.z.string().optional()
+});
+var SubscriptionSchema = import_zod8.z.object({
+  id: import_zod8.z.string(),
+  status: import_zod8.z.string(),
+  startDate: import_zod8.z.number().optional(),
+  daysUntilDue: import_zod8.z.number().optional(),
+  renewAutomatically: import_zod8.z.boolean().optional(),
+  currentPeriodStart: import_zod8.z.number().optional(),
+  currentPeriodEnd: import_zod8.z.number().optional(),
+  paymentMethodId: import_zod8.z.string().optional(),
+  product: ProductSchema,
+  type: import_zod8.z.nativeEnum(Type).optional(),
+  plan: PlanSchema.optional()
+});
+
+// src/model/tenant/Tenant.schema.ts
+var PreferencesSchema = import_zod9.z.object({
+  iconUrl: import_zod9.z.string().url(),
+  logoUrl: import_zod9.z.string().url(),
+  primaryColor: import_zod9.z.string(),
+  secondaryColor: import_zod9.z.string(),
+  guidelinesUrl: import_zod9.z.string().url().optional()
+});
+var TenantSchema = import_zod9.z.object({
+  id: import_zod9.z.string(),
+  name: import_zod9.z.string(),
+  isActive: import_zod9.z.boolean(),
+  isSubscriptionActive: import_zod9.z.boolean(),
+  preferences: PreferencesSchema,
+  inviteCode: import_zod9.z.string(),
+  totalUsersAllowed: import_zod9.z.number(),
+  currentUsersSize: import_zod9.z.number().optional(),
+  chargeByEmail: import_zod9.z.boolean(),
+  defaultProductId: import_zod9.z.string().optional(),
+  defaultPlanId: import_zod9.z.string().optional(),
+  defaultCoupomCode: import_zod9.z.string().optional(),
+  allowedProducts: import_zod9.z.array(import_zod9.z.string()).optional(),
+  useOwnScripts: import_zod9.z.boolean().optional(),
+  subscription: import_zod9.z.optional(import_zod9.z.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
+var import_zod10 = require("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 = import_zod10.z.object({
+  primaryColor: import_zod10.z.string().optional(),
+  secondaryColor: import_zod10.z.string().optional(),
+  facebookLink: import_zod10.z.string().optional(),
+  instagramLink: import_zod10.z.string().optional(),
+  bRoll: import_zod10.z.boolean().optional(),
+  logo: import_zod10.z.string().optional()
+});
+var UserSchema = import_zod10.z.object({
+  id: import_zod10.z.string(),
+  name: import_zod10.z.string(),
+  email: import_zod10.z.string().email(),
+  fcmToken: import_zod10.z.string().optional(),
+  profession: import_zod10.z.string().optional(),
+  photoUrl: import_zod10.z.string().optional(),
+  preferences: PreferencesSchema2.optional(),
+  tenantId: import_zod10.z.string().optional(),
+  editorId: import_zod10.z.string().optional(),
+  timezone: import_zod10.z.string().optional(),
+  experienceId: import_zod10.z.string().optional(),
+  customerId: import_zod10.z.string(),
+  role: import_zod10.z.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
+var import_zod11 = require("zod");
+var TrackParamSchema = import_zod11.z.object({
+  name: import_zod11.z.string(),
+  value: import_zod11.z.union([import_zod11.z.string(), import_zod11.z.number()])
+});
+var TrackSchema = import_zod11.z.object({
+  category: import_zod11.z.string(),
+  label: import_zod11.z.string(),
+  action: import_zod11.z.string(),
+  params: import_zod11.z.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 index_default = ShredAPI;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Asset,
+  Core,
+  Email,
+  Exceptions,
+  Goal,
+  Note,
+  Notification,
+  Project,
+  Prompt,
+  Subscription,
+  Tenant,
+  Track,
+  User
+});
+//# sourceMappingURL=index.js.map