@eduware/oneroster 1.1.0 → 1.2.1

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

@@ -0,0 +1,33 @@
+import { resourcesManagementGetResourcesForClass } from '../../funcs/resourcesManagementGetResourcesForClass.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.GetResourcesForClassRequest$inboundSchema,
+};
+
+export const tool$resourcesManagementGetResourcesForClass: ToolDefinition<typeof args> = {
+    name: 'resources-get-resources-class',
+    description: `Get resources for a class
+
+To get the collection of resources available 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 resourcesManagementGetResourcesForClass(
+            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/resourcesManagementGetResourcesForCourse.ts

@@ -0,0 +1,33 @@
+import { resourcesManagementGetResourcesForCourse } from '../../funcs/resourcesManagementGetResourcesForCourse.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.GetResourcesForCourseRequest$inboundSchema,
+};
+
+export const tool$resourcesManagementGetResourcesForCourse: ToolDefinition<typeof args> = {
+    name: 'resources-get-resources-course',
+    description: `Get resources for a course
+
+To get the collection of resources assigned to a specific course. If the corresponding record cannot be located, the api will return a 404 error code and message 'Course not found.'`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await resourcesManagementGetResourcesForCourse(
+            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/resourcesManagementGetResourcesForUser.ts

@@ -0,0 +1,33 @@
+import { resourcesManagementGetResourcesForUser } from '../../funcs/resourcesManagementGetResourcesForUser.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.GetResourcesForUserRequest$inboundSchema,
+};
+
+export const tool$resourcesManagementGetResourcesForUser: ToolDefinition<typeof args> = {
+    name: 'resources-get-resources-user',
+    description: `Get resources for a user
+
+To get the collection of resources available to a specific user. If the corresponding record cannot be located, the api will return a 404 error code and message 'User not found.'`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await resourcesManagementGetResourcesForUser(
+            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/resourcesManagementUpdateResource.ts

@@ -0,0 +1,31 @@
+import { resourcesManagementUpdateResource } from '../../funcs/resourcesManagementUpdateResource.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.UpdateResourceRequest$inboundSchema,
+};
+
+export const tool$resourcesManagementUpdateResource: ToolDefinition<typeof args> = {
+    name: 'resources-update-resource',
+    description: `Update an existing Resource
+
+To update an existing resource. The sourcedId for the record to be updated is supplied by the requesting system.`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await resourcesManagementUpdateResource(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/resultsManagementCreateResult.ts

@@ -0,0 +1,31 @@
+import { resultsManagementCreateResult } from '../../funcs/resultsManagementCreateResult.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.CreateResultRequest$inboundSchema,
+};
+
+export const tool$resultsManagementCreateResult: ToolDefinition<typeof args> = {
+    name: 'results-create-result',
+    description: `Create a Result
+
+To create a new result. The request body must include a \`result\` object with the following required fields: \`lineItem\` (with sourcedId), \`student\` (with sourcedId), \`scoreStatus\`, and \`scoreDate\`. The responding system must return the set of sourcedIds that have been allocated to the newly created result records.`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await resultsManagementCreateResult(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/resultsManagementDeleteResult.ts

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

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

@@ -0,0 +1,31 @@
+import { resultsManagementGetAllResults } from '../../funcs/resultsManagementGetAllResults.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.GetAllResultsRequest$inboundSchema,
+};
+
+export const tool$resultsManagementGetAllResults: ToolDefinition<typeof args> = {
+    name: 'results-get-all-results',
+    description: `Get all Results
+
+Get all of the results on the service provider.`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await resultsManagementGetAllResults(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/resultsManagementGetResult.ts

@@ -0,0 +1,31 @@
+import { resultsManagementGetResult } from '../../funcs/resultsManagementGetResult.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.GetResultRequest$inboundSchema,
+};
+
+export const tool$resultsManagementGetResult: ToolDefinition<typeof args> = {
+    name: 'results-get-result',
+    description: `Get a Result
+
+Get a specific result on the service provider. If the corresponding record cannot be located, the api will return a 404 error code and message 'Result not found.'`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await resultsManagementGetResult(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/resultsManagementUpdateResult.ts

@@ -0,0 +1,31 @@
+import { resultsManagementUpdateResult } from '../../funcs/resultsManagementUpdateResult.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.UpdateResultRequest$inboundSchema,
+};
+
+export const tool$resultsManagementUpdateResult: ToolDefinition<typeof args> = {
+    name: 'results-update-result',
+    description: `Update a Result
+
+To update an existing result. The sourcedId for the record to be updated is supplied by the requesting system.`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await resultsManagementUpdateResult(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/schoolsManagementCreateLineItemsForSchool.ts

@@ -0,0 +1,33 @@
+import { schoolsManagementCreateLineItemsForSchool } from '../../funcs/schoolsManagementCreateLineItemsForSchool.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.CreateLineItemsForSchoolRequest$inboundSchema,
+};
+
+export const tool$schoolsManagementCreateLineItemsForSchool: ToolDefinition<typeof args> = {
+    name: 'schools-create-lineitems-school',
+    description: `Create Line Items for a School
+
+To create a set of lineItems for a specific school. The responding system must return the set of sourcedIds that have been allocated to the newly created lineItem records. If the corresponding record cannot be located, the api will return a 404 error code and message 'School not found.'`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await schoolsManagementCreateLineItemsForSchool(
+            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/schoolsManagementCreateSchool.ts

@@ -0,0 +1,31 @@
+import { schoolsManagementCreateSchool } from '../../funcs/schoolsManagementCreateSchool.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.CreateSchoolRequest$inboundSchema.optional(),
+};
+
+export const tool$schoolsManagementCreateSchool: ToolDefinition<typeof args> = {
+    name: 'schools-create-school',
+    description: `Create a new School
+
+To create a new School. The responding system must return the set of sourcedIds that have been allocated to the newly created school record.`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await schoolsManagementCreateSchool(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/schoolsManagementDeleteSchool.ts

@@ -0,0 +1,31 @@
+import { schoolsManagementDeleteSchool } from '../../funcs/schoolsManagementDeleteSchool.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.DeleteSchoolRequest$inboundSchema,
+};
+
+export const tool$schoolsManagementDeleteSchool: ToolDefinition<typeof args> = {
+    name: 'schools-delete-school',
+    description: `Delete a School
+
+Perform a soft delete on a specific School on the service provider. The operation changes the status of the School to 'tobedeleted'.`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await schoolsManagementDeleteSchool(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/schoolsManagementGetAllSchools.ts

@@ -0,0 +1,31 @@
+import { schoolsManagementGetAllSchools } from '../../funcs/schoolsManagementGetAllSchools.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.GetAllSchoolsRequest$inboundSchema,
+};
+
+export const tool$schoolsManagementGetAllSchools: ToolDefinition<typeof args> = {
+    name: 'schools-get-all-schools',
+    description: `Get all Schools
+
+To get all Schools on the service provider.`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await schoolsManagementGetAllSchools(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/schoolsManagementGetClassesForSchool.ts

@@ -0,0 +1,31 @@
+import { schoolsManagementGetClassesForSchool } from '../../funcs/schoolsManagementGetClassesForSchool.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.GetClassesForSchoolRequest$inboundSchema,
+};
+
+export const tool$schoolsManagementGetClassesForSchool: ToolDefinition<typeof args> = {
+    name: 'schools-get-classes-school',
+    description: `Get all Classes for a School
+
+To get all Classes for a School on the service provider. If the specified school cannot be identified within the service provider, the api will return a 404 error code and message 'School not found.'`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await schoolsManagementGetClassesForSchool(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/schoolsManagementGetCoursesForSchool.ts

@@ -0,0 +1,31 @@
+import { schoolsManagementGetCoursesForSchool } from '../../funcs/schoolsManagementGetCoursesForSchool.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.GetCoursesForSchoolRequest$inboundSchema,
+};
+
+export const tool$schoolsManagementGetCoursesForSchool: ToolDefinition<typeof args> = {
+    name: 'schools-get-courses-school',
+    description: `Get all Courses for a School
+
+To get all Courses for a School on the service provider. If the specified school cannot be identified within the service provider, the api will return a 404 error code and message 'School not found.'`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await schoolsManagementGetCoursesForSchool(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/schoolsManagementGetEnrollmentsForClassInSchool.ts

@@ -0,0 +1,33 @@
+import { schoolsManagementGetEnrollmentsForClassInSchool } from '../../funcs/schoolsManagementGetEnrollmentsForClassInSchool.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.GetEnrollmentsForClassInSchoolRequest$inboundSchema,
+};
+
+export const tool$schoolsManagementGetEnrollmentsForClassInSchool: ToolDefinition<typeof args> = {
+    name: 'schools-get-enrolls-class-school',
+    description: `Get Enrollments for a specific Class in a School
+
+To get all Enrollments for a Class in a School on the service provider. If the specified school and/or class cannot be identified within the service provider, the api will return a 404 error code and message 'School or class not found.'`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await schoolsManagementGetEnrollmentsForClassInSchool(
+            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/schoolsManagementGetEnrollmentsForSchool.ts

@@ -0,0 +1,33 @@
+import { schoolsManagementGetEnrollmentsForSchool } from '../../funcs/schoolsManagementGetEnrollmentsForSchool.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.GetEnrollmentsForSchoolRequest$inboundSchema,
+};
+
+export const tool$schoolsManagementGetEnrollmentsForSchool: ToolDefinition<typeof args> = {
+    name: 'schools-get-enrolls-school',
+    description: `Get all Enrollments for a School
+
+To get all Enrollments for a School on the service provider. If the specified school cannot be identified within the service provider, the api will return a 404 error code and message 'School not found.'`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await schoolsManagementGetEnrollmentsForSchool(
+            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/schoolsManagementGetLineItemsForSchool.ts

@@ -0,0 +1,33 @@
+import { schoolsManagementGetLineItemsForSchool } from '../../funcs/schoolsManagementGetLineItemsForSchool.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.GetLineItemsForSchoolRequest$inboundSchema,
+};
+
+export const tool$schoolsManagementGetLineItemsForSchool: ToolDefinition<typeof args> = {
+    name: 'schools-get-lineitems-school',
+    description: `Get Line Items for a School
+
+Get the set of lineItems on the service provider for a specific school. If the corresponding record cannot be located, the api will return a 404 error code and message 'School not found.'`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await schoolsManagementGetLineItemsForSchool(
+            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/schoolsManagementGetSchool.ts

@@ -0,0 +1,31 @@
+import { schoolsManagementGetSchool } from '../../funcs/schoolsManagementGetSchool.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.GetSchoolRequest$inboundSchema,
+};
+
+export const tool$schoolsManagementGetSchool: ToolDefinition<typeof args> = {
+    name: 'schools-get-school',
+    description: `Get a specific School
+
+Get a specific School on the service provider. If the corresponding record cannot be located, the api will return a 404 error code and message 'School not found.'`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await schoolsManagementGetSchool(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/schoolsManagementGetStudentsForClassInSchool.ts

@@ -0,0 +1,33 @@
+import { schoolsManagementGetStudentsForClassInSchool } from '../../funcs/schoolsManagementGetStudentsForClassInSchool.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.GetStudentsForClassInSchoolRequest$inboundSchema,
+};
+
+export const tool$schoolsManagementGetStudentsForClassInSchool: ToolDefinition<typeof args> = {
+    name: 'schools-get-students-class-school',
+    description: `Get Students for a specific Class in a School
+
+To get all Students for a Class in a School on the service provider. If the specified school and/or class cannot be identified within the service provider, the api will return a 404 error code and message 'School or class not found.'`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await schoolsManagementGetStudentsForClassInSchool(
+            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);
+    },
+};