whio-api-sdk 1.0.2 → 1.0.3

package/dist/index.d.ts

@@ -1 +1 @@
-export {};
+export { ApiSDK } from "./src/sdk";

package/dist/index.js

@@ -1,59 +1 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const sdk_1 = require("./sdk");
-const keepAlive = setInterval(() => { }, 1000);
-class storage {
-    constructor() {
-        this.items = {};
-        console.log("Storage initialized");
-    }
-    getItem(key) {
-        return this.items[key] || null;
-    }
-    setItem(key, value) {
-        this.items[key] = value;
-    }
-    removeItem(key) {
-        delete this.items[key];
-    }
-}
-const config = {
-    baseUrl: 'http://localhost:3000',
-    storage: new storage(),
-};
-const loginCredentials = {
-    email: "rimu.boddy@make.nz",
-    password: "cbr400rr",
-};
-const sdk = new sdk_1.ApiSDK(config);
-function main() {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield sdk.login(loginCredentials);
-        const user = sdk.getCurrentUser();
-        const newUser = yield sdk.createEditorUser("Rimu", "Rimu", "chiscs2snw2@bread.com", "cbr400rr");
-        const team = yield sdk.createTeam("best team ever", "this is the best team ever");
-        console.log(team);
-        const assignRes = yield sdk.addUserToTeam(team.id, newUser.id, "admin");
-        const template = yield sdk.createTemplate("Test Template", "This is a test template");
-        const updatedTemplate = yield sdk.updateTemplate("Updated Template", "This is an updated test template", template.id);
-        const userTemplate = yield sdk.createUserTemplate("User Template", "This is a user template", template.id);
-        const updatedUserTemplate = yield sdk.updateUserTemplate("User templated updated", "This is an updated user template", userTemplate.id);
-        //console.log("Usertemplate", userTemplate);
-        //console.log("Updated User Template", updatedUserTemplate);
-        const templates = yield sdk.getTemplates();
-        const userTemplates = yield sdk.getUserTemplates();
-    });
-}
-main().catch((error) => {
-    console.error("Error:", error);
-});
-//make sure no exit
+export { ApiSDK } from "./src/sdk";

package/dist/src/sdk/exampleuse.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/sdk/exampleuse.js

@@ -0,0 +1,57 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { ApiSDK } from './sdk';
+const keepAlive = setInterval(() => { }, 1000);
+class storage {
+    constructor() {
+        this.items = {};
+        console.log("Storage initialized");
+    }
+    getItem(key) {
+        return this.items[key] || null;
+    }
+    setItem(key, value) {
+        this.items[key] = value;
+    }
+    removeItem(key) {
+        delete this.items[key];
+    }
+}
+const config = {
+    baseUrl: 'http://localhost:3000',
+    storage: new storage(),
+};
+const loginCredentials = {
+    email: "rimu.boddy@make.nz",
+    password: "cbr400rr",
+};
+const sdk = new ApiSDK(config);
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield sdk.login(loginCredentials);
+        const user = sdk.getCurrentUser();
+        const newUser = yield sdk.createEditorUser("Rimu", "Rimu", "chiscs2snw2@bread.com", "cbr400rr");
+        const team = yield sdk.createTeam("best team ever", "this is the best team ever");
+        console.log(team);
+        const assignRes = yield sdk.addUserToTeam(team.id, newUser.id, "admin");
+        const template = yield sdk.createTemplate("Test Template", "This is a test template");
+        const updatedTemplate = yield sdk.updateTemplate("Updated Template", "This is an updated test template", template.id);
+        const userTemplate = yield sdk.createUserTemplate("User Template", "This is a user template", template.id);
+        const updatedUserTemplate = yield sdk.updateUserTemplate("User templated updated", "This is an updated user template", userTemplate.id);
+        //console.log("Usertemplate", userTemplate);
+        //console.log("Updated User Template", updatedUserTemplate);
+        const templates = yield sdk.getTemplates();
+        const userTemplates = yield sdk.getUserTemplates();
+    });
+}
+main().catch((error) => {
+    console.error("Error:", error);
+});
+//make sure no exit

package/dist/src/sdk/index.d.ts

@@ -0,0 +1 @@
+export { ApiSDK } from "./sdk";

package/dist/src/sdk/index.js

@@ -0,0 +1 @@
+export { ApiSDK } from "./sdk";

package/dist/src/sdk/sdk.d.ts

@@ -0,0 +1,39 @@
+import { LoginResponse, LoginCredentials, SDKConfig, User, Template, Team, UserTemplate, TranscriptionSummary } from './types';
+export declare class ApiSDK {
+    private baseUrl;
+    private storage;
+    private accessToken;
+    private refreshToken;
+    private user;
+    constructor(config?: SDKConfig);
+    private initialize;
+    private request;
+    login(credentials: LoginCredentials): Promise<LoginResponse>;
+    logout(): Promise<void>;
+    private clearAuth;
+    isAuthenticated(): boolean;
+    getCurrentUser(): User | null;
+    getAccessToken(): string | null;
+    getRefreshToken(): string | null;
+    private createUser;
+    private assignRoleToUser;
+    assignEditorToRoleToUser(userId: string): Promise<User>;
+    assignAdminToRoleToUser(userId: string): Promise<User>;
+    assignDisabledToRoleToUser(userId: string): Promise<User>;
+    createEditorUser(firstName: string, lastName: string, email: string, password: string): Promise<User>;
+    createAdminUser(firstName: string, lastName: string, email: string, password: string): Promise<User>;
+    createDisabledUser(firstName: string, lastName: string, email: string, password: string): Promise<User>;
+    createTeam(name: string, description: string): Promise<Team>;
+    updateTeam(id: string, name: string, description: string): Promise<any>;
+    addUserToTeam(teamId: string, userId: string, roleName: string): Promise<any>;
+    removeUserFromTeam(teamId: string, userId: string): Promise<any>;
+    createTemplate(title: string, content: string): Promise<any>;
+    createUserTemplate(title: string, content: string, originalTemplateId: string | undefined): Promise<UserTemplate>;
+    updateTemplate(title: string, content: string, id: string): Promise<Template>;
+    updateUserTemplate(title: string, content: string, id: string): Promise<UserTemplate>;
+    getTemplates(): Promise<Template[]>;
+    getUserTemplates(): Promise<UserTemplate[]>;
+    generateTranscriptionSummary(transcript: string, templateId: string): Promise<TranscriptionSummary>;
+    generateTranscriptionSummaryFromUserTemplate(transcript: string, userTemplateId: string): Promise<TranscriptionSummary>;
+    updateTranscriptionSummary(id: string, content: string): Promise<TranscriptionSummary>;
+}

package/dist/src/sdk/sdk.js

@@ -0,0 +1,290 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+// sdk.ts
+import { OrganizationRoleType, } from './types';
+import urls from './urls';
+export class ApiSDK {
+    constructor(config = {}) {
+        this.accessToken = null;
+        this.refreshToken = null;
+        this.user = null;
+        this.baseUrl = config.baseUrl || '/api';
+        this.storage = config.storage || {
+            getItem: (key) => localStorage.getItem(key),
+            setItem: (key, value) => localStorage.setItem(key, value),
+            removeItem: (key) => localStorage.removeItem(key),
+        };
+        this.initialize();
+    }
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.accessToken = yield this.storage.getItem('access_token');
+            const userString = yield this.storage.getItem('user');
+            this.user = userString ? JSON.parse(userString) : null;
+        });
+    }
+    request(endpoint, method = 'GET', body, headers = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = `${this.baseUrl}${endpoint}`;
+            const defaultHeaders = {
+                'Content-Type': 'application/json',
+                'ngrok-skip-browser-warning': 'true'
+            };
+            if (this.accessToken) {
+                defaultHeaders['Authorization'] = `Bearer ${this.accessToken}`;
+            }
+            const response = yield fetch(url, {
+                method,
+                headers: Object.assign(Object.assign({}, defaultHeaders), headers),
+                body: body ? JSON.stringify(body) : undefined,
+            });
+            if (!response.ok) {
+                const errorData = yield response.json().catch(() => ({}));
+                throw new Error(errorData.message || `Request failed with status ${response.status}`);
+            }
+            return response.json();
+        });
+    }
+    login(credentials) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.request('/auth/login', 'POST', credentials);
+                this.accessToken = response.access_token;
+                this.refreshToken = response.referesh_token;
+                this.user = response.user;
+                yield this.storage.setItem('access_token', response.access_token);
+                yield this.storage.setItem('user', JSON.stringify(response.user));
+                return response;
+            }
+            catch (error) {
+                yield this.clearAuth();
+                throw error;
+            }
+        });
+    }
+    logout() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.request('/auth/logout', 'POST');
+            }
+            finally {
+                yield this.clearAuth();
+            }
+        });
+    }
+    clearAuth() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.accessToken = null;
+            this.user = null;
+            yield this.storage.removeItem('access_token');
+            yield this.storage.removeItem('user');
+        });
+    }
+    isAuthenticated() {
+        return !!this.accessToken;
+    }
+    getCurrentUser() {
+        return this.user;
+    }
+    getAccessToken() {
+        return this.accessToken;
+    }
+    getRefreshToken() {
+        return this.refreshToken;
+    }
+    createUser(firstName, lastName, email, password) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const createUserDto = {
+                firstName,
+                lastName,
+                email,
+                password,
+                organizationId: (_a = this.user) === null || _a === void 0 ? void 0 : _a.organizationId,
+            };
+            const user = yield this.request(urls.users, 'POST', createUserDto);
+            return user;
+        });
+    }
+    assignRoleToUser(userId, roleName) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const organization = yield this.request(`${urls.organizations}/${(_a = this.user) === null || _a === void 0 ? void 0 : _a.organizationId}`, 'GET');
+            const orgRoleEditor = organization.roles.find(r => r.name === roleName);
+            const assignRoleDto = {
+                userId: userId,
+                organizationRoleId: orgRoleEditor.id,
+            };
+            this.request(urls.userOrganizationRoles, 'POST', assignRoleDto);
+            const userWithOrgRole = yield this.request(`${urls.user}/${userId}`, 'GET');
+            return userWithOrgRole;
+        });
+    }
+    assignEditorToRoleToUser(userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.assignRoleToUser(userId, OrganizationRoleType.EDITOR);
+        });
+    }
+    assignAdminToRoleToUser(userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.assignRoleToUser(userId, OrganizationRoleType.ADMIN);
+        });
+    }
+    assignDisabledToRoleToUser(userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.assignRoleToUser(userId, OrganizationRoleType.DISABLED);
+        });
+    }
+    createEditorUser(firstName, lastName, email, password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const user = yield this.createUser(firstName, lastName, email, password);
+            const userWithOrgRole = yield this.assignEditorToRoleToUser(user.id);
+            return userWithOrgRole;
+        });
+    }
+    createAdminUser(firstName, lastName, email, password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const user = yield this.createUser(firstName, lastName, email, password);
+            const userWithOrgRole = yield this.assignAdminToRoleToUser(user.id);
+            return userWithOrgRole;
+        });
+    }
+    createDisabledUser(firstName, lastName, email, password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const user = yield this.createUser(firstName, lastName, email, password);
+            const userWithOrgRole = yield this.assignDisabledToRoleToUser(user.id);
+            return userWithOrgRole;
+        });
+    }
+    createTeam(name, description) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const teamDto = {
+                name,
+                description,
+                organizationId: this.user.organizationId,
+            };
+            return this.request(urls.teams, 'POST', teamDto);
+        });
+    }
+    updateTeam(id, name, description) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const teamDto = {
+                name,
+                description,
+            };
+            return this.request(`${urls.teams}/${id}`, 'PUT', teamDto);
+        });
+    }
+    addUserToTeam(teamId, userId, roleName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const assignRoleDto = {
+                teamId,
+                userId,
+                name: roleName,
+            };
+            return this.request(urls.teamRoles, 'POST', assignRoleDto);
+        });
+    }
+    removeUserFromTeam(teamId, userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = `${urls.teamRoles}/user/${userId}/team/${teamId}`;
+            return this.request(urls.teamRoles, 'DELETE');
+        });
+    }
+    //unsure how we are going to deal with template categories just yet
+    createTemplate(title, content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const templateCategories = yield this.request(urls.templateCatedories, 'GET');
+            const createTemplateDto = {
+                title,
+                content,
+                isGlobal: false,
+                categoryId: templateCategories[0].id,
+                createdById: this.user.id,
+                organizationId: this.user.organizationId,
+            };
+            return this.request(urls.templates, 'POST', createTemplateDto);
+        });
+    }
+    createUserTemplate(title, content, originalTemplateId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const createUserTemplateDto = {
+                title,
+                content,
+                originalTemplateId,
+                userId: this.user.id,
+            };
+            return this.request(urls.userTemplates, 'POST', createUserTemplateDto);
+        });
+    }
+    updateTemplate(title, content, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const templateDto = {
+                title,
+                content,
+                isGlobal: false,
+                organizationId: this.user.organizationId,
+            };
+            return this.request(`${urls.templates}/${id}`, 'PATCH', templateDto);
+        });
+    }
+    updateUserTemplate(title, content, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userTemplateDto = {
+                title,
+                content,
+            };
+            return this.request(`${urls.userTemplates}/${id}`, 'PATCH', userTemplateDto);
+        });
+    }
+    getTemplates() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request(urls.templates, 'GET');
+        });
+    }
+    getUserTemplates() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = `${urls.userTemplates}/user/${this.user.id}`;
+            return this.request(url, 'GET');
+        });
+    }
+    generateTranscriptionSummary(transcript, templateId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const generateSummaryDto = {
+                transcript,
+                templateId,
+                userId: this.user.id,
+                fromUserTemplate: false,
+            };
+            const transcriptionSummary = yield this.request(urls.transcriptionSummary, 'POST', generateSummaryDto);
+            return transcriptionSummary;
+        });
+    }
+    generateTranscriptionSummaryFromUserTemplate(transcript, userTemplateId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const generateSummaryDto = {
+                transcript,
+                templateId: userTemplateId,
+                userId: this.user.id,
+                fromUserTemplate: true,
+            };
+            const transcriptionSummary = yield this.request(urls.transcriptionSummary, 'POST', generateSummaryDto);
+            return transcriptionSummary;
+        });
+    }
+    updateTranscriptionSummary(id, content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const updateSummaryDto = {
+                content,
+            };
+            return this.request(`${urls.transcriptionSummary}/${id}`, 'PATCH', updateSummaryDto);
+        });
+    }
+}

package/dist/src/sdk/types.d.ts

@@ -0,0 +1,217 @@
+export interface Role {
+    id: string;
+    name: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface OrganizationRole {
+    id: string;
+    name: string;
+    createdAt: string;
+    updatedAt: string;
+    organizationId: string;
+}
+export interface UserRole {
+    userId: string;
+    roleId: string;
+    createdAt: string;
+    role: Role;
+}
+export interface UserOrganizationRole {
+    userId: string;
+    organizationRoleId: string;
+    createdAt: string;
+    organizationRole: OrganizationRole;
+}
+export interface Organization {
+    id: string;
+    name: string;
+    description: string;
+    createdAt: string;
+    updatedAt: string;
+    users?: User[];
+    roles?: OrganizationRole[];
+}
+export interface User {
+    id: string;
+    email: string;
+    firstName: string;
+    lastName: string;
+    createdAt: string;
+    updatedAt: string;
+    organizationId: string;
+    organization: Organization;
+    roles: UserRole[];
+    organizationRoles: UserOrganizationRole[];
+}
+export interface LoginResponse {
+    access_token: string;
+    referesh_token: string;
+    user: User;
+}
+export interface LoginCredentials {
+    email: string;
+    password: string;
+}
+export interface SDKConfig {
+    baseUrl?: string;
+    storage?: {
+        getItem: (key: string) => string | null | Promise<string | null>;
+        setItem: (key: string, value: string) => void | Promise<void>;
+        removeItem: (key: string) => void | Promise<void>;
+    };
+}
+export interface AssignTeamRoleDto {
+    userId: string;
+    teamId: string;
+    name: string;
+}
+export interface CreateTeamDto {
+    name: string;
+    description?: string;
+    organizationId: string;
+}
+export interface UpdateTeamDto {
+    name?: string;
+    description?: string;
+    organizationId?: string;
+}
+export interface CreateTemplateDto {
+    title: string;
+    content: string;
+    isGlobal?: boolean;
+    organizationId: string;
+    categoryId: string;
+    createdById: string;
+}
+export interface UpdateTemplateDto {
+    title?: string;
+    content?: string;
+    isGlobal?: boolean;
+    organizationId: string;
+    categoryId?: string;
+}
+export interface GenerateTranscriptionSummaryDto {
+    transcript?: string;
+    templateId: string;
+    userId?: string;
+    fromUserTemplate?: boolean;
+}
+export interface UpdateTranscriptionSummaryDto {
+    anonymisedTranscript?: string;
+    content?: string;
+    metadata?: Record<string, any>;
+    templateId?: string;
+}
+export interface AssignOrganizationRoleDto {
+    userId: string;
+    organizationRoleId: string;
+}
+export interface CreateUserTemplateDto {
+    title: string;
+    content: string;
+    userId: string;
+    originalTemplateId?: string;
+}
+export interface UpdateUserTemplateDto {
+    title?: string;
+    content?: string;
+}
+export interface CreateUserDto {
+    email: string;
+    password: string;
+    firstName?: string;
+    lastName?: string;
+    organizationId?: string;
+}
+export interface UpdateUserDto {
+    email?: string;
+    password?: string;
+    firstName?: string;
+    lastName?: string;
+    organizationId?: string;
+}
+export declare enum OrganizationRoleType {
+    ADMIN = "ADMIN",
+    EDITOR = "EDITOR",
+    DISABLED = "DISABLED"
+}
+export interface AdminUser {
+    id: string;
+    email: string;
+    password_hash: string;
+    role: string;
+    created_at: Date;
+}
+export interface TemplateCategory {
+    id: string;
+    name: string;
+}
+export interface Template {
+    id: string;
+    title: string;
+    content: string;
+    createdAt: string;
+    updatesAt: string;
+    isGlobal: boolean;
+    organizationId?: string;
+    categoryId: string;
+    createdById: string;
+    organization?: Organization;
+    category?: TemplateCategory;
+    createdBy?: User;
+    userTemplates?: UserTemplate[];
+    transcriptionSummaries?: TranscriptionSummary[];
+    teamTemplates?: TeamTemplate[];
+}
+export interface UserTemplate {
+    id: string;
+    title: string;
+    content: string;
+    createdAt: string;
+    updatesAt: string;
+    userId: string;
+    originalTemplateId?: string;
+    user?: User;
+    originalTemplate?: Template;
+}
+export interface TranscriptionSummary {
+    id: string;
+    anonymisedTranscript?: string;
+    content: string;
+    metadata?: any;
+    createdAt: string;
+    updatesAt: string;
+    templateId: string;
+    userId: string;
+    template?: Template;
+    user?: User;
+}
+export interface TeamTemplate {
+    teamId: string;
+    templateId: string;
+    createdAt: string;
+    team?: Team;
+    template?: Template;
+}
+export interface TeamRole {
+    id: string;
+    name: string;
+    createdAt: string;
+    updatesAt: string;
+    userId: string;
+    teamId: string;
+    user?: User;
+    team?: Team;
+}
+export interface Team {
+    id: string;
+    name: string;
+    description?: string;
+    createdAt: string;
+    updatesAt: string;
+    organizationId: string;
+    organization?: Organization;
+    teamRoles?: TeamRole[];
+    teamTemplates?: TeamTemplate[];
+}

package/dist/src/sdk/types.js

@@ -0,0 +1,7 @@
+// types.ts
+export var OrganizationRoleType;
+(function (OrganizationRoleType) {
+    OrganizationRoleType["ADMIN"] = "ADMIN";
+    OrganizationRoleType["EDITOR"] = "EDITOR";
+    OrganizationRoleType["DISABLED"] = "DISABLED";
+})(OrganizationRoleType || (OrganizationRoleType = {}));

package/dist/src/sdk/urls.d.ts

@@ -0,0 +1,20 @@
+declare const urls: {
+    login: string;
+    register: string;
+    refreshToken: string;
+    logout: string;
+    user: string;
+    users: string;
+    roles: string;
+    teams: string;
+    organizations: string;
+    organizationRoles: string;
+    userRoles: string;
+    teamRoles: string;
+    templates: string;
+    templateCatedories: string;
+    userTemplates: string;
+    userOrganizationRoles: string;
+    transcriptionSummary: string;
+};
+export default urls;

package/dist/src/sdk/urls.js

@@ -0,0 +1,20 @@
+const urls = {
+    login: '/auth/login',
+    register: '/auth/register',
+    refreshToken: '/auth/refresh-token',
+    logout: '/auth/logout',
+    user: '/users',
+    users: '/users',
+    roles: '/roles',
+    teams: '/teams',
+    organizations: '/organizations',
+    organizationRoles: '/organization-roles',
+    userRoles: '/user-roles',
+    teamRoles: '/team-roles',
+    templates: '/templates',
+    templateCatedories: '/template-categories',
+    userTemplates: '/user-templates',
+    userOrganizationRoles: '/user-organization-roles',
+    transcriptionSummary: '/transcription-summary',
+};
+export default urls;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whio-api-sdk",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",

package/tsconfig.json

@@ -4,7 +4,7 @@
     "module": "ES2020",                
     "declaration": true,
     "outDir": "./dist",
-    "rootDir": "./src",
+    "rootDir": "./",
     "strict": true,
     "esModuleInterop": true,
     "skipLibCheck": true,
@@ -12,6 +12,6 @@
     "moduleResolution": "node",
     "lib": ["es6", "dom"]
   },
-  "include": ["src/**/*"],
+  "include": ["src/**/*", "index.ts"],
   "exclude": ["node_modules", "**/*.spec.ts"]
 }