shred-api-client 1.8.0 → 1.9.0

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

@@ -0,0 +1,19 @@
+import Environment from "../model/Env";
+import { Approve, Project, ProjectAPISchema, ProjectCreation, Query, SendToApproval } from "../model/Project.schema";
+import Context from "../model/Context";
+declare class ProjectAPI implements ProjectAPISchema {
+    private env;
+    private clientHTTP;
+    constructor(env: Environment);
+    find(context: Context, projectId: string): Promise<Project>;
+    create(context: Context, createData: ProjectCreation): Promise<Project>;
+    review(ctx: Context, pId: string, revision: string): Promise<boolean>;
+    cancel(ctx: Context, projectId: string): Promise<boolean>;
+    list(context: Context, query: Query): Promise<Project[]>;
+    deny(ctx: Context, pId: string, denyFB: string): Promise<boolean>;
+    unschedule(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>;
+}
+export default ProjectAPI;

package/dist/api/Project.api.js

@@ -0,0 +1,72 @@
+"use strict";
+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");
+class ProjectAPI {
+    constructor(env) {
+        this.env = env;
+        this.clientHTTP = new HTTPClient_1.default();
+    }
+    async find(context, projectId) {
+        const endpointData = Project_schema_1.ProjectEndpoints.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 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 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 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, endpointData.method, query, context);
+        return data;
+    }
+    async deny(ctx, pId, denyFB) {
+        const endpointData = Project_schema_1.ProjectEndpoints.Deny;
+        const endpoint = endpointData.uri.replace(":projectId", pId);
+        const data = await this.clientHTTP.makeRequest(this.env, endpoint, endpointData.method, { denyFeedback: denyFB }, ctx);
+        return data.success;
+    }
+    async unschedule(context, projectId) {
+        const endpointData = Project_schema_1.ProjectEndpoints.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 start(context, projectId) {
+        const endpointData = Project_schema_1.ProjectEndpoints.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 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 endpoint = endpointData.uri.replace(":projectId", projectId);
+        const data = await this.clientHTTP.makeRequest(this.env, endpoint, endpointData.method, approval, context);
+        return data.success;
+    }
+}
+exports.default = ProjectAPI;

package/dist/api/PushNotification.api.d.ts

@@ -0,0 +1,10 @@
+import Environment from "../model/Env";
+import { PushNotificationSchema, PushNotification } from "../model/PushNotification.schema";
+import Context from "../src/model/Context";
+declare class PushNotificationAPI implements PushNotificationSchema {
+    private env;
+    private clientHTTP;
+    constructor(env: Environment);
+    push(ctx: Context, notification: PushNotification): Promise<boolean>;
+}
+export default PushNotificationAPI;

package/dist/api/PushNotification.api.js

@@ -0,0 +1,19 @@
+"use strict";
+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 PushNotification_schema_1 = require("../model/PushNotification.schema");
+class PushNotificationAPI {
+    constructor(env) {
+        this.env = env;
+        this.clientHTTP = new HTTPClient_1.default();
+    }
+    async push(ctx, notification) {
+        const endpointInfo = PushNotification_schema_1.PushNotificationEndpoints.Push;
+        const data = await this.clientHTTP.makeRequest(this.env, endpointInfo.uri, endpointInfo.method, notification, ctx);
+        return data.success;
+    }
+}
+exports.default = PushNotificationAPI;

package/dist/api/User.api.d.ts

@@ -8,7 +8,8 @@ declare class UserAPI implements UserAPISchema {
     sendValidationCode(email: string): Promise<boolean>;
     confirmCode(email: string, code: number): Promise<boolean>;
     isEmailAvaliable(email: string): Promise<boolean>;
-    update(context: Context, update: Update): Promise<boolean>;
+    update(context: Context, update: Partial<Update>): Promise<boolean>;
+    setup(context: Context): Promise<boolean>;
     authenticate(context: Context, system: System): Promise<string>;
     createUser(email: string, name: string, password: string, passwordConfirmation: string, profession: string | null, invitationCode: string | null): Promise<any>;
     getUserInfo(context: Context): Promise<User>;

package/dist/api/User.api.js

@@ -30,6 +30,11 @@ class UserAPI {
         const data = await this.clientHTTP.makeRequest(this.env, `${endpointData.uri}`, endpointData.method, Object.assign({}, update), context);
         return data.isValid;
     }
+    async setup(context) {
+        const endpointData = User_schema_1.UserEndpoints.Setup;
+        const data = await this.clientHTTP.makeRequest(this.env, `${endpointData.uri}`, endpointData.method, null, context);
+        return data.success;
+    }
     async authenticate(context, system) {
         const endpointData = User_schema_1.UserEndpoints.Authenticate;
         const data = await this.clientHTTP.makeRequest(this.env, `${endpointData.uri}`, endpointData.method, { system }, context);

package/dist/index.d.ts

@@ -1,7 +1,9 @@
 import { ShredAPI } from "./model/Api";
 import { Role } from "./model/User.schema";
+import { Status as ProjectStatus } from "./model/Project.schema";
 import Exceptions from "./model/exceptions/";
 export { Role };
 export { Exceptions };
+export { ProjectStatus };
 export default ShredAPI;
 export * from "./namespace";

package/dist/index.js

@@ -17,10 +17,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Exceptions = exports.Role = void 0;
+exports.ProjectStatus = exports.Exceptions = exports.Role = void 0;
 const Api_1 = require("./model/Api");
 const User_schema_1 = require("./model/User.schema");
 Object.defineProperty(exports, "Role", { enumerable: true, get: function () { return User_schema_1.Role; } });
+const Project_schema_1 = require("./model/Project.schema");
+Object.defineProperty(exports, "ProjectStatus", { enumerable: true, get: function () { return Project_schema_1.Status; } });
 const exceptions_1 = __importDefault(require("./model/exceptions/"));
 exports.Exceptions = exceptions_1.default;
 exports.default = Api_1.ShredAPI;

package/dist/model/Api.d.ts

@@ -1,16 +1,18 @@
 import Environment from "./Env";
 import { PromptAPISchema } from "./Prompt.schema";
-import { SMSAPISchema } from "./SMS.schema";
+import { PushNotificationSchema } from "./PushNotification.schema";
 import { SubscriptionAPISchema } from "./Subscription.schema";
 import { UserAPISchema } from "./User.schema";
 import { EmailAPISchema } from "./Email.schema";
 import { TenantAPISchema } from "./Tenant.schema";
+import { ProjectAPISchema } from "./Project.schema";
 export declare class ShredAPI {
     user: UserAPISchema;
     subscription: SubscriptionAPISchema;
     prompt: PromptAPISchema;
-    sms: SMSAPISchema;
+    pushNotification: PushNotificationSchema;
     email: EmailAPISchema;
     tenant: TenantAPISchema;
+    project: ProjectAPISchema;
     constructor(env: Environment);
 }

package/dist/model/Api.js

@@ -4,20 +4,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ShredAPI = void 0;
-const SMS_api_1 = __importDefault(require("../api/SMS.api"));
+const PushNotification_api_1 = __importDefault(require("../api/PushNotification.api"));
 const Prompt_api_1 = __importDefault(require("../api/Prompt.api"));
 const Subscription_api_1 = __importDefault(require("../api/Subscription.api"));
 const Tenant_api_1 = __importDefault(require("../api/Tenant.api"));
 const User_api_1 = __importDefault(require("../api/User.api"));
 const Email_api_1 = __importDefault(require("../api/Email.api"));
+const Project_api_1 = __importDefault(require("../api/Project.api"));
 class ShredAPI {
     constructor(env) {
         this.user = new User_api_1.default(env);
         this.prompt = new Prompt_api_1.default(env);
         this.subscription = new Subscription_api_1.default(env);
-        this.sms = new SMS_api_1.default(env);
+        this.pushNotification = new PushNotification_api_1.default(env);
         this.email = new Email_api_1.default(env);
         this.tenant = new Tenant_api_1.default(env);
+        this.project = new Project_api_1.default(env);
     }
 }
 exports.ShredAPI = ShredAPI;

package/dist/model/Asset.schema.d.ts

@@ -0,0 +1,12 @@
+type Asset = {
+    duration?: number;
+    fileName: string;
+    extension: string;
+    mimeType: string;
+    fileSize: number;
+    thumbnailUrl: string;
+    assetUrl: string;
+    uploadTime: number;
+    id?: string;
+};
+export { Asset };

package/dist/model/Asset.schema.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/model/Project.schema.d.ts

@@ -0,0 +1,123 @@
+import { Asset } from "./Asset.schema";
+import Context from "./Context";
+export type ProjectCreation = Pick<Project, "title" | "instructions" | "captionStyle" | "assets">;
+export type SendToApproval = {
+    video: string;
+    thumbnail: string;
+    captionSuggestion: string;
+};
+export type Approve = {
+    scheduleTime?: number;
+    captionSuggestion: string;
+};
+export type Query = {
+    startDate: string;
+    endDate: string;
+    timeZone?: string;
+};
+interface ProjectAPISchema {
+    find: (context: Context, projectId: string) => Promise<Project>;
+    create: (context: Context, data: ProjectCreation) => Promise<Project>;
+    review: (context: Context, projectId: string, revision: string) => Promise<boolean>;
+    cancel: (context: Context, projectId: string) => Promise<boolean>;
+    list: (context: Context, query: Query) => Promise<Project[]>;
+    start: (context: Context, projectId: string) => Promise<boolean>;
+    sendToApproval: (context: Context, projectId: string, data: SendToApproval) => Promise<boolean>;
+    approve: (context: Context, projectId: string, data: Approve) => Promise<boolean>;
+    deny: (context: Context, projectId: string, denyFeedback: string) => Promise<boolean>;
+    unschedule: (context: Context, projectId: string) => Promise<boolean>;
+}
+declare const ProjectEndpoints: {
+    List: {
+        uri: string;
+        method: string;
+    };
+    CreateProject: {
+        uri: string;
+        method: string;
+    };
+    FindOne: {
+        uri: string;
+        method: string;
+    };
+    Review: {
+        uri: string;
+        method: string;
+    };
+    Cancel: {
+        uri: string;
+        method: string;
+    };
+    StartEdition: {
+        uri: string;
+        method: string;
+    };
+    SendToApproval: {
+        uri: string;
+        method: string;
+    };
+    Approve: {
+        uri: string;
+        method: string;
+    };
+    Unschedule: {
+        uri: string;
+        method: string;
+    };
+    Deny: {
+        uri: string;
+        method: string;
+    };
+};
+export declare enum Status {
+    SUBMITTED = 0,
+    EDITING = 1,
+    COMPLETED = 2,
+    WAITING_APPROVE = 3,
+    DENIED = 4,
+    REVISIONING = 5,
+    CANCELLED = 6,
+    SCHEDULED = 7
+}
+declare enum CaptionStyle {
+    ONE_LINE = 1,
+    ONE_LINE_EMOJIS = 2,
+    TWO_LINES_EMOJIS = 3,
+    HOME_HIGHLIGHT = 4
+}
+type DenyFeedback = {
+    timestamp: number;
+    feedback: string;
+    resolved: boolean;
+};
+type Project = {
+    id: string | null;
+    title: string;
+    instructions: string;
+    submitMonth: string;
+    status: Status;
+    captionStyle: CaptionStyle;
+    finalVideoId?: string;
+    canRevision: boolean;
+    thumbnailUrl?: string;
+    revision?: string;
+    modified?: number;
+    captionSuggestion?: string;
+    editorId: string;
+    userId: string;
+    assets?: Asset[];
+    denyFeedback?: DenyFeedback[];
+    approvedBy?: string;
+    approveTimestamp?: number;
+    expirationTimestamp?: number;
+    sentToApproveTimestamp?: number;
+    submitTimestamp: number;
+    editTimestamp?: number;
+    completeTimestamp?: number;
+    revisedAt?: number;
+    isFreeProject?: boolean;
+    scheduledAt?: number;
+    scheduledTime?: number;
+    tenantId?: string;
+};
+export { Project, ProjectAPISchema, ProjectEndpoints };

package/dist/model/Project.schema.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectEndpoints = exports.Status = void 0;
+const ProjectEndpoints = {
+    List: {
+        uri: "/projects/list",
+        method: "GET",
+    },
+    CreateProject: {
+        uri: "/projects/create",
+        method: "POST",
+    },
+    FindOne: {
+        uri: `/projects/:projectId/`,
+        method: "POST",
+    },
+    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",
+    },
+    Approve: {
+        uri: "/projects/:projectId/approve/",
+        method: "POST",
+    },
+    Unschedule: {
+        uri: "/projects/:projectId/unschedule/",
+        method: "POST",
+    },
+    Deny: {
+        uri: "/projects/:projectId/deny/",
+        method: "POST",
+    },
+};
+exports.ProjectEndpoints = ProjectEndpoints;
+var Status;
+(function (Status) {
+    Status[Status["SUBMITTED"] = 0] = "SUBMITTED";
+    Status[Status["EDITING"] = 1] = "EDITING";
+    Status[Status["COMPLETED"] = 2] = "COMPLETED";
+    Status[Status["WAITING_APPROVE"] = 3] = "WAITING_APPROVE";
+    Status[Status["DENIED"] = 4] = "DENIED";
+    Status[Status["REVISIONING"] = 5] = "REVISIONING";
+    Status[Status["CANCELLED"] = 6] = "CANCELLED";
+    Status[Status["SCHEDULED"] = 7] = "SCHEDULED";
+})(Status || (exports.Status = Status = {}));
+var CaptionStyle;
+(function (CaptionStyle) {
+    CaptionStyle[CaptionStyle["ONE_LINE"] = 1] = "ONE_LINE";
+    CaptionStyle[CaptionStyle["ONE_LINE_EMOJIS"] = 2] = "ONE_LINE_EMOJIS";
+    CaptionStyle[CaptionStyle["TWO_LINES_EMOJIS"] = 3] = "TWO_LINES_EMOJIS";
+    CaptionStyle[CaptionStyle["HOME_HIGHLIGHT"] = 4] = "HOME_HIGHLIGHT";
+})(CaptionStyle || (CaptionStyle = {}));

package/dist/model/PushNotification.schema.d.ts

@@ -0,0 +1,17 @@
+import Context from "./Context";
+interface PushNotificationSchema {
+    push: (context: Context, notification: PushNotification) => Promise<boolean>;
+}
+declare const PushNotificationEndpoints: {
+    Push: {
+        uri: string;
+        method: string;
+    };
+};
+type PushNotification = {
+    title: string;
+    body: string;
+    userToken: string;
+    metadata: any;
+};
+export { PushNotificationSchema, PushNotificationEndpoints, PushNotification };

package/dist/model/PushNotification.schema.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PushNotificationEndpoints = void 0;
+const PushNotificationEndpoints = {
+    Push: {
+        uri: "/notifications/push/",
+        method: "POST",
+    },
+};
+exports.PushNotificationEndpoints = PushNotificationEndpoints;

package/dist/model/User.schema.d.ts

@@ -6,7 +6,8 @@ interface UserAPISchema {
     sendValidationCode: (email: string) => Promise<boolean>;
     confirmCode: (email: string, code: number) => Promise<boolean>;
     authenticate: (context: Context, system: System) => Promise<string>;
-    update: (context: Context, update: Update) => Promise<boolean>;
+    update: (context: Context, update: Partial<Update>) => Promise<boolean>;
+    setup: (context: Context) => Promise<boolean>;
     createUser: (email: string, name: string, password: string, passwordConfirmation: string, profession: string | null, invitationCode: string | null) => Promise<User>;
 }
 declare const UserEndpoints: {
@@ -42,6 +43,10 @@ declare const UserEndpoints: {
         uri: string;
         method: string;
     };
+    Setup: {
+        uri: string;
+        method: string;
+    };
 };
 declare enum Role {
     USER = "User",

package/dist/model/User.schema.js

@@ -34,6 +34,10 @@ const UserEndpoints = {
         uri: "/accounts/user/update",
         method: "PUT",
     },
+    Setup: {
+        uri: "/accounts/user/setup/",
+        method: "POST",
+    },
 };
 exports.UserEndpoints = UserEndpoints;
 var Role;

package/dist/namespace.d.ts

@@ -1,6 +1,8 @@
 import { Product as TProduct, Subscription as TSubscription } from "./model/Subscription.schema";
 import { System as TSystem, User as TUser, Role as TRole } from "./model/User.schema";
 import { Email as TEmail } from "./model/Email.schema";
+import { Asset as TAsset } from "./model/Asset.schema";
+import { Project as TProject } from "./model/Project.schema";
 import { Tenant as TTenant } from "./model/Tenant.schema";
 import { Prompt as TPrompt, Script as TScript, Category as TCategory } from "./model/Prompt.schema";
 export declare namespace Permissions {
@@ -13,6 +15,8 @@ export declare namespace Shred {
     type User = TUser;
     type Email = TEmail;
     type System = TSystem;
+    type Project = TProject;
+    type Asset = TAsset;
     namespace PromptTypes {
         type Prompt = TPrompt;
         type Script = TScript;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shred-api-client",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "description": "API Client for Shred",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/dist/api/SMS.api.d.ts

@@ -1,12 +0,0 @@
-import Environment from "../model/Env";
-import { SMSAPISchema } from "../model/SMS.schema";
-import Context from "../src/model/Context";
-declare class SMSAPI implements SMSAPISchema {
-    private env;
-    private clientHTTP;
-    constructor(env: Environment);
-    sendSMS(content: string, ctx: Context): Promise<boolean>;
-    verify(phone: string, code: number): Promise<boolean>;
-    sendVerifyCode(phone: string, friendlyName?: string | undefined): Promise<boolean>;
-}
-export default SMSAPI;

package/dist/api/SMS.api.js

@@ -1,29 +0,0 @@
-"use strict";
-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 SMS_schema_1 = require("../model/SMS.schema");
-class SMSAPI {
-    constructor(env) {
-        this.env = env;
-        this.clientHTTP = new HTTPClient_1.default();
-    }
-    async sendSMS(content, ctx) {
-        const endpointInfo = SMS_schema_1.SMSEndpoints.SendSMS;
-        const data = await this.clientHTTP.makeRequest(this.env, endpointInfo.uri, endpointInfo.method, { content }, ctx);
-        return data.success;
-    }
-    async verify(phone, code) {
-        const endpointInfo = SMS_schema_1.SMSEndpoints.VerifyCode;
-        const data = await this.clientHTTP.makeRequest(this.env, endpointInfo.uri, endpointInfo.method, { phone, code });
-        return data.success;
-    }
-    async sendVerifyCode(phone, friendlyName) {
-        const endpointInfo = SMS_schema_1.SMSEndpoints.SendVerifyCode;
-        const data = await this.clientHTTP.makeRequest(this.env, endpointInfo.uri, endpointInfo.method, { phone, friendlyName });
-        return data;
-    }
-}
-exports.default = SMSAPI;

package/dist/model/SMS.schema.d.ts

@@ -1,21 +0,0 @@
-import Context from "./Context";
-interface SMSAPISchema {
-    sendSMS: (content: string, context: Context) => Promise<boolean>;
-    sendVerifyCode: (phone: string, friendlyName?: string) => Promise<boolean>;
-    verify: (phone: string, number: number) => Promise<boolean>;
-}
-declare const SMSEndpoints: {
-    SendVerifyCode: {
-        uri: string;
-        method: string;
-    };
-    VerifyCode: {
-        uri: string;
-        method: string;
-    };
-    SendSMS: {
-        uri: string;
-        method: string;
-    };
-};
-export { SMSAPISchema, SMSEndpoints };

package/dist/model/SMS.schema.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SMSEndpoints = void 0;
-const SMSEndpoints = {
-    SendVerifyCode: {
-        uri: "/sms/public/verify/send",
-        method: "POST",
-    },
-    VerifyCode: {
-        uri: "/sms/public/verify",
-        method: "POST",
-    },
-    SendSMS: {
-        uri: "/sms/message/send",
-        method: "POST",
-    },
-};
-exports.SMSEndpoints = SMSEndpoints;