@timeback/oneroster 0.2.1-beta.20260313023436 → 0.2.1-beta.20260330020222

package/dist/{chunk-4fwv2yyb.js → chunk-bnh0e9yt.js}

@@ -643,6 +643,13 @@ var BEYONDAI_PATHS = {
     webhookFilterUpdate: "/webhook-filters/{id}",
     webhookFilterDelete: "/webhook-filters/{id}",
     webhookFiltersByWebhook: "/webhook-filters/webhook/{webhookId}"
+  },
+  reporting: {
+    mcp: "/mcp/reporting",
+    savedQueryExecute: "/reporting/saved-queries/{id}",
+    adminGroupCheck: "/mcp/admin/users/{email}/group",
+    adminGroupAdd: "/mcp/admin/users/{email}/group",
+    adminGroupRemove: "/mcp/admin/users/{email}/group"
   }
 };
 var LEARNWITHAI_PATHS = {
@@ -659,6 +666,7 @@ var LEARNWITHAI_PATHS = {
     resources: "/resources/1.0"
   },
   webhooks: null,
+  reporting: null,
   edubridge: null,
   powerpath: null,
   clr: null,
@@ -687,6 +695,7 @@ function resolvePathProfiles(pathProfile, customPaths) {
     caliper: customPaths?.caliper ?? basePaths.caliper,
     oneroster: customPaths?.oneroster ?? basePaths.oneroster,
     webhooks: customPaths?.webhooks ?? basePaths.webhooks,
+    reporting: customPaths?.reporting ?? basePaths.reporting,
     edubridge: customPaths?.edubridge ?? basePaths.edubridge,
     powerpath: customPaths?.powerpath ?? basePaths.powerpath,
     clr: customPaths?.clr ?? basePaths.clr,
@@ -699,11 +708,11 @@ class TimebackProvider {
   env;
   auth;
   timeout;
-  endpoints;
-  authUrl;
-  tokenScope;
-  pathProfiles;
-  tokenManagers = new Map;
+  _endpoints;
+  _authUrl;
+  _tokenScope;
+  _pathProfiles;
+  _tokenManagers = new Map;
   constructor(config) {
     this.timeout = config.timeout ?? 30000;
     if (isEnvConfig(config)) {
@@ -716,84 +725,89 @@ class TimebackProvider {
       if (!platformEndpoints) {
         throw new Error(`Unknown platform: ${platform}`);
       }
-      this.authUrl = platformEndpoints.token[env];
-      this.tokenScope = platformEndpoints.tokenScope ?? undefined;
-      this.pathProfiles = PLATFORM_PATHS[platform] ?? BEYONDAI_PATHS;
-      this.endpoints = {
+      this._authUrl = platformEndpoints.token[env];
+      this._tokenScope = platformEndpoints.tokenScope ?? undefined;
+      this._pathProfiles = PLATFORM_PATHS[platform] ?? BEYONDAI_PATHS;
+      this._endpoints = {
         oneroster: {
           baseUrl: platformEndpoints.api[env],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
         },
         edubridge: {
           baseUrl: platformEndpoints.api[env],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
         },
         powerpath: {
           baseUrl: platformEndpoints.api[env],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
         },
         clr: {
           baseUrl: platformEndpoints.api[env],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
         },
         case: {
           baseUrl: platformEndpoints.api[env],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
         },
         caliper: {
           baseUrl: platformEndpoints.caliper[env],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
         },
         webhooks: {
           baseUrl: platformEndpoints.caliper[env],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
+        },
+        reporting: {
+          baseUrl: platformEndpoints.api[env],
+          authUrl: this._authUrl
         },
         qti: {
           baseUrl: platformEndpoints.qti[env],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
         }
       };
     } else if (isExplicitConfig(config)) {
       this.auth = config.auth;
-      this.authUrl = config.authUrl;
-      this.pathProfiles = resolvePathProfiles(config.pathProfile, config.paths);
-      this.endpoints = {
-        oneroster: { baseUrl: config.baseUrl, authUrl: this.authUrl },
-        edubridge: { baseUrl: config.baseUrl, authUrl: this.authUrl },
-        powerpath: { baseUrl: config.baseUrl, authUrl: this.authUrl },
-        clr: { baseUrl: config.baseUrl, authUrl: this.authUrl },
-        case: { baseUrl: config.baseUrl, authUrl: this.authUrl },
-        caliper: { baseUrl: config.baseUrl, authUrl: this.authUrl },
-        webhooks: { baseUrl: config.baseUrl, authUrl: this.authUrl },
-        qti: { baseUrl: config.baseUrl, authUrl: this.authUrl }
+      this._authUrl = config.authUrl;
+      this._pathProfiles = resolvePathProfiles(config.pathProfile, config.paths);
+      this._endpoints = {
+        oneroster: { baseUrl: config.baseUrl, authUrl: this._authUrl },
+        edubridge: { baseUrl: config.baseUrl, authUrl: this._authUrl },
+        powerpath: { baseUrl: config.baseUrl, authUrl: this._authUrl },
+        clr: { baseUrl: config.baseUrl, authUrl: this._authUrl },
+        case: { baseUrl: config.baseUrl, authUrl: this._authUrl },
+        caliper: { baseUrl: config.baseUrl, authUrl: this._authUrl },
+        webhooks: { baseUrl: config.baseUrl, authUrl: this._authUrl },
+        reporting: { baseUrl: config.baseUrl, authUrl: this._authUrl },
+        qti: { baseUrl: config.baseUrl, authUrl: this._authUrl }
       };
     } else if (isServicesConfig(config)) {
       this.auth = config.auth;
-      this.authUrl = config.authUrl;
-      this.pathProfiles = resolvePathProfiles(config.pathProfile, config.paths);
-      this.endpoints = {};
+      this._authUrl = config.authUrl;
+      this._pathProfiles = resolvePathProfiles(config.pathProfile, config.paths);
+      this._endpoints = {};
       for (const [service, baseUrl] of Object.entries(config.services)) {
         if (baseUrl) {
-          this.endpoints[service] = {
+          this._endpoints[service] = {
             baseUrl,
-            authUrl: this.authUrl
+            authUrl: this._authUrl
           };
         }
       }
     } else {
       throw new Error("Invalid provider configuration");
     }
-    for (const service of Object.keys(this.pathProfiles)) {
-      if (this.pathProfiles[service] === null) {
-        delete this.endpoints[service];
+    for (const service of Object.keys(this._pathProfiles)) {
+      if (this._pathProfiles[service] === null) {
+        delete this._endpoints[service];
       }
     }
   }
   getEndpoint(service) {
-    const endpoint = this.endpoints[service];
+    const endpoint = this._endpoints[service];
     if (!endpoint) {
       const pathKey = service;
-      if (pathKey in this.pathProfiles && this.pathProfiles[pathKey] === null) {
+      if (pathKey in this._pathProfiles && this._pathProfiles[pathKey] === null) {
         throw new Error(`Service "${service}" is not supported on ${this.platform ?? "this"} platform.`);
       }
       throw new Error(`Service "${service}" is not configured in this provider`);
@@ -801,13 +815,13 @@ class TimebackProvider {
     return endpoint;
   }
   hasService(service) {
-    return service in this.endpoints;
+    return service in this._endpoints;
   }
   getAvailableServices() {
-    return Object.keys(this.endpoints);
+    return Object.keys(this._endpoints);
   }
   getTokenUrl() {
-    return this.authUrl;
+    return this._authUrl;
   }
   getEndpointWithPaths(service) {
     const endpoint = this.getEndpoint(service);
@@ -815,17 +829,17 @@ class TimebackProvider {
     return { ...endpoint, paths };
   }
   getPaths() {
-    return this.pathProfiles;
+    return this._pathProfiles;
   }
   getServicePaths(service) {
-    const paths = this.pathProfiles[service];
+    const paths = this._pathProfiles[service];
     if (!paths) {
       throw new Error(`Service "${service}" is not supported on ${this.platform ?? "this"} platform.`);
     }
     return paths;
   }
   hasServiceSupport(service) {
-    return this.pathProfiles[service] !== null;
+    return this._pathProfiles[service] !== null;
   }
   getTokenProvider(service) {
     const endpoint = this.getEndpoint(service);
@@ -836,7 +850,7 @@ class TimebackProvider {
     if (!this.auth) {
       throw new Error(`Service "${service}" requires authentication but no credentials were provided`);
     }
-    let manager = this.tokenManagers.get(authUrl);
+    let manager = this._tokenManagers.get(authUrl);
     if (!manager) {
       manager = new TokenManager({
         tokenUrl: authUrl,
@@ -844,28 +858,28 @@ class TimebackProvider {
           clientId: this.auth.clientId,
           clientSecret: this.auth.clientSecret
         },
-        scope: this.tokenScope
+        scope: this._tokenScope
       });
-      this.tokenManagers.set(authUrl, manager);
+      this._tokenManagers.set(authUrl, manager);
     }
     return manager;
   }
   async checkAuth() {
-    if (!this.authUrl || !this.auth) {
+    if (!this._authUrl || !this.auth) {
       throw new Error("No auth configured on this provider");
     }
     const startTime = Date.now();
-    let manager = this.tokenManagers.get(this.authUrl);
+    let manager = this._tokenManagers.get(this._authUrl);
     if (!manager) {
       manager = new TokenManager({
-        tokenUrl: this.authUrl,
+        tokenUrl: this._authUrl,
         credentials: {
           clientId: this.auth.clientId,
           clientSecret: this.auth.clientSecret
         },
-        scope: this.tokenScope
+        scope: this._tokenScope
       });
-      this.tokenManagers.set(this.authUrl, manager);
+      this._tokenManagers.set(this._authUrl, manager);
     }
     try {
       await manager.getToken();
@@ -884,10 +898,10 @@ class TimebackProvider {
     }
   }
   invalidateTokens() {
-    for (const manager of this.tokenManagers.values()) {
+    for (const manager of this._tokenManagers.values()) {
       manager.invalidate?.();
     }
-    this.tokenManagers.clear();
+    this._tokenManagers.clear();
   }
 }
 // ../../internal/client-infra/src/utils/utils.ts

package/dist/errors.js

@@ -5,7 +5,7 @@ import {
   NotFoundError,
   UnauthorizedError,
   ValidationError
-} from "./chunk-4fwv2yyb.js";
+} from "./chunk-bnh0e9yt.js";
 import"./chunk-6jf1natv.js";
 export {
   ValidationError,