@eduware/oneroster 1.0.1 → 1.2.0

package/src/mcp-server/tools/categoriesManagementUpdateCategory.ts

@@ -0,0 +1,31 @@
+import { categoriesManagementUpdateCategory } from '../../funcs/categoriesManagementUpdateCategory.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.UpdateCategoryRequest$inboundSchema,
+};
+
+export const tool$categoriesManagementUpdateCategory: ToolDefinition<typeof args> = {
+    name: 'categories-update-category',
+    description: `Update a Category
+
+To update an existing Category. The sourcedId for the record to be updated is supplied by the requesting system.`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await categoriesManagementUpdateCategory(client, args.request, {
+            fetchOptions: { signal: ctx.signal },
+        }).$inspect();
+
+        if (!result.ok) {
+            return {
+                content: [{ type: 'text', text: result.error.message }],
+                isError: true,
+            };
+        }
+
+        const value = result.value;
+
+        return formatResult(value, apiCall);
+    },
+};

package/src/mcp-server/tools/classesManagementAddStudentToClass.ts

@@ -0,0 +1,31 @@
+import { classesManagementAddStudentToClass } from '../../funcs/classesManagementAddStudentToClass.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.AddStudentToClassRequest$inboundSchema,
+};
+
+export const tool$classesManagementAddStudentToClass: ToolDefinition<typeof args> = {
+    name: 'classes-add-student-to-class',
+    description: `Add a student to a Class
+
+Enrolls a student in a specific Class. The responding system must return the set of sourcedIds that have been allocated to the newly created enrollment record.`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await classesManagementAddStudentToClass(client, args.request, {
+            fetchOptions: { signal: ctx.signal },
+        }).$inspect();
+
+        if (!result.ok) {
+            return {
+                content: [{ type: 'text', text: result.error.message }],
+                isError: true,
+            };
+        }
+
+        const value = result.value;
+
+        return formatResult(value, apiCall);
+    },
+};

package/src/mcp-server/tools/classesManagementAddTeacherToClass.ts

@@ -0,0 +1,31 @@
+import { classesManagementAddTeacherToClass } from '../../funcs/classesManagementAddTeacherToClass.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.AddTeacherToClassRequest$inboundSchema,
+};
+
+export const tool$classesManagementAddTeacherToClass: ToolDefinition<typeof args> = {
+    name: 'classes-add-teacher-to-class',
+    description: `Add a teacher to a Class
+
+Enrolls a teacher to a specific Class. The responding system must return the set of sourcedIds that have been allocated to the newly created enrollment record.`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await classesManagementAddTeacherToClass(client, args.request, {
+            fetchOptions: { signal: ctx.signal },
+        }).$inspect();
+
+        if (!result.ok) {
+            return {
+                content: [{ type: 'text', text: result.error.message }],
+                isError: true,
+            };
+        }
+
+        const value = result.value;
+
+        return formatResult(value, apiCall);
+    },
+};

package/src/mcp-server/tools/classesManagementCreateClass.ts

@@ -0,0 +1,31 @@
+import { classesManagementCreateClass } from '../../funcs/classesManagementCreateClass.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.CreateClassRequest$inboundSchema.optional(),
+};
+
+export const tool$classesManagementCreateClass: ToolDefinition<typeof args> = {
+    name: 'classes-create-class',
+    description: `Create a new Class
+
+To create a new Class. The responding system must return the set of sourcedIds that have been allocated to the newly created class record.`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await classesManagementCreateClass(client, args.request, {
+            fetchOptions: { signal: ctx.signal },
+        }).$inspect();
+
+        if (!result.ok) {
+            return {
+                content: [{ type: 'text', text: result.error.message }],
+                isError: true,
+            };
+        }
+
+        const value = result.value;
+
+        return formatResult(value, apiCall);
+    },
+};

package/src/mcp-server/tools/classesManagementDeleteClass.ts

@@ -0,0 +1,31 @@
+import { classesManagementDeleteClass } from '../../funcs/classesManagementDeleteClass.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.DeleteClassRequest$inboundSchema,
+};
+
+export const tool$classesManagementDeleteClass: ToolDefinition<typeof args> = {
+    name: 'classes-delete-class',
+    description: `Delete a Class
+
+Perform a soft delete on a specific Class on the service provider. This operation changes the status of the Class to 'tobedeleted'.`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await classesManagementDeleteClass(client, args.request, {
+            fetchOptions: { signal: ctx.signal },
+        }).$inspect();
+
+        if (!result.ok) {
+            return {
+                content: [{ type: 'text', text: result.error.message }],
+                isError: true,
+            };
+        }
+
+        const value = result.value;
+
+        return formatResult(value, apiCall);
+    },
+};

package/src/mcp-server/tools/classesManagementGetAllClasses.ts

@@ -0,0 +1,31 @@
+import { classesManagementGetAllClasses } from '../../funcs/classesManagementGetAllClasses.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.GetAllClassesRequest$inboundSchema,
+};
+
+export const tool$classesManagementGetAllClasses: ToolDefinition<typeof args> = {
+    name: 'classes-get-all-classes',
+    description: `Get all Classes
+
+To get all Classes on the service provider.`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await classesManagementGetAllClasses(client, args.request, {
+            fetchOptions: { signal: ctx.signal },
+        }).$inspect();
+
+        if (!result.ok) {
+            return {
+                content: [{ type: 'text', text: result.error.message }],
+                isError: true,
+            };
+        }
+
+        const value = result.value.result;
+
+        return formatResult(value, apiCall);
+    },
+};

package/src/mcp-server/tools/classesManagementGetCategoriesForClass.ts

@@ -0,0 +1,33 @@
+import { classesManagementGetCategoriesForClass } from '../../funcs/classesManagementGetCategoriesForClass.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.GetCategoriesForClassRequest$inboundSchema,
+};
+
+export const tool$classesManagementGetCategoriesForClass: ToolDefinition<typeof args> = {
+    name: 'classes-get-categories-class',
+    description: `Get Categories for a Class
+
+Get the set of categories on the service provider for a specific class. If the corresponding record cannot be located, the api will return a 404 error code and message 'Class not found.'`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await classesManagementGetCategoriesForClass(
+            client,
+            args.request,
+            { fetchOptions: { signal: ctx.signal } }
+        ).$inspect();
+
+        if (!result.ok) {
+            return {
+                content: [{ type: 'text', text: result.error.message }],
+                isError: true,
+            };
+        }
+
+        const value = result.value.result;
+
+        return formatResult(value, apiCall);
+    },
+};

package/src/mcp-server/tools/classesManagementGetClass.ts

@@ -0,0 +1,31 @@
+import { classesManagementGetClass } from '../../funcs/classesManagementGetClass.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.GetClassRequest$inboundSchema,
+};
+
+export const tool$classesManagementGetClass: ToolDefinition<typeof args> = {
+    name: 'classes-get-class',
+    description: `Get a specific class
+
+Get a specific Class on the service provider. If the corresponding record cannot be located, the api will return a 404 error code and message 'Class not found.'`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await classesManagementGetClass(client, args.request, {
+            fetchOptions: { signal: ctx.signal },
+        }).$inspect();
+
+        if (!result.ok) {
+            return {
+                content: [{ type: 'text', text: result.error.message }],
+                isError: true,
+            };
+        }
+
+        const value = result.value;
+
+        return formatResult(value, apiCall);
+    },
+};

package/src/mcp-server/tools/classesManagementGetClassesForStudent.ts

@@ -0,0 +1,33 @@
+import { classesManagementGetClassesForStudent } from '../../funcs/classesManagementGetClassesForStudent.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.GetClassesForStudentRequest$inboundSchema,
+};
+
+export const tool$classesManagementGetClassesForStudent: ToolDefinition<typeof args> = {
+    name: 'classes-get-classes-student',
+    description: `Get Classes for a Student
+
+To get the set of Classes related to a specific Student. If the specified student cannot be identified within the service provider, the api will return a 404 error code and message 'Student not found.'`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await classesManagementGetClassesForStudent(
+            client,
+            args.request,
+            { fetchOptions: { signal: ctx.signal } }
+        ).$inspect();
+
+        if (!result.ok) {
+            return {
+                content: [{ type: 'text', text: result.error.message }],
+                isError: true,
+            };
+        }
+
+        const value = result.value.result;
+
+        return formatResult(value, apiCall);
+    },
+};

package/src/mcp-server/tools/classesManagementGetClassesForTeacher.ts

@@ -0,0 +1,33 @@
+import { classesManagementGetClassesForTeacher } from '../../funcs/classesManagementGetClassesForTeacher.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.GetClassesForTeacherRequest$inboundSchema,
+};
+
+export const tool$classesManagementGetClassesForTeacher: ToolDefinition<typeof args> = {
+    name: 'classes-get-classes-teacher',
+    description: `Get Classes for a Teacher
+
+To get the set of Classes a Teacher is enrolled in. If the specified teacher cannot be identified within the service provider, the api will return a 404 error code and message 'Teacher not found.'`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await classesManagementGetClassesForTeacher(
+            client,
+            args.request,
+            { fetchOptions: { signal: ctx.signal } }
+        ).$inspect();
+
+        if (!result.ok) {
+            return {
+                content: [{ type: 'text', text: result.error.message }],
+                isError: true,
+            };
+        }
+
+        const value = result.value.result;
+
+        return formatResult(value, apiCall);
+    },
+};

package/src/mcp-server/tools/classesManagementGetClassesForTerm.ts

@@ -0,0 +1,31 @@
+import { classesManagementGetClassesForTerm } from '../../funcs/classesManagementGetClassesForTerm.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.GetClassesForTermRequest$inboundSchema,
+};
+
+export const tool$classesManagementGetClassesForTerm: ToolDefinition<typeof args> = {
+    name: 'classes-get-classes-term',
+    description: `Get Classes for a Term
+
+To get the set of Classes related to a specific Term. If the specified term cannot be identified within the service provider, the api will return a 404 error code and message 'Term not found.'`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await classesManagementGetClassesForTerm(client, args.request, {
+            fetchOptions: { signal: ctx.signal },
+        }).$inspect();
+
+        if (!result.ok) {
+            return {
+                content: [{ type: 'text', text: result.error.message }],
+                isError: true,
+            };
+        }
+
+        const value = result.value.result;
+
+        return formatResult(value, apiCall);
+    },
+};

package/src/mcp-server/tools/classesManagementGetClassesForUser.ts

@@ -0,0 +1,31 @@
+import { classesManagementGetClassesForUser } from '../../funcs/classesManagementGetClassesForUser.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.GetClassesForUserRequest$inboundSchema,
+};
+
+export const tool$classesManagementGetClassesForUser: ToolDefinition<typeof args> = {
+    name: 'classes-get-classes-user',
+    description: `Get Classes for a User
+
+To get the set of Classes a User is enrolled in.`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await classesManagementGetClassesForUser(client, args.request, {
+            fetchOptions: { signal: ctx.signal },
+        }).$inspect();
+
+        if (!result.ok) {
+            return {
+                content: [{ type: 'text', text: result.error.message }],
+                isError: true,
+            };
+        }
+
+        const value = result.value.result;
+
+        return formatResult(value, apiCall);
+    },
+};

package/src/mcp-server/tools/classesManagementGetLineItemsForClass.ts

@@ -0,0 +1,33 @@
+import { classesManagementGetLineItemsForClass } from '../../funcs/classesManagementGetLineItemsForClass.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.GetLineItemsForClassRequest$inboundSchema,
+};
+
+export const tool$classesManagementGetLineItemsForClass: ToolDefinition<typeof args> = {
+    name: 'classes-get-lineitems-class',
+    description: `Get Line Items for a Class
+
+Get the set of lineItems on the service provider for a specific class. If the corresponding record cannot be located, the api will return a 404 error code and message 'Class not found.'`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await classesManagementGetLineItemsForClass(
+            client,
+            args.request,
+            { fetchOptions: { signal: ctx.signal } }
+        ).$inspect();
+
+        if (!result.ok) {
+            return {
+                content: [{ type: 'text', text: result.error.message }],
+                isError: true,
+            };
+        }
+
+        const value = result.value.result;
+
+        return formatResult(value, apiCall);
+    },
+};

package/src/mcp-server/tools/classesManagementGetResultsForClass.ts

@@ -0,0 +1,31 @@
+import { classesManagementGetResultsForClass } from '../../funcs/classesManagementGetResultsForClass.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.GetResultsForClassRequest$inboundSchema,
+};
+
+export const tool$classesManagementGetResultsForClass: ToolDefinition<typeof args> = {
+    name: 'classes-get-results-class',
+    description: `Get Results for a Class
+
+Get the set of results on the service provider for a specific class. If the corresponding record cannot be located, the api will return a 404 error code and message 'Class not found.'`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await classesManagementGetResultsForClass(client, args.request, {
+            fetchOptions: { signal: ctx.signal },
+        }).$inspect();
+
+        if (!result.ok) {
+            return {
+                content: [{ type: 'text', text: result.error.message }],
+                isError: true,
+            };
+        }
+
+        const value = result.value.result;
+
+        return formatResult(value, apiCall);
+    },
+};

package/src/mcp-server/tools/classesManagementGetResultsForLineItemForClass.ts

@@ -0,0 +1,33 @@
+import { classesManagementGetResultsForLineItemForClass } from '../../funcs/classesManagementGetResultsForLineItemForClass.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.GetResultsForLineItemForClassRequest$inboundSchema,
+};
+
+export const tool$classesManagementGetResultsForLineItemForClass: ToolDefinition<typeof args> = {
+    name: 'classes-get-results-lineitem-class',
+    description: `Get Results for a Line Item for a Class
+
+Get the set of results on the service provider for a specific lineItem and for a specific class. If the corresponding record cannot be located, the api will return a 404 error code and message 'Class or line item not found.'`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await classesManagementGetResultsForLineItemForClass(
+            client,
+            args.request,
+            { fetchOptions: { signal: ctx.signal } }
+        ).$inspect();
+
+        if (!result.ok) {
+            return {
+                content: [{ type: 'text', text: result.error.message }],
+                isError: true,
+            };
+        }
+
+        const value = result.value.result;
+
+        return formatResult(value, apiCall);
+    },
+};

package/src/mcp-server/tools/classesManagementGetResultsForStudentForClass.ts

@@ -0,0 +1,33 @@
+import { classesManagementGetResultsForStudentForClass } from '../../funcs/classesManagementGetResultsForStudentForClass.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.GetResultsForStudentForClassRequest$inboundSchema,
+};
+
+export const tool$classesManagementGetResultsForStudentForClass: ToolDefinition<typeof args> = {
+    name: 'classes-get-results-student-class',
+    description: `Get Results for a Student for a Class
+
+Get the set of results on the service provider for a specific student and for a specific class. If the corresponding record cannot be located, the api will return a 404 error code and message 'Class or student not found.'`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await classesManagementGetResultsForStudentForClass(
+            client,
+            args.request,
+            { fetchOptions: { signal: ctx.signal } }
+        ).$inspect();
+
+        if (!result.ok) {
+            return {
+                content: [{ type: 'text', text: result.error.message }],
+                isError: true,
+            };
+        }
+
+        const value = result.value.result;
+
+        return formatResult(value, apiCall);
+    },
+};

package/src/mcp-server/tools/classesManagementGetScoreScalesForClass.ts

@@ -0,0 +1,33 @@
+import { classesManagementGetScoreScalesForClass } from '../../funcs/classesManagementGetScoreScalesForClass.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.GetScoreScalesForClassRequest$inboundSchema,
+};
+
+export const tool$classesManagementGetScoreScalesForClass: ToolDefinition<typeof args> = {
+    name: 'classes-get-scales-class',
+    description: `Get Score Scales for a Class
+
+Get the set of scoreScales on the service provider for a specific class. If the corresponding record cannot be located, the api will return a 404 error code and message 'Class not found.'`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await classesManagementGetScoreScalesForClass(
+            client,
+            args.request,
+            { fetchOptions: { signal: ctx.signal } }
+        ).$inspect();
+
+        if (!result.ok) {
+            return {
+                content: [{ type: 'text', text: result.error.message }],
+                isError: true,
+            };
+        }
+
+        const value = result.value.result;
+
+        return formatResult(value, apiCall);
+    },
+};

package/src/mcp-server/tools/classesManagementGetStudentsForClass.ts

@@ -0,0 +1,31 @@
+import { classesManagementGetStudentsForClass } from '../../funcs/classesManagementGetStudentsForClass.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.GetStudentsForClassRequest$inboundSchema,
+};
+
+export const tool$classesManagementGetStudentsForClass: ToolDefinition<typeof args> = {
+    name: 'classes-get-students-class',
+    description: `Get students for a Class
+
+To get all students enrolled in a specific Class. If the corresponding record cannot be located, the api will return a 404 error code and message 'Class not found.'`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await classesManagementGetStudentsForClass(client, args.request, {
+            fetchOptions: { signal: ctx.signal },
+        }).$inspect();
+
+        if (!result.ok) {
+            return {
+                content: [{ type: 'text', text: result.error.message }],
+                isError: true,
+            };
+        }
+
+        const value = result.value.result;
+
+        return formatResult(value, apiCall);
+    },
+};

package/src/mcp-server/tools/classesManagementGetTeachersForClass.ts

@@ -0,0 +1,31 @@
+import { classesManagementGetTeachersForClass } from '../../funcs/classesManagementGetTeachersForClass.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.GetTeachersForClassRequest$inboundSchema,
+};
+
+export const tool$classesManagementGetTeachersForClass: ToolDefinition<typeof args> = {
+    name: 'classes-get-teachers-class',
+    description: `Get teachers for a Class
+
+To get all teachers assigned to a specific Class. If the corresponding record cannot be located, the api will return a 404 error code and message 'Class not found.'`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await classesManagementGetTeachersForClass(client, args.request, {
+            fetchOptions: { signal: ctx.signal },
+        }).$inspect();
+
+        if (!result.ok) {
+            return {
+                content: [{ type: 'text', text: result.error.message }],
+                isError: true,
+            };
+        }
+
+        const value = result.value.result;
+
+        return formatResult(value, apiCall);
+    },
+};

package/src/mcp-server/tools/classesManagementPostResultsForAcademicSessionForClass.ts

@@ -0,0 +1,35 @@
+import { classesManagementPostResultsForAcademicSessionForClass } from '../../funcs/classesManagementPostResultsForAcademicSessionForClass.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.PostResultsForAcademicSessionForClassRequest$inboundSchema,
+};
+
+export const tool$classesManagementPostResultsForAcademicSessionForClass: ToolDefinition<
+    typeof args
+> = {
+    name: 'classes-post-results-for-session-class',
+    description: `Create Results for an Academic Session for a Class
+
+To create a set of results for a specific academic session and specific class. The responding system must return the set of sourcedIds that have been allocated to the newly created result records. If the corresponding record cannot be located, the api will return a 404 error code and message 'Class or academic session not found.'`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await classesManagementPostResultsForAcademicSessionForClass(
+            client,
+            args.request,
+            { fetchOptions: { signal: ctx.signal } }
+        ).$inspect();
+
+        if (!result.ok) {
+            return {
+                content: [{ type: 'text', text: result.error.message }],
+                isError: true,
+            };
+        }
+
+        const value = result.value;
+
+        return formatResult(value, apiCall);
+    },
+};