@timeback/webhooks 0.2.1-beta.20260313023436 → 0.2.1-beta.20260331191116

package/dist/{chunk-1dmdawx1.js → chunk-9a1sbh56.js}

@@ -571,6 +571,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 = {
@@ -587,6 +594,7 @@ var LEARNWITHAI_PATHS = {
     resources: "/resources/1.0"
   },
   webhooks: null,
+  reporting: null,
   edubridge: null,
   powerpath: null,
   clr: null,
@@ -615,6 +623,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,
@@ -627,11 +636,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)) {
@@ -644,84 +653,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`);
@@ -729,13 +743,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);
@@ -743,17 +757,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);
@@ -764,7 +778,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,
@@ -772,28 +786,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();
@@ -812,10 +826,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-1dmdawx1.js";
+} from "./chunk-9a1sbh56.js";
 import"./chunk-6jf1natv.js";
 export {
   ApiError as WebhooksError,

package/dist/index.js

@@ -5,7 +5,7 @@ import {
   resolveToProvider,
   validateNonEmptyString,
   validateWithSchema
-} from "./chunk-1dmdawx1.js";
+} from "./chunk-9a1sbh56.js";
 import"./chunk-6jf1natv.js";
 
 // src/constants.ts
@@ -55,7 +55,7 @@ var TimebackSubject = z.enum([
   "None",
   "Other"
 ]).meta({ id: "TimebackSubject", description: "Subject area" });
-var TimebackGrade = z.union([
+var NumericTimebackGrade = z.union([
   z.literal(-1),
   z.literal(0),
   z.literal(1),
@@ -71,7 +71,39 @@ var TimebackGrade = z.union([
   z.literal(11),
   z.literal(12),
   z.literal(13)
-]).meta({
+]);
+var StringTimebackGrade = z.string().transform((value, ctx) => {
+  const raw = value.toLowerCase().trim().replaceAll("_", " ");
+  if (raw === "") {
+    ctx.addIssue({
+      code: "custom",
+      message: "must be a valid Timeback grade"
+    });
+    return z.NEVER;
+  }
+  const stripped = raw.replace(/\bgrade\b/g, "").replace(/(\d+)(st|nd|rd|th)\b/g, "$1").trim();
+  if (stripped === "pre-k" || stripped === "pk") {
+    return -1;
+  }
+  if (stripped === "k") {
+    return 0;
+  }
+  if (stripped === "middle school") {
+    return 7;
+  }
+  const normalized = stripped.replace(/\s+/g, "");
+  const withoutLeadingZeros = normalized.replace(/^0+/, "") || "0";
+  const parsed = Number(withoutLeadingZeros);
+  if (!Number.isInteger(parsed)) {
+    ctx.addIssue({
+      code: "custom",
+      message: "must be a valid Timeback grade"
+    });
+    return z.NEVER;
+  }
+  return parsed;
+});
+var TimebackGrade = z.union([z.number(), StringTimebackGrade]).pipe(NumericTimebackGrade).meta({
   id: "TimebackGrade",
   description: "Grade level (-1 = Pre-K, 0 = K, 1-12 = grades, 13 = AP)"
 });
@@ -697,7 +729,6 @@ var TimebackConfig = z6.object({
 // ../../types/src/zod/edubridge.ts
 import { z as z7 } from "zod/v4";
 var EdubridgeDateString = z7.union([IsoDateTimeString, IsoDateString]);
-var EdubridgeDateStringInput = EdubridgeDateString.transform((date) => date.includes("T") ? date : `${date}T00:00:00.000Z`);
 var EduBridgeEnrollment = z7.object({
   id: z7.string(),
   role: z7.string(),
@@ -716,7 +747,9 @@ var EduBridgeEnrollment = z7.object({
   school: z7.object({
     id: z7.string(),
     name: z7.string()
-  })
+  }),
+  testOutSupported: z7.boolean(),
+  testOutEligible: z7.boolean()
 });
 var SubjectMetrics = z7.object({
   activityMetrics: z7.object({
@@ -785,18 +818,18 @@ var EdubridgeUsersListParams = z7.object({
   orgSourcedIds: z7.array(NonEmptyString).optional()
 });
 var EdubridgeActivityParams = EmailOrStudentId.extend({
-  startDate: EdubridgeDateStringInput,
-  endDate: EdubridgeDateStringInput,
+  startDate: EdubridgeDateString,
+  endDate: EdubridgeDateString,
   timezone: z7.string().optional()
 });
 var EdubridgeWeeklyFactsParams = EmailOrStudentId.extend({
-  weekDate: EdubridgeDateStringInput,
+  weekDate: EdubridgeDateString,
   timezone: z7.string().optional()
 });
 var EdubridgeEnrollmentFactsParams = z7.object({
   enrollmentId: NonEmptyString,
-  startDate: EdubridgeDateStringInput.optional(),
-  endDate: EdubridgeDateStringInput.optional(),
+  startDate: EdubridgeDateString.optional(),
+  endDate: EdubridgeDateString.optional(),
   timezone: z7.string().optional()
 });
 // ../../types/src/zod/masterytrack.ts
@@ -885,7 +918,42 @@ var Ref = z9.object({
   type: z9.string().optional(),
   href: z9.string().optional()
 }).strict();
+var GuidRefType = z9.enum([
+  "academicSession",
+  "assessmentLineItem",
+  "category",
+  "class",
+  "course",
+  "demographics",
+  "enrollment",
+  "gradingPeriod",
+  "lineItem",
+  "org",
+  "resource",
+  "result",
+  "scoreScale",
+  "student",
+  "teacher",
+  "term",
+  "user",
+  "componentResource",
+  "courseComponent"
+]);
+var GuidRef = z9.object({
+  sourcedId: NonEmptyString,
+  type: GuidRefType,
+  href: z9.url()
+}).strict();
 var OneRosterDateString = z9.union([IsoDateString, IsoDateTimeString]).transform((date) => date.includes("T") ? date : `${date}T00:00:00Z`);
+var LearningObjectiveResult = z9.object({
+  learningObjectiveId: z9.string(),
+  score: z9.number().optional(),
+  textScore: z9.string().optional()
+});
+var LearningObjectiveScoreSetSchema = z9.array(z9.object({
+  source: z9.string(),
+  learningObjectiveResults: z9.array(LearningObjectiveResult)
+}));
 var OneRosterUserRoleInput = z9.object({
   roleType: z9.enum(["primary", "secondary"]),
   role: OneRosterUserRole,
@@ -898,35 +966,46 @@ var OneRosterUserRoleInput = z9.object({
 var OneRosterUserCreateInput = z9.object({
   sourcedId: NonEmptyString.describe("sourcedId must be a non-empty string"),
   status: Status.optional(),
-  enabledUser: z9.boolean(),
+  enabledUser: z9.union([
+    z9.boolean(),
+    z9.enum(["true", "false"]).transform((value) => value === "true")
+  ]),
   givenName: NonEmptyString.describe("givenName must be a non-empty string"),
   familyName: NonEmptyString.describe("familyName must be a non-empty string"),
-  middleName: NonEmptyString.optional(),
-  username: NonEmptyString.optional(),
+  middleName: NonEmptyString.nullable().optional(),
+  preferredFirstName: NonEmptyString.nullable().optional(),
+  preferredMiddleName: NonEmptyString.nullable().optional(),
+  preferredLastName: NonEmptyString.nullable().optional(),
+  username: NonEmptyString.nullable().optional(),
   email: z9.email(),
+  userMasterIdentifier: z9.string().nullable().optional(),
   roles: z9.array(OneRosterUserRoleInput).min(1, "roles must include at least one role"),
   userIds: z9.array(z9.object({
     type: NonEmptyString,
     identifier: NonEmptyString
   }).strict()).optional(),
   agents: z9.array(Ref).optional(),
+  primaryOrg: Ref.optional(),
   grades: z9.array(TimebackGrade).optional(),
-  identifier: NonEmptyString.optional(),
-  sms: NonEmptyString.optional(),
-  phone: NonEmptyString.optional(),
-  pronouns: NonEmptyString.optional(),
-  password: NonEmptyString.optional(),
+  sms: NonEmptyString.nullable().optional(),
+  phone: NonEmptyString.nullable().optional(),
+  pronouns: NonEmptyString.nullable().optional(),
+  password: NonEmptyString.nullable().optional(),
   metadata: Metadata
 }).strict();
 var OneRosterCourseCreateInput = z9.object({
   sourcedId: NonEmptyString.describe("sourcedId must be a non-empty string").optional(),
-  status: Status.optional(),
+  status: Status,
   title: NonEmptyString.describe("title must be a non-empty string"),
   org: Ref,
-  courseCode: NonEmptyString.optional(),
-  subjects: z9.array(TimebackSubject).optional(),
-  grades: z9.array(TimebackGrade).optional(),
-  level: NonEmptyString.optional(),
+  courseCode: NonEmptyString.nullable().optional(),
+  subjects: z9.array(TimebackSubject).nullable().optional(),
+  subjectCodes: z9.array(z9.string()).nullable().optional(),
+  grades: z9.array(TimebackGrade).nullable().optional(),
+  level: NonEmptyString.nullable().optional(),
+  academicSession: Ref.nullable().optional(),
+  schoolYear: GuidRef.nullable().optional(),
+  gradingScheme: NonEmptyString.nullable().optional(),
   metadata: Metadata
 }).strict();
 var OneRosterClassCreateInput = z9.object({
@@ -936,9 +1015,9 @@ var OneRosterClassCreateInput = z9.object({
   terms: z9.array(Ref).min(1, "terms must have at least one item"),
   course: Ref,
   org: Ref,
-  classCode: NonEmptyString.optional(),
+  classCode: NonEmptyString.nullable().optional(),
   classType: z9.enum(["homeroom", "scheduled"]).optional(),
-  location: NonEmptyString.optional(),
+  location: NonEmptyString.nullable().optional(),
   grades: z9.array(TimebackGrade).optional(),
   subjects: z9.array(TimebackSubject).optional(),
   subjectCodes: z9.array(NonEmptyString).optional(),
@@ -973,18 +1052,21 @@ var OneRosterLineItemCreateInput = z9.object({
   category: Ref,
   assignDate: OneRosterDateString,
   dueDate: OneRosterDateString,
-  status: Status,
-  description: z9.string().optional(),
+  status: Status.optional(),
+  description: z9.string().nullable().optional(),
   resultValueMin: z9.number().nullable().optional(),
   resultValueMax: z9.number().nullable().optional(),
-  scoreScale: Ref.optional(),
+  gradingPeriod: Ref.nullable().optional(),
+  academicSession: Ref.nullable().optional(),
+  scoreScale: Ref.nullable().optional(),
+  learningObjectiveSet: LearningObjectiveSetSchema.nullable().optional(),
   metadata: Metadata
 }).strict();
 var OneRosterResultCreateInput = z9.object({
   sourcedId: NonEmptyString.optional(),
   lineItem: Ref,
   student: Ref,
-  class: Ref.optional(),
+  class: Ref.nullable().optional(),
   scoreDate: OneRosterDateString,
   scoreStatus: z9.enum([
     "exempt",
@@ -996,14 +1078,20 @@ var OneRosterResultCreateInput = z9.object({
   score: z9.number().nullable().optional(),
   textScore: z9.string().nullable().optional(),
   status: Status,
+  scoreScale: Ref.nullable().optional(),
   comment: z9.string().nullable().optional(),
+  learningObjectiveSet: LearningObjectiveScoreSetSchema.nullable().optional(),
+  inProgress: z9.string().optional(),
+  incomplete: z9.string().optional(),
+  late: z9.string().optional(),
+  missing: z9.string().optional(),
   metadata: Metadata
 }).strict();
 var OneRosterScoreScaleCreateInput = z9.object({
   sourcedId: NonEmptyString.optional(),
   title: NonEmptyString.describe("title must be a non-empty string"),
-  status: Status.optional(),
-  type: z9.string(),
+  status: Status,
+  type: NonEmptyString,
   class: Ref,
   course: Ref.nullable().optional(),
   scoreScaleValue: z9.array(z9.object({
@@ -1012,13 +1100,11 @@ var OneRosterScoreScaleCreateInput = z9.object({
     value: z9.string().optional(),
     description: z9.string().optional()
   }).strict()),
-  minScore: z9.number().optional(),
-  maxScore: z9.number().optional(),
   metadata: Metadata
 }).strict();
 var OneRosterAssessmentLineItemCreateInput = z9.object({
   sourcedId: NonEmptyString.optional(),
-  status: Status.optional(),
+  status: Status,
   dateLastModified: IsoDateTimeString.optional(),
   title: NonEmptyString.describe("title must be a non-empty string"),
   description: z9.string().nullable().optional(),
@@ -1036,18 +1122,9 @@ var OneRosterAssessmentLineItemCreateInput = z9.object({
   course: Ref.nullable().optional(),
   metadata: Metadata
 }).strict();
-var LearningObjectiveResult = z9.object({
-  learningObjectiveId: z9.string(),
-  score: z9.number().optional(),
-  textScore: z9.string().optional()
-});
-var LearningObjectiveScoreSetSchema = z9.array(z9.object({
-  source: z9.string(),
-  learningObjectiveResults: z9.array(LearningObjectiveResult)
-}));
 var OneRosterAssessmentResultCreateInput = z9.object({
   sourcedId: NonEmptyString.optional(),
-  status: Status.optional(),
+  status: Status,
   dateLastModified: IsoDateTimeString.optional(),
   metadata: Metadata,
   assessmentLineItem: Ref,
@@ -1076,7 +1153,7 @@ var OneRosterOrgCreateInput = z9.object({
   status: Status.optional(),
   name: NonEmptyString.describe("name must be a non-empty string"),
   type: OrganizationType,
-  identifier: NonEmptyString.optional(),
+  identifier: z9.string().nullish(),
   parent: Ref.optional(),
   metadata: Metadata
 }).strict();
@@ -1084,8 +1161,8 @@ var OneRosterSchoolCreateInput = z9.object({
   sourcedId: NonEmptyString.optional(),
   status: Status.optional(),
   name: NonEmptyString.describe("name must be a non-empty string"),
-  type: z9.literal("school").optional(),
-  identifier: NonEmptyString.optional(),
+  type: z9.literal("school").default("school"),
+  identifier: z9.string().nullish(),
   parent: Ref.optional(),
   metadata: Metadata
 }).strict();
@@ -1103,11 +1180,13 @@ var OneRosterAcademicSessionCreateInput = z9.object({
   metadata: Metadata
 }).strict();
 var OneRosterComponentResourceCreateInput = z9.object({
-  sourcedId: NonEmptyString.optional(),
+  sourcedId: NonEmptyString,
   title: NonEmptyString.describe("title must be a non-empty string"),
   courseComponent: Ref,
   resource: Ref,
   status: Status,
+  sortOrder: z9.number().optional(),
+  lessonType: LessonType.optional(),
   metadata: Metadata
 }).strict();
 var OneRosterCourseComponentCreateInput = z9.object({
@@ -1115,8 +1194,17 @@ var OneRosterCourseComponentCreateInput = z9.object({
   title: NonEmptyString.describe("title must be a non-empty string"),
   course: Ref,
   status: Status,
+  sortOrder: z9.number().optional(),
+  parent: Ref.nullable().optional(),
+  courseComponent: Ref.nullable().optional(),
+  prerequisites: z9.array(z9.string()).nullable().optional(),
+  prerequisiteCriteria: z9.string().nullable().optional(),
+  unlockDate: OneRosterDateString.nullable().optional(),
   metadata: Metadata
-}).strict();
+}).strict().transform(({ courseComponent, parent, ...rest }) => ({
+  ...rest,
+  parent: parent === undefined ? courseComponent ?? undefined : parent
+}));
 var OneRosterEnrollInput = z9.object({
   sourcedId: NonEmptyString.describe("sourcedId must be a non-empty string"),
   role: z9.enum(["student", "teacher"]),
@@ -1136,8 +1224,23 @@ var OneRosterCredentialInput = z9.object({
   })
 }).strict();
 var OneRosterDemographicsCreateInput = z9.object({
-  sourcedId: NonEmptyString.describe("sourcedId must be a non-empty string")
-}).loose();
+  sourcedId: NonEmptyString.describe("sourcedId must be a non-empty string"),
+  status: Status.optional(),
+  metadata: Metadata,
+  birthDate: z9.string().regex(/^\d{4}-\d{2}-\d{2}$/).nullable().optional(),
+  sex: z9.enum(["male", "female"]).nullable().optional(),
+  americanIndianOrAlaskaNative: StringBoolean.nullable().optional(),
+  asian: StringBoolean.nullable().optional(),
+  blackOrAfricanAmerican: StringBoolean.nullable().optional(),
+  nativeHawaiianOrOtherPacificIslander: StringBoolean.nullable().optional(),
+  white: StringBoolean.nullable().optional(),
+  demographicRaceTwoOrMoreRaces: StringBoolean.nullable().optional(),
+  hispanicOrLatinoEthnicity: StringBoolean.nullable().optional(),
+  countryOfBirthCode: z9.string().nullable().optional(),
+  stateOfBirthAbbreviation: z9.string().nullable().optional(),
+  cityOfBirth: z9.string().nullable().optional(),
+  publicSchoolResidenceStatus: z9.string().nullable().optional()
+}).strict();
 var CommonResourceMetadataSchema = z9.object({
   type: ResourceType,
   subject: TimebackSubject.nullish(),
@@ -1207,16 +1310,63 @@ var ResourceMetadataSchema = z9.discriminatedUnion("type", [
   CourseMaterialMetadataSchema,
   AssessmentBankMetadataSchema
 ]);
+var ReservedResourceMetadataKeys = new Set([
+  "type",
+  "subject",
+  "grades",
+  "language",
+  "xp",
+  "url",
+  "keywords",
+  "learningObjectiveSet",
+  "lessonType",
+  "subType",
+  "questionType",
+  "difficulty",
+  "format",
+  "author",
+  "pageCount",
+  "duration",
+  "speaker",
+  "captionsAvailable",
+  "launchUrl",
+  "toolProvider",
+  "instructionalMethod",
+  "courseIdOnFail",
+  "resolution",
+  "resources"
+]);
+var UntypedResourceMetadataSchema = z9.record(z9.string(), z9.unknown()).superRefine((metadata, ctx) => {
+  if ("fail_fast" in metadata) {
+    const result = FastFailConfigSchema.safeParse(metadata.fail_fast);
+    if (!result.success) {
+      for (const issue of result.error.issues) {
+        ctx.addIssue({
+          ...issue,
+          path: ["fail_fast", ...issue.path]
+        });
+      }
+    }
+  }
+  const reservedKeys = Object.keys(metadata).filter((key) => ReservedResourceMetadataKeys.has(key));
+  if (reservedKeys.length === 0) {
+    return;
+  }
+  ctx.addIssue({
+    code: "custom",
+    message: `metadata keys ${reservedKeys.map((key) => `\`${key}\``).join(", ")} require a valid \`type\` discriminator`
+  });
+});
 var OneRosterResourceCreateInput = z9.object({
   sourcedId: NonEmptyString.optional(),
   title: NonEmptyString.describe("title must be a non-empty string"),
   vendorResourceId: NonEmptyString.describe("vendorResourceId must be a non-empty string"),
   roles: z9.array(z9.enum(["primary", "secondary"])).optional(),
   importance: z9.enum(["primary", "secondary"]).optional(),
-  vendorId: z9.string().optional(),
-  applicationId: z9.string().optional(),
+  vendorId: NonEmptyString.nullable().optional(),
+  applicationId: NonEmptyString.nullable().optional(),
   status: Status.optional(),
-  metadata: ResourceMetadataSchema.nullable().optional()
+  metadata: z9.union([ResourceMetadataSchema, UntypedResourceMetadataSchema]).nullable().optional()
 }).strict();
 var CourseStructureItem = z9.object({
   url: NonEmptyString.describe("courseStructure.url must be a non-empty string"),
@@ -1511,6 +1661,18 @@ var PowerPathPlacementQueryParams = z10.object({
   student: NonEmptyString,
   subject: TimebackSubject
 });
+var PowerPathMakeExternalStudentTestOutAssignmentInput = z10.object({
+  oneRosterSourcedId: NonEmptyString,
+  subject: NonEmptyString
+});
+var PowerPathRenderConfigUpsertInput = z10.object({
+  courseIds: z10.array(NonEmptyString).min(1),
+  rendererId: NonEmptyString,
+  rendererUrl: z10.url(),
+  rendererVersion: NonEmptyString.optional(),
+  suppressFeedback: z10.boolean().optional(),
+  suppressCorrectResponse: z10.boolean().optional()
+});
 var PowerPathSyllabusQueryParams = z10.object({
   status: z10.enum(["active", "tobedeleted"]).optional()
 });
@@ -1775,6 +1937,23 @@ var QtiLessonFeedbackInput = z11.object({
   lessonId: NonEmptyString,
   humanApproved: z11.boolean().optional()
 }).strict();
+// ../../types/src/zod/reporting.ts
+import { z as z12 } from "zod/v4";
+var ReportingAuthMode = z12.enum(["creator_only", "same_org", "all_orgs"]);
+var ReportingSavedQueryId = z12.string().uuid();
+var ReportingUserEmail = z12.email();
+var ReportingQueryInput = z12.object({
+  sql: NonEmptyString
+});
+var PersistReportingQueryInput = z12.object({
+  endpointName: NonEmptyString,
+  sql: NonEmptyString,
+  authMode: ReportingAuthMode,
+  description: NonEmptyString.optional()
+});
+var RemoveReportingQueryInput = z12.object({
+  endpointId: ReportingSavedQueryId
+});
 // src/resources/webhooks.ts
 class WebhooksResource {
   transport;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@timeback/webhooks",
-	"version": "0.2.1-beta.20260313023436",
+	"version": "0.2.1-beta.20260331191116",
 	"description": "Webhook management client SDK for Timeback",
 	"type": "module",
 	"exports": {

package/dist/errors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACN,QAAQ,IAAI,aAAa,EACzB,cAAc,EACd,oBAAoB,EACpB,aAAa,EACb,iBAAiB,EACjB,eAAe,GACf,MAAM,iCAAiC,CAAA"}

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAMH,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AACzC,OAAO,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAA;AAEhD,YAAY,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAA;AACtD,YAAY,EAAE,oBAAoB,EAAE,WAAW,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC9F,YAAY,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAA;AAMtE,YAAY,EACX,kBAAkB,EAClB,kBAAkB,EAClB,wBAAwB,EACxB,wBAAwB,GACxB,MAAM,qBAAqB,CAAA;AAE5B,YAAY,EACX,OAAO,EACP,aAAa,EACb,UAAU,EACV,eAAe,GACf,MAAM,oCAAoC,CAAA;AAM3C,OAAO,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA"}

package/dist/public-types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"public-types.d.ts","sourceRoot":"","sources":["../src/public-types.ts"],"names":[],"mappings":"AAAA,cAAc,oCAAoC,CAAA;AAElD,YAAY,EACX,kBAAkB,EAClB,kBAAkB,EAClB,wBAAwB,EACxB,wBAAwB,GACxB,MAAM,qBAAqB,CAAA"}