shred-api-client 1.14.2 → 1.14.4-rc.1

package/dist/api/AppConfig.api.d.ts

@@ -1,6 +1,6 @@
 import Environment from "../model/Env";
-import { APPConfigSchema } from "../model/AppConfig.schema";
-declare class AppConfigAPI implements APPConfigSchema {
+import * as APPConfig from "../model/app-config";
+declare class AppConfigAPI implements APPConfig.IAPI {
     private env;
     private clientHTTP;
     constructor(env: Environment);

package/dist/api/AppConfig.api.js

@@ -1,17 +1,40 @@
 "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]; } };
+    }
+    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;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const HTTPClient_1 = __importDefault(require("../util/HTTPClient"));
-const AppConfig_schema_1 = require("../model/AppConfig.schema");
+const APPConfig = __importStar(require("../model/app-config"));
 class AppConfigAPI {
     constructor(env) {
         this.env = env;
         this.clientHTTP = new HTTPClient_1.default();
     }
     async version() {
-        const endpointInfo = AppConfig_schema_1.AppConfigEndpoints.Version;
+        const endpointInfo = APPConfig.Endpoints.Version;
         const data = await this.clientHTTP.makeRequest(this.env, endpointInfo.uri, endpointInfo.method);
         return data.version;
     }

package/dist/api/Email.api.d.ts

@@ -1,10 +1,10 @@
 import Environment from "../model/Env";
 import Context from "../model/Context";
-import { EmailAPISchema, Email } from "../model/Email.schema";
-declare class EmailAPI implements EmailAPISchema {
+import * as Email from "../model/email";
+declare class EmailAPI implements Email.IAPI {
     private env;
     private clientHTTP;
     constructor(env: Environment);
-    send(email: Email, ctx?: Context): Promise<boolean>;
+    send(email: Email.Entity, ctx?: Context): Promise<boolean>;
 }
 export default EmailAPI;

package/dist/api/Email.api.js

@@ -1,17 +1,40 @@
 "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]; } };
+    }
+    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;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const HTTPClient_1 = __importDefault(require("../util/HTTPClient"));
-const Email_schema_1 = require("../model/Email.schema");
+const Email = __importStar(require("../model/email"));
 class EmailAPI {
     constructor(env) {
         this.env = env;
         this.clientHTTP = new HTTPClient_1.default();
     }
     async send(email, ctx) {
-        const endpointInfo = Email_schema_1.EmailEndpoints.SendEmail;
+        const endpointInfo = Email.Endpoints.SendEmail;
         const data = await this.clientHTTP.makeRequest(this.env, endpointInfo.uri, endpointInfo.method, email, ctx);
         return data.result;
     }

package/dist/api/Goal.api.d.ts

@@ -0,0 +1,10 @@
+import Environment from "../model/Env";
+import Context from "../model/Context";
+import * as Goal from "../model/goal";
+declare class GoalAPI implements Goal.IAPI {
+    private env;
+    private clientHTTP;
+    constructor(env: Environment);
+    getGoals(context: Context): Promise<Goal.Entity[]>;
+}
+export default GoalAPI;

package/dist/api/Goal.api.js

@@ -0,0 +1,42 @@
+"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]; } };
+    }
+    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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const HTTPClient_1 = __importDefault(require("../util/HTTPClient"));
+const Goal = __importStar(require("../model/goal"));
+class GoalAPI {
+    constructor(env) {
+        this.env = env;
+        this.clientHTTP = new HTTPClient_1.default();
+    }
+    async getGoals(context) {
+        const endpointData = Goal.Endpoints.GetGoals;
+        const data = await this.clientHTTP.makeRequest(this.env, endpointData.uri, endpointData.method, null, context);
+        return data;
+    }
+}
+exports.default = GoalAPI;

package/dist/api/Note.api.js

@@ -0,0 +1 @@
+"use strict";

package/dist/api/Notification.api.d.ts

@@ -1,18 +1,18 @@
 import Environment from "../model/Env";
-import { NotificationSchema, NotificationDetail, Trigger, NotificationItem } from "../model/Notification.schema";
+import * as Notification from "../model/notification";
+import * as Core from "../model/core";
 import Context from "../model/Context";
-import { APIResponse } from "../model/Api";
-declare class NotificationAPI implements NotificationSchema {
+declare class NotificationAPI implements Notification.IAPI {
     private env;
     private clientHTTP;
     constructor(env: Environment);
     clearNotifications(ctx: Context): Promise<boolean>;
     markAsRead(ctx: Context, id: string): Promise<boolean>;
-    getNotifications(ctx: Context): Promise<APIResponse<NotificationItem>>;
+    getNotifications(ctx: Context): Promise<Core.APIResponse<Notification.NotificationItem>>;
     deleteTrigger(ctx: Context, triggerId: string): Promise<boolean>;
-    updateTrigger(ctx: Context, triggerId: string, t: Partial<Trigger>): Promise<Trigger>;
-    createTrigger(ctx: Context, t: Trigger): Promise<Trigger>;
-    getTriggers(ctx: Context): Promise<APIResponse<Trigger>>;
-    push(ctx: Context, notification: NotificationDetail): Promise<boolean>;
+    updateTrigger(ctx: Context, triggerId: string, t: Partial<Notification.Trigger>): Promise<Notification.Trigger>;
+    createTrigger(ctx: Context, t: Notification.Trigger): Promise<Notification.Trigger>;
+    getTriggers(ctx: Context): Promise<Core.APIResponse<Notification.Trigger>>;
+    push(ctx: Context, notification: Notification.NotificationDetail): Promise<boolean>;
 }
 export default NotificationAPI;

package/dist/api/Notification.api.js

@@ -1,55 +1,78 @@
 "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]; } };
+    }
+    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;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const HTTPClient_1 = __importDefault(require("../util/HTTPClient"));
-const Notification_schema_1 = require("../model/Notification.schema");
+const Notification = __importStar(require("../model/notification"));
 class NotificationAPI {
     constructor(env) {
         this.env = env;
         this.clientHTTP = new HTTPClient_1.default();
     }
     async clearNotifications(ctx) {
-        const endpointData = Notification_schema_1.NotificationEndpoints.ClearNotifications;
+        const endpointData = Notification.Endpoints.ClearNotifications;
         const data = await this.clientHTTP.makeRequest(this.env, endpointData.uri, endpointData.method, null, ctx);
         return data;
     }
     async markAsRead(ctx, id) {
-        const endpointData = Notification_schema_1.NotificationEndpoints.MarkAsRead;
+        const endpointData = Notification.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 = Notification_schema_1.NotificationEndpoints.ListNotifications;
+        const endpointData = Notification.Endpoints.ListNotifications;
         const data = await this.clientHTTP.makeRequest(this.env, endpointData.uri, endpointData.method, null, ctx);
         return data;
     }
     async deleteTrigger(ctx, triggerId) {
-        const endpointData = Notification_schema_1.NotificationEndpoints.Delete;
+        const endpointData = Notification.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 = Notification_schema_1.NotificationEndpoints.Update;
+        const endpointData = Notification.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 = Notification_schema_1.NotificationEndpoints.Create;
+        const endpointData = Notification.Endpoints.Create;
         const data = await this.clientHTTP.makeRequest(this.env, endpointData.uri, endpointData.method, t, ctx);
         return data;
     }
     async getTriggers(ctx) {
-        const endpointInfo = Notification_schema_1.NotificationEndpoints.List;
+        const endpointInfo = Notification.Endpoints.List;
         const data = await this.clientHTTP.makeRequest(this.env, endpointInfo.uri, endpointInfo.method, null, ctx);
         return data;
     }
     async push(ctx, notification) {
-        const endpointInfo = Notification_schema_1.NotificationEndpoints.Push;
+        const endpointInfo = Notification.Endpoints.Push;
         const data = await this.clientHTTP.makeRequest(this.env, endpointInfo.uri, endpointInfo.method, notification, ctx);
         return data.success;
     }

package/dist/api/Project.api.d.ts

@@ -1,21 +1,21 @@
 import Environment from "../model/Env";
-import { Approve, Goal, Project, ProjectAPISchema, ProjectCreation, Query, SendToApproval } from "../model/Project.schema";
+import * as Project from "../model/project";
 import Context from "../model/Context";
-declare class ProjectAPI implements ProjectAPISchema {
+import * as Core from "../model/core";
+declare class ProjectAPI implements Project.IAPI {
     private env;
     private clientHTTP;
     constructor(env: Environment);
-    getGoals(context: Context): Promise<Goal[]>;
-    find(context: Context, projectId: string): Promise<Project>;
-    create(context: Context, createData: ProjectCreation): Promise<Project>;
+    find(context: Context, projectId: string): Promise<Project.Entity>;
+    create(context: Context, createData: Project.ProjectCreation): Promise<Project.Entity>;
     review(ctx: Context, pId: string, revision: string): Promise<boolean>;
     cancel(ctx: Context, projectId: string): Promise<boolean>;
-    list(context: Context, query: Query): Promise<Project[]>;
+    list(context: Context, query: Core.QueryOptions<Project.Entity>): Promise<Project.Entity[]>;
     deny(ctx: Context, pId: string, denyFB: string, categories?: string[]): Promise<boolean>;
     unschedule(context: Context, projectId: string): Promise<boolean>;
     rollback(context: Context, projectId: string): Promise<boolean>;
     start(context: Context, projectId: string): Promise<boolean>;
-    approve(ctx: Context, pId: string, approve: Approve): Promise<boolean>;
-    sendToApproval(context: Context, projectId: string, approval: SendToApproval): Promise<boolean>;
+    approve(ctx: Context, pId: string, approve: Project.Approve): Promise<boolean>;
+    sendToApproval(context: Context, projectId: string, approval: Project.SendToApproval): Promise<boolean>;
 }
 export default ProjectAPI;

package/dist/api/Project.api.js

@@ -1,80 +1,100 @@
 "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]; } };
+    }
+    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;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const HTTPClient_1 = __importDefault(require("../util/HTTPClient"));
-const Project_schema_1 = require("../model/Project.schema");
+const Project = __importStar(require("../model/project"));
+const parseQuery_1 = require("../src/util/parseQuery");
 class ProjectAPI {
     constructor(env) {
         this.env = env;
         this.clientHTTP = new HTTPClient_1.default();
     }
-    async getGoals(context) {
-        const endpointData = Project_schema_1.ProjectEndpoints.GetGoals;
-        const data = await this.clientHTTP.makeRequest(this.env, endpointData.uri, endpointData.method, null, context);
-        return data;
-    }
     async find(context, projectId) {
-        const endpointData = Project_schema_1.ProjectEndpoints.FindOne;
+        const endpointData = Project.Endpoints.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 = Project_schema_1.ProjectEndpoints.CreateProject;
+        const endpointData = Project.Endpoints.CreateProject;
         const data = await this.clientHTTP.makeRequest(this.env, endpointData.uri, endpointData.method, createData, context);
         return data;
     }
     async review(ctx, pId, revision) {
-        const endpointData = Project_schema_1.ProjectEndpoints.Review;
+        const endpointData = Project.Endpoints.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 = Project_schema_1.ProjectEndpoints.Cancel;
+        const endpointData = Project.Endpoints.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 = Project_schema_1.ProjectEndpoints.List;
-        const data = await this.clientHTTP.makeRequest(this.env, `${endpointData.uri}?startDate=${query.startDate}&endDate=${query.endDate}&timezone=${query.timeZone}`, endpointData.method, null, context);
+        const endpointData = Project.Endpoints.List;
+        const qs = (0, parseQuery_1.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 = Project_schema_1.ProjectEndpoints.Deny;
+        const endpointData = Project.Endpoints.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 = Project_schema_1.ProjectEndpoints.Unschedule;
+        const endpointData = Project.Endpoints.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 = Project_schema_1.ProjectEndpoints.Rollback;
+        const endpointData = Project.Endpoints.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 = Project_schema_1.ProjectEndpoints.StartEdition;
+        const endpointData = Project.Endpoints.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 = Project_schema_1.ProjectEndpoints.Approve;
+        const endpointData = Project.Endpoints.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 = Project_schema_1.ProjectEndpoints.SendToApproval;
+        const endpointData = Project.Endpoints.SendToApproval;
         const endpoint = endpointData.uri.replace(":projectId", projectId);
         const data = await this.clientHTTP.makeRequest(this.env, endpoint, endpointData.method, approval, context);
         return data.success;

package/dist/api/Prompt.api.d.ts

@@ -1,14 +1,14 @@
 import Context from "../model/Context";
-import { Prompt, PromptAPISchema, Script } from "../model/Prompt.schema";
+import { Prompt } from "../";
 import Environment from "../model/Env";
-declare class PromptAPI implements PromptAPISchema {
+declare class PromptAPI implements Prompt.IAPI {
     private env;
     private clientHTTP;
     constructor(env: Environment);
-    getPrompt(context: Context): Promise<Prompt>;
-    getScripts(context: Context): Promise<Script[]>;
-    updateScript(c: Context, id: string, script: Partial<Script>): Promise<boolean>;
-    addScript(c: Context, script: Partial<Script>): Promise<Script>;
+    getPrompt(context: Context): Promise<Prompt.Entity>;
+    getScripts(context: Context): Promise<Prompt.Script[]>;
+    updateScript(c: Context, id: string, script: Partial<Prompt.Script>): Promise<boolean>;
+    addScript(c: Context, script: Partial<Prompt.Script>): Promise<Prompt.Script>;
     deleteScript(c: Context, id: string): Promise<boolean>;
 }
 export default PromptAPI;

package/dist/api/Prompt.api.js

@@ -4,35 +4,35 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const HTTPClient_1 = __importDefault(require("../util/HTTPClient"));
-const Prompt_schema_1 = require("../model/Prompt.schema");
+const __1 = require("../");
 class PromptAPI {
     constructor(env) {
         this.env = env;
         this.clientHTTP = new HTTPClient_1.default();
     }
     async getPrompt(context) {
-        const endpointInfo = Prompt_schema_1.PromptEndpoints.GetPrompt;
+        const endpointInfo = __1.Prompt.Endpoints.GetPrompt;
         const data = await this.clientHTTP.makeRequest(this.env, endpointInfo.uri, endpointInfo.method, null, context);
         return data;
     }
     async getScripts(context) {
-        const endpointInfo = Prompt_schema_1.PromptEndpoints.ListScript;
+        const endpointInfo = __1.Prompt.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_schema_1.PromptEndpoints.UpdateScript;
+        const endpointData = __1.Prompt.Endpoints.UpdateScript;
         const endpoint = endpointData.uri.replace(":id", id);
         const data = await this.clientHTTP.makeRequest(this.env, endpoint, endpointData.method, Object.assign({}, script), c);
         return data;
     }
     async addScript(c, script) {
-        const endpointInfo = Prompt_schema_1.PromptEndpoints.AddScript;
+        const endpointInfo = __1.Prompt.Endpoints.AddScript;
         const data = await this.clientHTTP.makeRequest(this.env, endpointInfo.uri, endpointInfo.method, Object.assign({}, script), c);
         return data;
     }
     async deleteScript(c, id) {
-        const endpointData = Prompt_schema_1.PromptEndpoints.DeleteScript;
+        const endpointData = __1.Prompt.Endpoints.DeleteScript;
         const endpoint = endpointData.uri.replace(":id", id);
         const data = await this.clientHTTP.makeRequest(this.env, endpoint, endpointData.method, null, c);
         return data;

package/dist/api/Subscription.api.d.ts

@@ -1,18 +1,18 @@
 import Context from "../model/Context";
-import { Charge, Product, Subscription, SubscriptionAPISchema } from "../model/Subscription.schema";
+import { Subscription } from "../";
 import Environment from "../model/Env";
-declare class SubscriptionAPI implements SubscriptionAPISchema {
+declare class SubscriptionAPI implements Subscription.IAPI {
     private env;
     private clientHTTP;
     constructor(env: Environment);
     updatePlan(ctx: Context, planId: string): Promise<boolean>;
-    getProduct(id: string, context?: Context): Promise<Product>;
-    getCharges(ctx: Context): Promise<Charge[]>;
-    getSubscription(context: Context, userId?: string): Promise<Subscription | null>;
+    getProduct(id: string, context?: Context): Promise<Subscription.Product>;
+    getCharges(ctx: Context): Promise<Subscription.Charge[]>;
+    getSubscription(context: Context, userId?: string): Promise<Subscription.Entity | null>;
     charge(ctx: Context): Promise<boolean>;
     pause(ctx: Context): Promise<boolean>;
     resume(ctx: Context): Promise<boolean>;
-    getProducts(ctx?: Context): Promise<Product[]>;
+    getProducts(ctx?: Context): Promise<Subscription.Product[]>;
     createCheckout(planId: string | null, ctx: Context): Promise<string>;
 }
 export default SubscriptionAPI;

package/dist/api/Subscription.api.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const Subscription_schema_1 = require("../model/Subscription.schema");
+const __1 = require("../");
 const HTTPClient_1 = __importDefault(require("../util/HTTPClient"));
 class SubscriptionAPI {
     constructor(env) {
@@ -11,26 +11,26 @@ class SubscriptionAPI {
         this.clientHTTP = new HTTPClient_1.default();
     }
     async updatePlan(ctx, planId) {
-        const endpointInfo = Subscription_schema_1.SubscriptionEndpoints.UpdatePlan;
+        const endpointInfo = __1.Subscription.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_schema_1.SubscriptionEndpoints.GetProduct;
+        const endpointInfo = __1.Subscription.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_schema_1.SubscriptionEndpoints.GetCharges;
+        const endpointInfo = __1.Subscription.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_schema_1.SubscriptionEndpoints.GetActiveSubscription;
+        const endpointInfo = __1.Subscription.Endpoints.GetActiveSubscription;
         let uri = endpointInfo.uri;
         let method = endpointInfo.method;
         if (userId) {
-            const endpointData = Subscription_schema_1.SubscriptionEndpoints.GetUserActiveSubscription;
+            const endpointData = __1.Subscription.Endpoints.GetUserActiveSubscription;
             const endpoint = endpointData.uri.replace(":userId", userId);
             uri = endpoint;
             method = endpointData.method;
@@ -39,29 +39,29 @@ class SubscriptionAPI {
         return data;
     }
     async charge(ctx) {
-        const endpointInfo = Subscription_schema_1.SubscriptionEndpoints.Charge;
+        const endpointInfo = __1.Subscription.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_schema_1.SubscriptionEndpoints.Pause;
+        const endpointInfo = __1.Subscription.Endpoints.Pause;
         const data = await this.clientHTTP.makeRequest(this.env, endpointInfo.uri, endpointInfo.method, null, ctx);
         return data;
     }
     async resume(ctx) {
-        const endpointInfo = Subscription_schema_1.SubscriptionEndpoints.Resume;
+        const endpointInfo = __1.Subscription.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_schema_1.SubscriptionEndpoints.GetProductsByUser
-            : Subscription_schema_1.SubscriptionEndpoints.GetProducts;
+            ? __1.Subscription.Endpoints.GetProductsByUser
+            : __1.Subscription.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_schema_1.SubscriptionEndpoints.Checkout;
+        const endpointInfo = __1.Subscription.Endpoints.Checkout;
         const data = await this.clientHTTP.makeRequest(this.env, endpointInfo.uri, endpointInfo.method, { planId }, ctx);
         return data.url;
     }

package/dist/api/Tenant.api.d.ts

@@ -1,14 +1,14 @@
 import Context from "../model/Context";
-import { Tenant, TenantAPISchema } from "../model/Tenant.schema";
+import { Tenant } from "../";
 import Environment from "../model/Env";
-declare class TenantAPI implements TenantAPISchema {
+declare class TenantAPI implements Tenant.IAPI {
     private env;
     private clientHTTP;
     constructor(env: Environment);
-    getByInviteCode(inviteCode: string, context?: Context): Promise<Tenant | null>;
-    getTenant(context: Context, tenantId?: string): Promise<Tenant | null>;
-    create(t: Tenant, context: Context): Promise<boolean>;
-    list(context: Context): Promise<Tenant[]>;
-    update(tenantId: string, updateData: Pick<Tenant, "preferences">, context: Context): Promise<boolean>;
+    getByInviteCode(inviteCode: string, context?: Context): Promise<Tenant.Entity | null>;
+    getTenant(context: Context, tenantId?: string): Promise<Tenant.Entity | null>;
+    create(t: Tenant.Entity, context: Context): Promise<boolean>;
+    list(context: Context): Promise<Tenant.Entity[]>;
+    update(tenantId: string, updateData: Pick<Tenant.Entity, "preferences">, context: Context): Promise<boolean>;
 }
 export default TenantAPI;