@eduware/oneroster 1.0.1 → 1.2.0

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

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

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

@@ -0,0 +1,33 @@
+import { enrollmentsManagementCreateEnrollment } from '../../funcs/enrollmentsManagementCreateEnrollment.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.CreateEnrollmentRequest$inboundSchema.optional(),
+};
+
+export const tool$enrollmentsManagementCreateEnrollment: ToolDefinition<typeof args> = {
+    name: 'enrollments-create-enroll',
+    description: `Create a new Enrollment
+
+To create a new Enrollment. 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 enrollmentsManagementCreateEnrollment(
+            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/enrollmentsManagementDeleteEnrollment.ts

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,33 @@
+import { lineItemsManagementCreateResultForLineItem } from '../../funcs/lineItemsManagementCreateResultForLineItem.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.CreateResultForLineItemRequest$inboundSchema,
+};
+
+export const tool$lineItemsManagementCreateResultForLineItem: ToolDefinition<typeof args> = {
+    name: 'line-items-create-result-for-lineitem',
+    description: `Create a Result for a Line Item
+
+To create a new result for a specific Line Item. 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 'Line item not found.'`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await lineItemsManagementCreateResultForLineItem(
+            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/lineItemsManagementDeleteLineItem.ts

@@ -0,0 +1,29 @@
+import { lineItemsManagementDeleteLineItem } from '../../funcs/lineItemsManagementDeleteLineItem.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.DeleteLineItemRequest$inboundSchema,
+};
+
+export const tool$lineItemsManagementDeleteLineItem: ToolDefinition<typeof args> = {
+    name: 'line-items-delete-lineitem',
+    description: `Delete a Line Item
+
+Perform a soft delete on a specific Line Item on the service provider. This operation changes the status of the LineItem to 'tobedeleted'.`,
+    args,
+    tool: async (client, args, ctx) => {
+        const [result, apiCall] = await lineItemsManagementDeleteLineItem(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/lineItemsManagementGetAllLineItems.ts

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

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

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

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

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