timeback 0.2.1 → 0.2.2-beta.20260320221119

package/dist/cli.js

@@ -11676,158 +11676,8 @@ var {
   Help
 } = import__.default;
 
-// ../clients/core/dist/chunk-2z9zawsc.js
+// ../clients/core/dist/chunk-bjb7ngh9.js
 init_chunk_3j7jywnx();
-
-class ApiError extends Error {
-  statusCode;
-  response;
-  name = "ApiError";
-  constructor(message, statusCode, response) {
-    super(message);
-    this.statusCode = statusCode;
-    this.response = response;
-  }
-  get minorCodes() {
-    const ims = this.response;
-    if (!ims?.imsx_CodeMinor?.imsx_codeMinorField) {
-      return [];
-    }
-    return ims.imsx_CodeMinor.imsx_codeMinorField.map((field) => ({
-      field: field.imsx_codeMinorFieldName,
-      value: field.imsx_codeMinorFieldValue
-    }));
-  }
-  get details() {
-    const ims = this.response;
-    return ims?.imsx_error_details ?? [];
-  }
-}
-
-class UnauthorizedError extends ApiError {
-  name = "UnauthorizedError";
-  constructor(message = "Unauthorized", response) {
-    super(message, 401, response);
-  }
-}
-
-class ForbiddenError extends ApiError {
-  name = "ForbiddenError";
-  constructor(message = "Forbidden", response) {
-    super(message, 403, response);
-  }
-}
-
-class NotFoundError extends ApiError {
-  name = "NotFoundError";
-  constructor(message = "Not Found", response) {
-    super(message, 404, response);
-  }
-}
-
-class ValidationError extends ApiError {
-  name = "ValidationError";
-  constructor(message = "Validation Error", response) {
-    super(message, 422, response);
-  }
-}
-
-class InputValidationError extends ApiError {
-  name = "InputValidationError";
-  issues;
-  constructor(message, issues) {
-    const response = {
-      imsx_codeMajor: "failure",
-      imsx_severity: "error",
-      imsx_description: message,
-      imsx_error_details: issues.map((issue) => ({
-        path: issue.path,
-        message: issue.message
-      }))
-    };
-    super(message, 400, response);
-    this.issues = issues;
-  }
-}
-function createInputValidationError(message, issues) {
-  return new InputValidationError(message, issues);
-}
-function isApiError(error) {
-  if (!(error instanceof Error))
-    return false;
-  return "statusCode" in error && "response" in error;
-}
-function escapeValue(value) {
-  if (value instanceof Date) {
-    return value.toISOString();
-  }
-  if (typeof value === "boolean") {
-    return value ? "true" : "false";
-  }
-  if (typeof value === "number") {
-    return String(value);
-  }
-  return value.replaceAll("'", "''");
-}
-function formatValue2(value) {
-  const escaped = escapeValue(value);
-  const needsQuotes = typeof value === "string" || value instanceof Date;
-  return needsQuotes ? `'${escaped}'` : escaped;
-}
-function fieldToConditions(field, condition) {
-  if (typeof condition === "string" || typeof condition === "number" || typeof condition === "boolean" || condition instanceof Date) {
-    return [`${field}=${formatValue2(condition)}`];
-  }
-  if (typeof condition === "object" && condition !== null) {
-    const ops = condition;
-    const conditions = [];
-    if (ops.ne !== undefined) {
-      conditions.push(`${field}!=${formatValue2(ops.ne)}`);
-    }
-    if (ops.gt !== undefined) {
-      conditions.push(`${field}>${formatValue2(ops.gt)}`);
-    }
-    if (ops.gte !== undefined) {
-      conditions.push(`${field}>=${formatValue2(ops.gte)}`);
-    }
-    if (ops.lt !== undefined) {
-      conditions.push(`${field}<${formatValue2(ops.lt)}`);
-    }
-    if (ops.lte !== undefined) {
-      conditions.push(`${field}<=${formatValue2(ops.lte)}`);
-    }
-    if (ops.contains !== undefined) {
-      conditions.push(`${field}~${formatValue2(ops.contains)}`);
-    }
-    if (ops.in !== undefined && ops.in.length > 0) {
-      const inConditions = ops.in.map((v) => `${field}=${formatValue2(v)}`);
-      const joined = inConditions.join(" OR ");
-      conditions.push(inConditions.length > 1 ? `(${joined})` : joined);
-    }
-    if (ops.notIn !== undefined && ops.notIn.length > 0) {
-      const notInConditions = ops.notIn.map((v) => `${field}!=${formatValue2(v)}`);
-      conditions.push(notInConditions.join(" AND "));
-    }
-    return conditions;
-  }
-  return [];
-}
-function isOrCondition(clause) {
-  return "OR" in clause && Array.isArray(clause.OR);
-}
-function whereToFilter(where) {
-  if (isOrCondition(where)) {
-    const orParts = where.OR.map((clause) => whereToFilter(clause)).filter((s) => s !== undefined);
-    return orParts.length > 0 ? orParts.join(" OR ") : undefined;
-  }
-  const conditions = [];
-  for (const [field, condition] of Object.entries(where)) {
-    if (condition !== undefined) {
-      conditions.push(...fieldToConditions(field, condition));
-    }
-  }
-  return conditions.length > 0 ? conditions.join(" AND ") : undefined;
-}
 var PLATFORM_BEYOND_AI = "BEYOND_AI";
 var PLATFORM_LEARNWITH_AI = "LEARNWITH_AI";
 var DEFAULT_PLATFORM = PLATFORM_BEYOND_AI;
@@ -12049,9 +11899,9 @@ var LEVEL_PREFIX = {
   error: "[ERROR]"
 };
 function formatContext2(context) {
-  return Object.entries(context).map(([key, value]) => `${key}=${formatValue22(value)}`).join(" ");
+  return Object.entries(context).map(([key, value]) => `${key}=${formatValue2(value)}`).join(" ");
 }
-function formatValue22(value) {
+function formatValue2(value) {
   if (typeof value === "string")
     return value;
   if (typeof value === "number")
@@ -12368,11 +12218,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)) {
@@ -12385,89 +12235,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
+          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 },
-        reporting: { 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`);
@@ -12475,13 +12325,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);
@@ -12489,17 +12339,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);
@@ -12510,7 +12360,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,
@@ -12518,28 +12368,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();
@@ -12558,10 +12408,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();
   }
 }
 function getEnv(key) {
@@ -12821,6 +12671,156 @@ function resolveToProvider(config, envVars, registry = DEFAULT_PROVIDER_REGISTRY
   }
   throw new Error(buildMissingEnvError(envVars));
 }
+
+class ApiError extends Error {
+  statusCode;
+  response;
+  name = "ApiError";
+  constructor(message, statusCode, response) {
+    super(message);
+    this.statusCode = statusCode;
+    this.response = response;
+  }
+  get minorCodes() {
+    const ims = this.response;
+    if (!ims?.imsx_CodeMinor?.imsx_codeMinorField) {
+      return [];
+    }
+    return ims.imsx_CodeMinor.imsx_codeMinorField.map((field) => ({
+      field: field.imsx_codeMinorFieldName,
+      value: field.imsx_codeMinorFieldValue
+    }));
+  }
+  get details() {
+    const ims = this.response;
+    return ims?.imsx_error_details ?? [];
+  }
+}
+
+class UnauthorizedError extends ApiError {
+  name = "UnauthorizedError";
+  constructor(message = "Unauthorized", response) {
+    super(message, 401, response);
+  }
+}
+
+class ForbiddenError extends ApiError {
+  name = "ForbiddenError";
+  constructor(message = "Forbidden", response) {
+    super(message, 403, response);
+  }
+}
+
+class NotFoundError extends ApiError {
+  name = "NotFoundError";
+  constructor(message = "Not Found", response) {
+    super(message, 404, response);
+  }
+}
+
+class ValidationError extends ApiError {
+  name = "ValidationError";
+  constructor(message = "Validation Error", response) {
+    super(message, 422, response);
+  }
+}
+
+class InputValidationError extends ApiError {
+  name = "InputValidationError";
+  issues;
+  constructor(message, issues) {
+    const response = {
+      imsx_codeMajor: "failure",
+      imsx_severity: "error",
+      imsx_description: message,
+      imsx_error_details: issues.map((issue) => ({
+        path: issue.path,
+        message: issue.message
+      }))
+    };
+    super(message, 400, response);
+    this.issues = issues;
+  }
+}
+function createInputValidationError(message, issues) {
+  return new InputValidationError(message, issues);
+}
+function isApiError(error) {
+  if (!(error instanceof Error))
+    return false;
+  return "statusCode" in error && "response" in error;
+}
+function escapeValue(value) {
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  if (typeof value === "number") {
+    return String(value);
+  }
+  return value.replaceAll("'", "''");
+}
+function formatValue22(value) {
+  const escaped = escapeValue(value);
+  const needsQuotes = typeof value === "string" || value instanceof Date;
+  return needsQuotes ? `'${escaped}'` : escaped;
+}
+function fieldToConditions(field, condition) {
+  if (typeof condition === "string" || typeof condition === "number" || typeof condition === "boolean" || condition instanceof Date) {
+    return [`${field}=${formatValue22(condition)}`];
+  }
+  if (typeof condition === "object" && condition !== null) {
+    const ops = condition;
+    const conditions = [];
+    if (ops.ne !== undefined) {
+      conditions.push(`${field}!=${formatValue22(ops.ne)}`);
+    }
+    if (ops.gt !== undefined) {
+      conditions.push(`${field}>${formatValue22(ops.gt)}`);
+    }
+    if (ops.gte !== undefined) {
+      conditions.push(`${field}>=${formatValue22(ops.gte)}`);
+    }
+    if (ops.lt !== undefined) {
+      conditions.push(`${field}<${formatValue22(ops.lt)}`);
+    }
+    if (ops.lte !== undefined) {
+      conditions.push(`${field}<=${formatValue22(ops.lte)}`);
+    }
+    if (ops.contains !== undefined) {
+      conditions.push(`${field}~${formatValue22(ops.contains)}`);
+    }
+    if (ops.in !== undefined && ops.in.length > 0) {
+      const inConditions = ops.in.map((v) => `${field}=${formatValue22(v)}`);
+      const joined = inConditions.join(" OR ");
+      conditions.push(inConditions.length > 1 ? `(${joined})` : joined);
+    }
+    if (ops.notIn !== undefined && ops.notIn.length > 0) {
+      const notInConditions = ops.notIn.map((v) => `${field}!=${formatValue22(v)}`);
+      conditions.push(notInConditions.join(" AND "));
+    }
+    return conditions;
+  }
+  return [];
+}
+function isOrCondition(clause) {
+  return "OR" in clause && Array.isArray(clause.OR);
+}
+function whereToFilter(where) {
+  if (isOrCondition(where)) {
+    const orParts = where.OR.map((clause) => whereToFilter(clause)).filter((s) => s !== undefined);
+    return orParts.length > 0 ? orParts.join(" OR ") : undefined;
+  }
+  const conditions = [];
+  for (const [field, condition] of Object.entries(where)) {
+    if (condition !== undefined) {
+      conditions.push(...fieldToConditions(field, condition));
+    }
+  }
+  return conditions.length > 0 ? conditions.join(" AND ") : undefined;
+}
 var MAX_RETRIES = 3;
 var RETRY_STATUS_CODES = [429, 503];
 var INITIAL_RETRY_DELAY_MS = 1000;
@@ -26823,7 +26823,7 @@ function date4(params) {
 
 // ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/external.js
 config(en_default());
-// ../clients/core/dist/chunk-aw1d6bdn.js
+// ../clients/core/dist/chunk-2mkbbgd8.js
 var log3 = createScopedLogger("edubridge");
 function normalizeBoolean(value) {
   if (typeof value === "boolean")
@@ -30282,6 +30282,18 @@ class ScoreScalesResource extends BaseResource {
     }
   }
 }
+function normalizeResourceFromApi(resource) {
+  if (!resource.metadata) {
+    return resource;
+  }
+  return {
+    ...resource,
+    metadata: {
+      ...resource.metadata,
+      grades: parseGrades(resource.metadata.grades)
+    }
+  };
+}
 
 class ScopedResourceResource {
   transport;
@@ -30295,7 +30307,7 @@ class ScopedResourceResource {
   }
   async get() {
     const response = await this.transport.request(this.basePath);
-    return response.resource;
+    return normalizeResourceFromApi(response.resource);
   }
   exists() {
     return this.transport.exists(this.basePath);
@@ -30333,6 +30345,9 @@ class ResourcesResourceImpl extends BaseResource {
   get updateSchema() {
     return OneRosterResourceCreateInput.partial();
   }
+  transform(resource) {
+    return normalizeResourceFromApi(resource);
+  }
 }
 function createResourcesResource(transport) {
   const impl = new ResourcesResourceImpl(transport);
@@ -30384,7 +30399,7 @@ class ScopedUserResource {
     return this.streamResources(params).toArray();
   }
   streamResources(params) {
-    return new Paginator3(this.transport, `${this.transport.paths.resources}/resources/users/${this.userId}/resources`, params, "resources");
+    return new Paginator3(this.transport, `${this.transport.paths.resources}/resources/users/${this.userId}/resources`, params, "resources", normalizeResourceFromApi);
   }
   classes(params) {
     return this.streamClasses(params).toArray();
@@ -30869,7 +30884,7 @@ class ScopedClassResource {
     return this.streamResources(params).toArray();
   }
   streamResources(params) {
-    return new Paginator3(this.transport, `${this.transport.paths.resources}/resources/classes/${this.classId}/resources`, params, "resources");
+    return new Paginator3(this.transport, `${this.transport.paths.resources}/resources/classes/${this.classId}/resources`, params, "resources", normalizeResourceFromApi);
   }
   student(studentId) {
     return new ScopedClassStudentResource(this.transport, this.classId, studentId);
@@ -30973,7 +30988,7 @@ class ScopedCourseResource {
     return this.streamResources(params).toArray();
   }
   streamResources(params) {
-    return new Paginator3(this.transport, `${this.transport.paths.resources}/resources/courses/${this.courseId}/resources`, params, "resources");
+    return new Paginator3(this.transport, `${this.transport.paths.resources}/resources/courses/${this.courseId}/resources`, params, "resources", normalizeResourceFromApi);
   }
 }
 
@@ -38016,11 +38031,11 @@ class TimebackProvider2 {
   env;
   auth;
   timeout;
-  endpoints;
-  authUrl;
-  tokenScope;
-  pathProfiles;
-  tokenManagers = new Map;
+  _endpoints;
+  _authUrl;
+  _tokenScope;
+  _pathProfiles;
+  _tokenManagers = new Map;
   constructor(config3) {
     this.timeout = config3.timeout ?? 30000;
     if (isEnvConfig2(config3)) {
@@ -38033,89 +38048,89 @@ class TimebackProvider2 {
       if (!platformEndpoints) {
         throw new Error(`Unknown platform: ${platform3}`);
       }
-      this.authUrl = platformEndpoints.token[env2];
-      this.tokenScope = platformEndpoints.tokenScope ?? undefined;
-      this.pathProfiles = PLATFORM_PATHS2[platform3] ?? BEYONDAI_PATHS2;
-      this.endpoints = {
+      this._authUrl = platformEndpoints.token[env2];
+      this._tokenScope = platformEndpoints.tokenScope ?? undefined;
+      this._pathProfiles = PLATFORM_PATHS2[platform3] ?? BEYONDAI_PATHS2;
+      this._endpoints = {
         oneroster: {
           baseUrl: platformEndpoints.api[env2],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
         },
         edubridge: {
           baseUrl: platformEndpoints.api[env2],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
         },
         powerpath: {
           baseUrl: platformEndpoints.api[env2],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
         },
         clr: {
           baseUrl: platformEndpoints.api[env2],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
         },
         case: {
           baseUrl: platformEndpoints.api[env2],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
         },
         caliper: {
           baseUrl: platformEndpoints.caliper[env2],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
         },
         webhooks: {
           baseUrl: platformEndpoints.caliper[env2],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
         },
         reporting: {
           baseUrl: platformEndpoints.api[env2],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
         },
         qti: {
           baseUrl: platformEndpoints.qti[env2],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
         }
       };
     } else if (isExplicitConfig2(config3)) {
       this.auth = config3.auth;
-      this.authUrl = config3.authUrl;
-      this.pathProfiles = resolvePathProfiles2(config3.pathProfile, config3.paths);
-      this.endpoints = {
-        oneroster: { baseUrl: config3.baseUrl, authUrl: this.authUrl },
-        edubridge: { baseUrl: config3.baseUrl, authUrl: this.authUrl },
-        powerpath: { baseUrl: config3.baseUrl, authUrl: this.authUrl },
-        clr: { baseUrl: config3.baseUrl, authUrl: this.authUrl },
-        case: { baseUrl: config3.baseUrl, authUrl: this.authUrl },
-        caliper: { baseUrl: config3.baseUrl, authUrl: this.authUrl },
-        webhooks: { baseUrl: config3.baseUrl, authUrl: this.authUrl },
-        reporting: { baseUrl: config3.baseUrl, authUrl: this.authUrl },
-        qti: { baseUrl: config3.baseUrl, authUrl: this.authUrl }
+      this._authUrl = config3.authUrl;
+      this._pathProfiles = resolvePathProfiles2(config3.pathProfile, config3.paths);
+      this._endpoints = {
+        oneroster: { baseUrl: config3.baseUrl, authUrl: this._authUrl },
+        edubridge: { baseUrl: config3.baseUrl, authUrl: this._authUrl },
+        powerpath: { baseUrl: config3.baseUrl, authUrl: this._authUrl },
+        clr: { baseUrl: config3.baseUrl, authUrl: this._authUrl },
+        case: { baseUrl: config3.baseUrl, authUrl: this._authUrl },
+        caliper: { baseUrl: config3.baseUrl, authUrl: this._authUrl },
+        webhooks: { baseUrl: config3.baseUrl, authUrl: this._authUrl },
+        reporting: { baseUrl: config3.baseUrl, authUrl: this._authUrl },
+        qti: { baseUrl: config3.baseUrl, authUrl: this._authUrl }
       };
     } else if (isServicesConfig2(config3)) {
       this.auth = config3.auth;
-      this.authUrl = config3.authUrl;
-      this.pathProfiles = resolvePathProfiles2(config3.pathProfile, config3.paths);
-      this.endpoints = {};
+      this._authUrl = config3.authUrl;
+      this._pathProfiles = resolvePathProfiles2(config3.pathProfile, config3.paths);
+      this._endpoints = {};
       for (const [service, baseUrl] of Object.entries(config3.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`);
@@ -38123,13 +38138,13 @@ class TimebackProvider2 {
     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);
@@ -38137,17 +38152,17 @@ class TimebackProvider2 {
     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);
@@ -38158,7 +38173,7 @@ class TimebackProvider2 {
     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 TokenManager2({
         tokenUrl: authUrl,
@@ -38166,28 +38181,28 @@ class TimebackProvider2 {
           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 TokenManager2({
-        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();
@@ -38206,10 +38221,10 @@ class TimebackProvider2 {
     }
   }
   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/errors/errors.ts
@@ -38993,7 +39008,7 @@ async function runImportFlow(opts = {}) {
     configPath
   };
 }
-// ../clients/masterytrack/dist/chunk-7gh7qjve.js
+// ../clients/masterytrack/dist/chunk-740nbf3x.js
 init_chunk_6jf1natv();
 
 class ApiError3 extends Error {
@@ -39613,11 +39628,11 @@ class TimebackProvider3 {
   env;
   auth;
   timeout;
-  endpoints;
-  authUrl;
-  tokenScope;
-  pathProfiles;
-  tokenManagers = new Map;
+  _endpoints;
+  _authUrl;
+  _tokenScope;
+  _pathProfiles;
+  _tokenManagers = new Map;
   constructor(config3) {
     this.timeout = config3.timeout ?? 30000;
     if (isEnvConfig3(config3)) {
@@ -39630,89 +39645,89 @@ class TimebackProvider3 {
       if (!platformEndpoints) {
         throw new Error(`Unknown platform: ${platform3}`);
       }
-      this.authUrl = platformEndpoints.token[env2];
-      this.tokenScope = platformEndpoints.tokenScope ?? undefined;
-      this.pathProfiles = PLATFORM_PATHS3[platform3] ?? BEYONDAI_PATHS3;
-      this.endpoints = {
+      this._authUrl = platformEndpoints.token[env2];
+      this._tokenScope = platformEndpoints.tokenScope ?? undefined;
+      this._pathProfiles = PLATFORM_PATHS3[platform3] ?? BEYONDAI_PATHS3;
+      this._endpoints = {
         oneroster: {
           baseUrl: platformEndpoints.api[env2],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
         },
         edubridge: {
           baseUrl: platformEndpoints.api[env2],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
         },
         powerpath: {
           baseUrl: platformEndpoints.api[env2],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
         },
         clr: {
           baseUrl: platformEndpoints.api[env2],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
         },
         case: {
           baseUrl: platformEndpoints.api[env2],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
         },
         caliper: {
           baseUrl: platformEndpoints.caliper[env2],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
         },
         webhooks: {
           baseUrl: platformEndpoints.caliper[env2],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
         },
         reporting: {
           baseUrl: platformEndpoints.api[env2],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
         },
         qti: {
           baseUrl: platformEndpoints.qti[env2],
-          authUrl: this.authUrl
+          authUrl: this._authUrl
         }
       };
     } else if (isExplicitConfig3(config3)) {
       this.auth = config3.auth;
-      this.authUrl = config3.authUrl;
-      this.pathProfiles = resolvePathProfiles3(config3.pathProfile, config3.paths);
-      this.endpoints = {
-        oneroster: { baseUrl: config3.baseUrl, authUrl: this.authUrl },
-        edubridge: { baseUrl: config3.baseUrl, authUrl: this.authUrl },
-        powerpath: { baseUrl: config3.baseUrl, authUrl: this.authUrl },
-        clr: { baseUrl: config3.baseUrl, authUrl: this.authUrl },
-        case: { baseUrl: config3.baseUrl, authUrl: this.authUrl },
-        caliper: { baseUrl: config3.baseUrl, authUrl: this.authUrl },
-        webhooks: { baseUrl: config3.baseUrl, authUrl: this.authUrl },
-        reporting: { baseUrl: config3.baseUrl, authUrl: this.authUrl },
-        qti: { baseUrl: config3.baseUrl, authUrl: this.authUrl }
+      this._authUrl = config3.authUrl;
+      this._pathProfiles = resolvePathProfiles3(config3.pathProfile, config3.paths);
+      this._endpoints = {
+        oneroster: { baseUrl: config3.baseUrl, authUrl: this._authUrl },
+        edubridge: { baseUrl: config3.baseUrl, authUrl: this._authUrl },
+        powerpath: { baseUrl: config3.baseUrl, authUrl: this._authUrl },
+        clr: { baseUrl: config3.baseUrl, authUrl: this._authUrl },
+        case: { baseUrl: config3.baseUrl, authUrl: this._authUrl },
+        caliper: { baseUrl: config3.baseUrl, authUrl: this._authUrl },
+        webhooks: { baseUrl: config3.baseUrl, authUrl: this._authUrl },
+        reporting: { baseUrl: config3.baseUrl, authUrl: this._authUrl },
+        qti: { baseUrl: config3.baseUrl, authUrl: this._authUrl }
       };
     } else if (isServicesConfig3(config3)) {
       this.auth = config3.auth;
-      this.authUrl = config3.authUrl;
-      this.pathProfiles = resolvePathProfiles3(config3.pathProfile, config3.paths);
-      this.endpoints = {};
+      this._authUrl = config3.authUrl;
+      this._pathProfiles = resolvePathProfiles3(config3.pathProfile, config3.paths);
+      this._endpoints = {};
       for (const [service, baseUrl] of Object.entries(config3.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`);
@@ -39720,13 +39735,13 @@ class TimebackProvider3 {
     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);
@@ -39734,17 +39749,17 @@ class TimebackProvider3 {
     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);
@@ -39755,7 +39770,7 @@ class TimebackProvider3 {
     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 TokenManager3({
         tokenUrl: authUrl,
@@ -39763,28 +39778,28 @@ class TimebackProvider3 {
           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 TokenManager3({
-        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();
@@ -39803,10 +39818,10 @@ class TimebackProvider3 {
     }
   }
   invalidateTokens() {
-    for (const manager of this.tokenManagers.values()) {
+    for (const manager of this._tokenManagers.values()) {
       manager.invalidate?.();
     }
-    this.tokenManagers.clear();
+    this._tokenManagers.clear();
   }
 }
 function getEnv3(key) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "timeback",
-	"version": "0.2.1",
+	"version": "0.2.2-beta.20260320221119",
 	"type": "module",
 	"bin": {
 		"timeback": "./dist/cli.js"