@totoday/quinn-sdk 0.1.2 → 0.2.0

package/README.md

@@ -34,6 +34,16 @@ const people = await quinn.members.batchGet({
   ids: ["user-id-1"],
   emails: ["user@example.com"],
 });
+const created = await quinn.members.create({
+  email: "new.user@example.com",
+  firstName: "New",
+  lastName: "User",
+  sendInvite: false,
+});
+if (created) {
+  await quinn.members.updateRoles({ memberId: created.userId, roleIds: ["role-id"] });
+  await quinn.members.updateManager({ memberId: created.userId, managerUid: "manager-uid" });
+}
 
 // role -> level -> competencies
 const roles = await quinn.roles.list();
@@ -60,6 +70,28 @@ Default `apiUrl` is `https://api.lunapark.com`.
 
 `token` and `orgId` are required.
 
+## Mutation Access
+
+By default, the SDK preserves current behavior and uses `mutationAccess: "full_access"`.
+
+You can explicitly restrict Quinn business mutations:
+
+```ts
+import { Quinn } from "@totoday/quinn-sdk";
+
+const quinn = new Quinn({
+  mutationAccess: "read_only",
+});
+```
+
+Supported values:
+
+- `read_only`: blocks SDK mutation methods
+- `needs_confirmation`: also blocks mutation methods for now, but throws a distinct confirmation-required error
+- `full_access`: allows mutation methods
+
+This setting does not affect local file writes or sandbox execution. It only gates Quinn business mutations through the SDK.
+
 For password login from scripts, use `QuinnAuth`:
 
 ```ts

package/dist/config.d.ts

@@ -1,4 +1,5 @@
 import { AxiosInstance } from 'axios';
+import { QuinnMutationAccess } from './mutation-access';
 export declare const DEFAULT_QUINN_API_URL = "https://api.lunapark.com";
 export interface QuinnClientConfig {
     apiUrl?: string;
@@ -6,12 +7,14 @@ export interface QuinnClientConfig {
     orgId?: string;
     configPath?: string;
     httpClient?: AxiosInstance;
+    mutationAccess?: QuinnMutationAccess;
 }
 export interface QuinnResolvedConfig {
     apiUrl: string;
     token: string;
     orgId: string;
     httpClient?: AxiosInstance;
+    mutationAccess: QuinnMutationAccess;
 }
 export declare function resolveQuinnConfig(input: QuinnClientConfig): QuinnResolvedConfig;
 export declare function resolveApiUrl(input?: {

package/dist/config.js

@@ -17,6 +17,7 @@ function resolveQuinnConfig(input) {
     const apiUrl = firstNonEmpty(input.apiUrl, process.env.QUINN_API_URL, fileConfig.apiUrl, exports.DEFAULT_QUINN_API_URL);
     const token = firstNonEmpty(input.token, process.env.QUINN_API_TOKEN, fileConfig.token);
     const orgId = firstNonEmpty(input.orgId, process.env.QUINN_ORG_ID, fileConfig.orgId);
+    const mutationAccess = resolveMutationAccess(input.mutationAccess, process.env.QUINN_MUTATION_ACCESS, fileConfig.mutationAccess);
     if (!apiUrl) {
         throw new Error('missing apiUrl');
     }
@@ -31,6 +32,7 @@ function resolveQuinnConfig(input) {
         token,
         orgId,
         httpClient: input.httpClient,
+        mutationAccess,
     };
 }
 function resolveApiUrl(input) {
@@ -55,12 +57,22 @@ function readConfigFile(configPath) {
             apiUrl: asNonEmptyString(parsed.apiUrl),
             token: asNonEmptyString(parsed.token),
             orgId: asNonEmptyString(parsed.orgId),
+            mutationAccess: asMutationAccess(parsed.mutationAccess),
         };
     }
     catch {
         return {};
     }
 }
+function resolveMutationAccess(...values) {
+    for (const value of values) {
+        const parsed = asMutationAccess(value);
+        if (parsed) {
+            return parsed;
+        }
+    }
+    return 'full_access';
+}
 function firstNonEmpty(...values) {
     for (const value of values) {
         const normalized = asNonEmptyString(value);
@@ -77,3 +89,9 @@ function asNonEmptyString(value) {
     const trimmed = value.trim();
     return trimmed === '' ? undefined : trimmed;
 }
+function asMutationAccess(value) {
+    if (value !== 'read_only' && value !== 'needs_confirmation' && value !== 'full_access') {
+        return undefined;
+    }
+    return value;
+}

package/dist/http.d.ts

@@ -2,5 +2,6 @@ import { AxiosInstance } from 'axios';
 export interface QuinnHttpConfig {
     apiUrl: string;
     token: string;
+    orgId: string;
 }
 export declare function createQuinnHttpClient(config: QuinnHttpConfig): AxiosInstance;

package/dist/http.js

@@ -7,7 +7,7 @@ exports.createQuinnHttpClient = createQuinnHttpClient;
 const axios_1 = __importDefault(require("axios"));
 function createQuinnHttpClient(config) {
     return axios_1.default.create({
-        baseURL: config.apiUrl,
+        baseURL: `${config.apiUrl}/platform/v1/orgs/${config.orgId}`,
         headers: {
             Authorization: `Bearer ${config.token}`,
             'Content-Type': 'application/json',

package/dist/index.d.ts

@@ -1,23 +1,36 @@
 import { QuinnClientConfig } from './config';
 import { CompetenciesService } from './services/competencies';
+import { CoursesService } from './services/courses';
 import { EndorsementsService } from './services/endorsements';
+import { GroupsService } from './services/groups';
+import { KnowledgeService } from './services/knowledge';
 import { LevelsService } from './services/levels';
 import { MembersService } from './services/members';
 import { OrganizationsService } from './services/organizations';
+import { ProgressService } from './services/progress';
+import { ProgramsService } from './services/programs';
 import { RolesService } from './services/roles';
 export * from './types';
 export { QuinnAuth } from './auth';
 export { DEFAULT_QUINN_API_URL, resolveApiUrl, resolveConfigPath, } from './config';
 export type { QuinnClientConfig } from './config';
+export type { QuinnMutationAccess } from './mutation-access';
+export { QuinnMutationAccessError } from './mutation-access';
+export { KnowledgeDocumentsService, KnowledgeFoldersService, KnowledgeService, } from './services/knowledge';
 export declare class Quinn {
     private readonly config;
     private readonly http;
     readonly organizations: OrganizationsService;
+    readonly knowledge: KnowledgeService;
     readonly members: MembersService;
     readonly roles: RolesService;
     readonly levels: LevelsService;
     readonly competencies: CompetenciesService;
+    readonly courses: CoursesService;
+    readonly groups: GroupsService;
+    readonly programs: ProgramsService;
+    readonly progress: ProgressService;
     readonly endorsements: EndorsementsService;
     constructor(config?: QuinnClientConfig);
-    private orgPath;
+    private assertMutationAllowed;
 }

package/dist/index.js

@@ -14,14 +14,20 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Quinn = exports.resolveConfigPath = exports.resolveApiUrl = exports.DEFAULT_QUINN_API_URL = exports.QuinnAuth = void 0;
+exports.Quinn = exports.KnowledgeService = exports.KnowledgeFoldersService = exports.KnowledgeDocumentsService = exports.QuinnMutationAccessError = exports.resolveConfigPath = exports.resolveApiUrl = exports.DEFAULT_QUINN_API_URL = exports.QuinnAuth = void 0;
 const config_1 = require("./config");
 const http_1 = require("./http");
+const mutation_access_1 = require("./mutation-access");
 const competencies_1 = require("./services/competencies");
+const courses_1 = require("./services/courses");
 const endorsements_1 = require("./services/endorsements");
+const groups_1 = require("./services/groups");
+const knowledge_1 = require("./services/knowledge");
 const levels_1 = require("./services/levels");
 const members_1 = require("./services/members");
 const organizations_1 = require("./services/organizations");
+const progress_1 = require("./services/progress");
+const programs_1 = require("./services/programs");
 const roles_1 = require("./services/roles");
 __exportStar(require("./types"), exports);
 var auth_1 = require("./auth");
@@ -30,27 +36,49 @@ var config_2 = require("./config");
 Object.defineProperty(exports, "DEFAULT_QUINN_API_URL", { enumerable: true, get: function () { return config_2.DEFAULT_QUINN_API_URL; } });
 Object.defineProperty(exports, "resolveApiUrl", { enumerable: true, get: function () { return config_2.resolveApiUrl; } });
 Object.defineProperty(exports, "resolveConfigPath", { enumerable: true, get: function () { return config_2.resolveConfigPath; } });
+var mutation_access_2 = require("./mutation-access");
+Object.defineProperty(exports, "QuinnMutationAccessError", { enumerable: true, get: function () { return mutation_access_2.QuinnMutationAccessError; } });
+var knowledge_2 = require("./services/knowledge");
+Object.defineProperty(exports, "KnowledgeDocumentsService", { enumerable: true, get: function () { return knowledge_2.KnowledgeDocumentsService; } });
+Object.defineProperty(exports, "KnowledgeFoldersService", { enumerable: true, get: function () { return knowledge_2.KnowledgeFoldersService; } });
+Object.defineProperty(exports, "KnowledgeService", { enumerable: true, get: function () { return knowledge_2.KnowledgeService; } });
 class Quinn {
     config;
     http;
     organizations;
+    knowledge;
     members;
     roles;
     levels;
     competencies;
+    courses;
+    groups;
+    programs;
+    progress;
     endorsements;
     constructor(config = {}) {
         this.config = (0, config_1.resolveQuinnConfig)(config);
         this.http =
             this.config.httpClient ??
-                (0, http_1.createQuinnHttpClient)({ apiUrl: this.config.apiUrl, token: this.config.token });
-        this.organizations = new organizations_1.OrganizationsService(this.http, this.orgPath);
-        this.members = new members_1.MembersService(this.http, this.orgPath);
-        this.roles = new roles_1.RolesService(this.http, this.orgPath);
-        this.levels = new levels_1.LevelsService(this.http, this.orgPath);
-        this.competencies = new competencies_1.CompetenciesService(this.http, this.orgPath);
-        this.endorsements = new endorsements_1.EndorsementsService(this.http, this.orgPath);
+                (0, http_1.createQuinnHttpClient)({
+                    apiUrl: this.config.apiUrl,
+                    token: this.config.token,
+                    orgId: this.config.orgId,
+                });
+        this.organizations = new organizations_1.OrganizationsService(this.http, this.assertMutationAllowed);
+        this.knowledge = new knowledge_1.KnowledgeService(this.http);
+        this.members = new members_1.MembersService(this.http, this.assertMutationAllowed);
+        this.roles = new roles_1.RolesService(this.http);
+        this.levels = new levels_1.LevelsService(this.http);
+        this.competencies = new competencies_1.CompetenciesService(this.http);
+        this.courses = new courses_1.CoursesService(this.http);
+        this.groups = new groups_1.GroupsService(this.http);
+        this.programs = new programs_1.ProgramsService(this.http);
+        this.progress = new progress_1.ProgressService(this.http);
+        this.endorsements = new endorsements_1.EndorsementsService(this.http, this.assertMutationAllowed);
     }
-    orgPath = () => `/platform/v1/orgs/${this.config.orgId}`;
+    assertMutationAllowed = (operation) => {
+        (0, mutation_access_1.assertMutationAllowed)(this.config.mutationAccess, operation);
+    };
 }
 exports.Quinn = Quinn;

package/dist/mutation-access.d.ts

@@ -0,0 +1,13 @@
+export type QuinnMutationAccess = 'read_only' | 'needs_confirmation' | 'full_access';
+export declare class QuinnMutationAccessError extends Error {
+    readonly access: QuinnMutationAccess;
+    readonly operation: string;
+    readonly code: 'MUTATION_BLOCKED' | 'MUTATION_CONFIRMATION_REQUIRED';
+    constructor(input: {
+        access: QuinnMutationAccess;
+        operation: string;
+        code: 'MUTATION_BLOCKED' | 'MUTATION_CONFIRMATION_REQUIRED';
+        message: string;
+    });
+}
+export declare function assertMutationAllowed(access: QuinnMutationAccess, operation: string): void;

package/dist/mutation-access.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuinnMutationAccessError = void 0;
+exports.assertMutationAllowed = assertMutationAllowed;
+class QuinnMutationAccessError extends Error {
+    access;
+    operation;
+    code;
+    constructor(input) {
+        super(input.message);
+        this.name = 'QuinnMutationAccessError';
+        this.access = input.access;
+        this.operation = input.operation;
+        this.code = input.code;
+    }
+}
+exports.QuinnMutationAccessError = QuinnMutationAccessError;
+function assertMutationAllowed(access, operation) {
+    if (access === 'full_access') {
+        return;
+    }
+    if (access === 'needs_confirmation') {
+        throw new QuinnMutationAccessError({
+            access,
+            operation,
+            code: 'MUTATION_CONFIRMATION_REQUIRED',
+            message: `Quinn SDK mutation requires confirmation before executing "${operation}".`,
+        });
+    }
+    throw new QuinnMutationAccessError({
+        access,
+        operation,
+        code: 'MUTATION_BLOCKED',
+        message: `Quinn SDK mutation blocked because mutationAccess is "${access}" for "${operation}".`,
+    });
+}

package/dist/services/competencies.d.ts

@@ -2,8 +2,7 @@ import { AxiosInstance } from 'axios';
 import { CompetenciesListQuery, Competency, Course, PagedResult } from '../types';
 export declare class CompetenciesService {
     private readonly http;
-    private readonly orgPath;
-    constructor(http: AxiosInstance, orgPath: () => string);
+    constructor(http: AxiosInstance);
     list(query: CompetenciesListQuery): Promise<PagedResult<Competency>>;
     get(id: string): Promise<Competency | null>;
     batchGet(ids: string[]): Promise<Competency[]>;

package/dist/services/competencies.js

@@ -3,25 +3,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CompetenciesService = void 0;
 class CompetenciesService {
     http;
-    orgPath;
-    constructor(http, orgPath) {
+    constructor(http) {
         this.http = http;
-        this.orgPath = orgPath;
     }
     async list(query) {
-        const resp = await this.http.get(`${this.orgPath()}/competencies`, { params: query });
+        const resp = await this.http.get('/competencies', { params: query });
         return resp.data;
     }
     async get(id) {
-        const resp = await this.http.get(`${this.orgPath()}/competencies/${id}`);
+        const resp = await this.http.get(`/competencies/${id}`);
         return resp.data.item;
     }
     async batchGet(ids) {
-        const resp = await this.http.post(`${this.orgPath()}/competencies/batch`, { ids });
+        const resp = await this.http.post('/competencies/batch', { ids });
         return resp.data.items;
     }
     async listCourses(id) {
-        const resp = await this.http.get(`${this.orgPath()}/competencies/${id}/courses`);
+        const resp = await this.http.get(`/competencies/${id}/courses`);
         return resp.data.items;
     }
 }

package/dist/services/courses.d.ts

@@ -0,0 +1,12 @@
+import { AxiosInstance } from 'axios';
+import { Course, PagedResult } from '../types';
+export declare class CoursesService {
+    private readonly http;
+    constructor(http: AxiosInstance);
+    list(query?: {
+        limit?: number;
+        token?: string;
+    }): Promise<PagedResult<Course>>;
+    get(id: string): Promise<Course | null>;
+    batchGet(ids: string[]): Promise<Course[]>;
+}

package/dist/services/courses.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoursesService = void 0;
+class CoursesService {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async list(query = {}) {
+        const resp = await this.http.get('/courses', { params: query });
+        return resp.data;
+    }
+    async get(id) {
+        const resp = await this.http.get(`/courses/${id}`);
+        return resp.data.item;
+    }
+    async batchGet(ids) {
+        const resp = await this.http.post('/courses/batch', { ids });
+        return resp.data.items;
+    }
+}
+exports.CoursesService = CoursesService;

package/dist/services/endorsements.d.ts

@@ -1,10 +1,12 @@
 import { AxiosInstance } from 'axios';
-import { Endorsement, ListEndorsementsInput } from '../types';
+import { EndorseCompetencyInput, Endorsement, ListEndorsementsInput, ResetEndorsementInput } from '../types';
 export declare class EndorsementsService {
     private readonly http;
-    private readonly orgPath;
-    constructor(http: AxiosInstance, orgPath: () => string);
+    private readonly assertMutationAllowed;
+    constructor(http: AxiosInstance, assertMutationAllowed: (operation: string) => void);
     get(id: string): Promise<Endorsement | null>;
     find(uid: string, competencyId: string): Promise<Endorsement | null>;
     list(input: ListEndorsementsInput): Promise<Endorsement[]>;
+    endorse(input: EndorseCompetencyInput): Promise<Endorsement | null>;
+    reset(input: ResetEndorsementInput): Promise<Endorsement | null>;
 }

package/dist/services/endorsements.js

@@ -3,22 +3,32 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EndorsementsService = void 0;
 class EndorsementsService {
     http;
-    orgPath;
-    constructor(http, orgPath) {
+    assertMutationAllowed;
+    constructor(http, assertMutationAllowed) {
         this.http = http;
-        this.orgPath = orgPath;
+        this.assertMutationAllowed = assertMutationAllowed;
     }
     async get(id) {
-        const resp = await this.http.get(`${this.orgPath()}/endorsements/${id}`);
+        const resp = await this.http.get(`/endorsements/${id}`);
         return resp.data.item;
     }
     async find(uid, competencyId) {
-        const resp = await this.http.get(`${this.orgPath()}/endorsements/find`, { params: { uid, competencyId } });
+        const resp = await this.http.get('/endorsements/find', { params: { uid, competencyId } });
         return resp.data.item;
     }
     async list(input) {
-        const resp = await this.http.post(`${this.orgPath()}/endorsements/list`, input);
+        const resp = await this.http.post('/endorsements/list', input);
         return resp.data.items;
     }
+    async endorse(input) {
+        this.assertMutationAllowed('endorsements.endorse');
+        const resp = await this.http.post('/endorsements/endorse', input);
+        return resp.data.item;
+    }
+    async reset(input) {
+        this.assertMutationAllowed('endorsements.reset');
+        const resp = await this.http.post('/endorsements/reset', input);
+        return resp.data.item;
+    }
 }
 exports.EndorsementsService = EndorsementsService;

package/dist/services/groups.d.ts

@@ -0,0 +1,10 @@
+import { AxiosInstance } from 'axios';
+import { Group, GroupMember } from '../types';
+export declare class GroupsService {
+    private readonly http;
+    constructor(http: AxiosInstance);
+    list(): Promise<Group[]>;
+    get(id: string): Promise<Group | null>;
+    batchGet(ids: string[]): Promise<Group[]>;
+    listMembers(groupId: string): Promise<GroupMember[]>;
+}

package/dist/services/groups.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupsService = void 0;
+class GroupsService {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async list() {
+        const resp = await this.http.get('/groups');
+        return resp.data.items;
+    }
+    async get(id) {
+        const resp = await this.http.get(`/groups/${id}`);
+        return resp.data.item;
+    }
+    async batchGet(ids) {
+        const resp = await this.http.post('/groups/batch', { ids });
+        return resp.data.items;
+    }
+    async listMembers(groupId) {
+        const resp = await this.http.get(`/groups/${groupId}/members`);
+        return resp.data.items;
+    }
+}
+exports.GroupsService = GroupsService;

package/dist/services/knowledge.d.ts

@@ -0,0 +1,24 @@
+import { AxiosInstance } from 'axios';
+import { GetDocumentTranscriptResponse, KnowledgeDocument, KnowledgeDocumentsListQuery, KnowledgeFolder, KnowledgeFoldersListQuery, KnowledgeSearchHit, KnowledgeSearchInput, PagedResult } from '../types';
+export declare class KnowledgeDocumentsService {
+    private readonly http;
+    constructor(http: AxiosInstance);
+    list(query?: KnowledgeDocumentsListQuery): Promise<PagedResult<KnowledgeDocument>>;
+    get(id: string): Promise<KnowledgeDocument | null>;
+    getTranscript(id: string): Promise<GetDocumentTranscriptResponse>;
+}
+export declare class KnowledgeFoldersService {
+    private readonly http;
+    constructor(http: AxiosInstance);
+    list(query?: KnowledgeFoldersListQuery): Promise<{
+        items: KnowledgeFolder[];
+    }>;
+    get(id: string): Promise<KnowledgeFolder | null>;
+}
+export declare class KnowledgeService {
+    private readonly http;
+    readonly documents: KnowledgeDocumentsService;
+    readonly folders: KnowledgeFoldersService;
+    constructor(http: AxiosInstance);
+    search(input: KnowledgeSearchInput): Promise<KnowledgeSearchHit[]>;
+}

package/dist/services/knowledge.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnowledgeService = exports.KnowledgeFoldersService = exports.KnowledgeDocumentsService = void 0;
+class KnowledgeDocumentsService {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async list(query = {}) {
+        const resp = await this.http.get('/knowledge/documents', { params: query });
+        return resp.data;
+    }
+    async get(id) {
+        const resp = await this.http.get(`/knowledge/documents/${id}`);
+        return resp.data.item;
+    }
+    async getTranscript(id) {
+        const resp = await this.http.get(`/knowledge/documents/${id}/transcript`);
+        return resp.data;
+    }
+}
+exports.KnowledgeDocumentsService = KnowledgeDocumentsService;
+class KnowledgeFoldersService {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async list(query = {}) {
+        const resp = await this.http.get('/knowledge/folders', { params: query });
+        return resp.data;
+    }
+    async get(id) {
+        const resp = await this.http.get(`/knowledge/folders/${id}`);
+        return resp.data.item;
+    }
+}
+exports.KnowledgeFoldersService = KnowledgeFoldersService;
+class KnowledgeService {
+    http;
+    documents;
+    folders;
+    constructor(http) {
+        this.http = http;
+        this.documents = new KnowledgeDocumentsService(http);
+        this.folders = new KnowledgeFoldersService(http);
+    }
+    async search(input) {
+        const resp = await this.http.post('/knowledge/search', input);
+        return resp.data.items;
+    }
+}
+exports.KnowledgeService = KnowledgeService;

package/dist/services/levels.d.ts

@@ -2,8 +2,7 @@ import { AxiosInstance } from 'axios';
 import { Level, LevelsListQuery, PagedResult } from '../types';
 export declare class LevelsService {
     private readonly http;
-    private readonly orgPath;
-    constructor(http: AxiosInstance, orgPath: () => string);
+    constructor(http: AxiosInstance);
     list(query: LevelsListQuery): Promise<PagedResult<Level>>;
     get(id: string): Promise<Level | null>;
     batchGet(ids: string[]): Promise<Level[]>;

package/dist/services/levels.js

@@ -3,23 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LevelsService = void 0;
 class LevelsService {
     http;
-    orgPath;
-    constructor(http, orgPath) {
+    constructor(http) {
         this.http = http;
-        this.orgPath = orgPath;
     }
     async list(query) {
-        const resp = await this.http.get(`${this.orgPath()}/levels`, {
+        const resp = await this.http.get('/levels', {
             params: query,
         });
         return resp.data;
     }
     async get(id) {
-        const resp = await this.http.get(`${this.orgPath()}/levels/${id}`);
+        const resp = await this.http.get(`/levels/${id}`);
         return resp.data.item;
     }
     async batchGet(ids) {
-        const resp = await this.http.post(`${this.orgPath()}/levels/batch`, { ids });
+        const resp = await this.http.post('/levels/batch', { ids });
         return resp.data.items;
     }
 }

package/dist/services/members.d.ts

@@ -1,9 +1,9 @@
 import { AxiosInstance } from 'axios';
-import { Member, MembersBatchGetInput, MembersListQuery, PagedResult } from '../types';
+import { MembersBatchDeleteInput, Member, MembersBatchGetInput, MembersCreateInput, MembersListQuery, MembersUpdateManagerInput, MembersUpdateProfileInput, MembersUpdatePrivilegeInput, MembersUpdateRolesInput, PagedResult } from '../types';
 export declare class MembersService {
     private readonly http;
-    private readonly orgPath;
-    constructor(http: AxiosInstance, orgPath: () => string);
+    private readonly assertMutationAllowed;
+    constructor(http: AxiosInstance, assertMutationAllowed: (operation: string) => void);
     list(query?: MembersListQuery): Promise<PagedResult<Member>>;
     listManagers(query?: {
         limit?: number;
@@ -12,4 +12,11 @@ export declare class MembersService {
     }): Promise<PagedResult<Member>>;
     get(id: string): Promise<Member | null>;
     batchGet(input: string[] | MembersBatchGetInput): Promise<Member[]>;
+    delete(memberId: string): Promise<void>;
+    batchDelete(input: string[] | MembersBatchDeleteInput): Promise<void>;
+    create(input: MembersCreateInput): Promise<Member | null>;
+    updatePrivilege(input: MembersUpdatePrivilegeInput): Promise<Member | null>;
+    updateRoles(input: MembersUpdateRolesInput): Promise<Member | null>;
+    updateManager(input: MembersUpdateManagerInput): Promise<Member | null>;
+    updateProfile(input: MembersUpdateProfileInput): Promise<Member | null>;
 }

package/dist/services/members.js

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MembersService = void 0;
 class MembersService {
     http;
-    orgPath;
-    constructor(http, orgPath) {
+    assertMutationAllowed;
+    constructor(http, assertMutationAllowed) {
         this.http = http;
-        this.orgPath = orgPath;
+        this.assertMutationAllowed = assertMutationAllowed;
     }
     async list(query = {}) {
         const params = {
@@ -18,23 +18,65 @@ class MembersService {
                 ? query.privilege.join(',')
                 : query.privilege,
         };
-        const resp = await this.http.get(`${this.orgPath()}/members`, { params });
+        const resp = await this.http.get('/members', { params });
         return resp.data;
     }
     async listManagers(query = {}) {
-        const resp = await this.http.get(`${this.orgPath()}/members/managers`, { params: query });
+        const resp = await this.http.get('/members/managers', {
+            params: query,
+        });
         return resp.data;
     }
     async get(id) {
-        const resp = await this.http.get(`${this.orgPath()}/members/${id}`);
+        const resp = await this.http.get(`/members/${id}`);
         return resp.data.item;
     }
     async batchGet(input) {
         const body = Array.isArray(input)
             ? { ids: input }
             : input;
-        const resp = await this.http.post(`${this.orgPath()}/members/batch`, body);
+        const resp = await this.http.post('/members/batch', body);
         return resp.data.items;
     }
+    async delete(memberId) {
+        this.assertMutationAllowed('members.delete');
+        await this.http.delete(`/members/${memberId}`);
+    }
+    async batchDelete(input) {
+        this.assertMutationAllowed('members.batchDelete');
+        const body = Array.isArray(input)
+            ? { uids: input }
+            : input;
+        await this.http.post('/members/batch-delete', body);
+    }
+    async create(input) {
+        this.assertMutationAllowed('members.create');
+        const resp = await this.http.post('/members', input);
+        return resp.data.item;
+    }
+    async updatePrivilege(input) {
+        this.assertMutationAllowed('members.updatePrivilege');
+        const resp = await this.http.patch(`/members/${input.memberId}/privilege`, { privilege: input.privilege });
+        return resp.data.item;
+    }
+    async updateRoles(input) {
+        this.assertMutationAllowed('members.updateRoles');
+        const resp = await this.http.put(`/members/${input.memberId}/roles`, { roleIds: input.roleIds });
+        return resp.data.item;
+    }
+    async updateManager(input) {
+        this.assertMutationAllowed('members.updateManager');
+        const resp = await this.http.put(`/members/${input.memberId}/manager`, { managerUid: input.managerUid });
+        return resp.data.item;
+    }
+    async updateProfile(input) {
+        this.assertMutationAllowed('members.updateProfile');
+        const resp = await this.http.patch(`/members/${input.memberId}/profile`, {
+            firstName: input.firstName,
+            lastName: input.lastName,
+            phoneNumber: input.phoneNumber,
+        });
+        return resp.data.item;
+    }
 }
 exports.MembersService = MembersService;

package/dist/services/organizations.d.ts

@@ -1,8 +1,9 @@
 import { AxiosInstance } from 'axios';
-import { OrganizationDetails } from '../types';
+import { OrganizationDetails, OrganizationUpdateInput } from '../types';
 export declare class OrganizationsService {
     private readonly http;
-    private readonly orgPath;
-    constructor(http: AxiosInstance, orgPath: () => string);
+    private readonly assertMutationAllowed;
+    constructor(http: AxiosInstance, assertMutationAllowed: (operation: string) => void);
     current(): Promise<OrganizationDetails>;
+    update(input: OrganizationUpdateInput): Promise<OrganizationDetails>;
 }

package/dist/services/organizations.js

@@ -3,13 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OrganizationsService = void 0;
 class OrganizationsService {
     http;
-    orgPath;
-    constructor(http, orgPath) {
+    assertMutationAllowed;
+    constructor(http, assertMutationAllowed) {
         this.http = http;
-        this.orgPath = orgPath;
+        this.assertMutationAllowed = assertMutationAllowed;
     }
     async current() {
-        const resp = await this.http.get(this.orgPath());
+        const resp = await this.http.get('/');
+        return resp.data.item;
+    }
+    async update(input) {
+        this.assertMutationAllowed('organizations.update');
+        const resp = await this.http.patch('/', input);
         return resp.data.item;
     }
 }

package/dist/services/programs.d.ts

@@ -0,0 +1,12 @@
+import { AxiosInstance } from 'axios';
+import { PagedResult, Program } from '../types';
+export declare class ProgramsService {
+    private readonly http;
+    constructor(http: AxiosInstance);
+    list(query?: {
+        limit?: number;
+        token?: string;
+    }): Promise<PagedResult<Program>>;
+    get(id: string): Promise<Program | null>;
+    batchGet(ids: string[]): Promise<Program[]>;
+}

package/dist/services/programs.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProgramsService = void 0;
+class ProgramsService {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async list(query = {}) {
+        const resp = await this.http.get('/programs', { params: query });
+        return resp.data;
+    }
+    async get(id) {
+        const resp = await this.http.get(`/programs/${id}`);
+        return resp.data.item;
+    }
+    async batchGet(ids) {
+        const resp = await this.http.post('/programs/batch', { ids });
+        return resp.data.items;
+    }
+}
+exports.ProgramsService = ProgramsService;

package/dist/services/progress.d.ts

@@ -0,0 +1,10 @@
+import { AxiosInstance } from 'axios';
+import { Progress, ProgressesBatchQueryInputItem, ProgressesListInput, ProgressSummary } from '../types';
+export declare class ProgressService {
+    private readonly http;
+    constructor(http: AxiosInstance);
+    list(input: ProgressesListInput): Promise<Progress[]>;
+    batchQuery(items: ProgressesBatchQueryInputItem[]): Promise<Progress[]>;
+    summary(input: ProgressesListInput): Promise<ProgressSummary>;
+    courseSummary(courseId: string): Promise<ProgressSummary>;
+}

package/dist/services/progress.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProgressService = void 0;
+class ProgressService {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async list(input) {
+        const params = {
+            userIds: input.userIds?.join(','),
+            courseIds: input.courseIds?.join(','),
+        };
+        const resp = await this.http.get('/progress', { params });
+        return resp.data.items;
+    }
+    async batchQuery(items) {
+        const resp = await this.http.post('/progress/batch', { items });
+        return resp.data.items;
+    }
+    async summary(input) {
+        const params = {
+            userIds: input.userIds?.join(','),
+            courseIds: input.courseIds?.join(','),
+        };
+        const resp = await this.http.get('/progress/summary', { params });
+        return resp.data.item;
+    }
+    async courseSummary(courseId) {
+        const resp = await this.http.get(`/progress/summary/courses/${courseId}`);
+        return resp.data.item;
+    }
+}
+exports.ProgressService = ProgressService;

package/dist/services/roles.d.ts

@@ -2,8 +2,7 @@ import { AxiosInstance } from 'axios';
 import { Role } from '../types';
 export declare class RolesService {
     private readonly http;
-    private readonly orgPath;
-    constructor(http: AxiosInstance, orgPath: () => string);
+    constructor(http: AxiosInstance);
     list(): Promise<Role[]>;
     get(id: string): Promise<Role | null>;
     batchGet(ids: string[]): Promise<Role[]>;

package/dist/services/roles.js

@@ -3,21 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RolesService = void 0;
 class RolesService {
     http;
-    orgPath;
-    constructor(http, orgPath) {
+    constructor(http) {
         this.http = http;
-        this.orgPath = orgPath;
     }
     async list() {
-        const resp = await this.http.get(`${this.orgPath()}/roles`);
+        const resp = await this.http.get('/roles');
         return resp.data.items;
     }
     async get(id) {
-        const resp = await this.http.get(`${this.orgPath()}/roles/${id}`);
+        const resp = await this.http.get(`/roles/${id}`);
         return resp.data.item;
     }
     async batchGet(ids) {
-        const resp = await this.http.post(`${this.orgPath()}/roles/batch`, { ids });
+        const resp = await this.http.post('/roles/batch', { ids });
         return resp.data.items;
     }
 }

package/dist/types.d.ts

@@ -10,6 +10,11 @@ export interface PagedResult<T> {
 export interface Organization {
     id: string;
     name: string;
+    brandColor: string;
+    logo: {
+        id: string;
+        url: string;
+    } | null;
 }
 export interface OrganizationDetails {
     organization: Organization | null;
@@ -21,6 +26,11 @@ export interface OrganizationDetails {
         competencies: number;
     };
 }
+export interface OrganizationUpdateInput {
+    name?: string;
+    logoId?: string;
+    brandColor?: string;
+}
 export interface Member {
     userId: string;
     email: string;
@@ -42,6 +52,33 @@ export interface MembersBatchGetInput {
     ids?: string[];
     emails?: string[];
 }
+export interface MembersBatchDeleteInput {
+    uids: string[];
+}
+export interface MembersCreateInput {
+    email: string;
+    firstName: string;
+    lastName: string;
+    sendInvite?: boolean;
+}
+export interface MembersUpdatePrivilegeInput {
+    memberId: string;
+    privilege: Privilege;
+}
+export interface MembersUpdateRolesInput {
+    memberId: string;
+    roleIds: string[];
+}
+export interface MembersUpdateManagerInput {
+    memberId: string;
+    managerUid: string;
+}
+export interface MembersUpdateProfileInput {
+    memberId: string;
+    firstName?: string;
+    lastName?: string;
+    phoneNumber?: string;
+}
 export interface Role {
     id: string;
     label: string;
@@ -85,6 +122,98 @@ export interface Course {
     creatorUid: string;
     createdAt: string;
 }
+export interface KnowledgeSearchInput {
+    query: string;
+    folderId?: string;
+    size?: number;
+}
+export interface KnowledgeSearchHit {
+    id: string;
+    type: string;
+    text: string;
+    metadata?: Record<string, unknown>;
+}
+export interface KnowledgeDocument {
+    id: string;
+    name: string;
+    uid: string;
+    orgId: string;
+    parentId: string;
+    parentType: string;
+    status: string;
+    extFileId: string | null;
+    contentType: string | null;
+    originalContentLength: number;
+    contentLength: number;
+    downloadable: boolean;
+    folderId: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface KnowledgeDocumentsListQuery extends PaginationQuery {
+    folderId?: string;
+    name?: string;
+    includePackFiles?: boolean;
+}
+export interface GetDocumentTranscriptResponse {
+    content: string;
+}
+export interface KnowledgeFolder {
+    id: string;
+    orgId: string;
+    name: string;
+    parentId: string | null;
+    createdBy: string;
+    children?: KnowledgeFolder[];
+    createdAt: string;
+    updatedAt: string;
+}
+export interface KnowledgeFoldersListQuery {
+    parentId?: string;
+}
+export interface Group {
+    id: string;
+    name: string;
+    creatorUid: string;
+    createdAt: string;
+}
+export interface GroupMember {
+    groupId: string;
+    userId: string;
+    addedByUid: string;
+    addedAt: string;
+}
+export interface Program {
+    id: string;
+    name: string;
+    creatorUid: string;
+    createdAt: string;
+    settings?: {
+        managerOnlyEndorsement: boolean;
+    };
+}
+export interface Progress {
+    id: string;
+    userId: string;
+    courseId: string;
+    progressPct: number;
+    completedAt: string | null;
+    score: number | null;
+}
+export interface ProgressSummary {
+    total: number;
+    numCompleted: number;
+    numInProgress: number;
+    numNotStarted: number;
+}
+export interface ProgressesListInput {
+    userIds?: string[];
+    courseIds?: string[];
+}
+export interface ProgressesBatchQueryInputItem {
+    userId: string;
+    courseId: string;
+}
 export interface Endorsement {
     id: string;
     uid: string;
@@ -105,3 +234,13 @@ export interface ListEndorsementsInput {
     uids: string[];
     competencyIds: string[];
 }
+export interface EndorseCompetencyInput {
+    uid: string;
+    competencyId: string;
+    note?: string;
+}
+export interface ResetEndorsementInput {
+    uid: string;
+    competencyId: string;
+    reason: string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@totoday/quinn-sdk",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [