@eduware/oneroster 1.1.0 → 1.2.1

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);
+    },
+};

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

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

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

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

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

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

@@ -0,0 +1,34 @@
+import { resourcesManagementExportResourceToCommonCartridge } from '../../funcs/resourcesManagementExportResourceToCommonCartridge.js';
+import * as operations from '../../models/operations/index.js';
+import { formatResult, ToolDefinition } from '../tools.js';
+
+const args = {
+    request: operations.ExportResourceToCommonCartridgeRequest$inboundSchema,
+};
+
+export const tool$resourcesManagementExportResourceToCommonCartridge: ToolDefinition<typeof args> =
+    {
+        name: 'resources-export-resource-to-cc',
+        description: `Export Resource to Common Cartridge
+
+Export a resource to Common Cartridge (.imscc) format for import into LMS systems.`,
+        args,
+        tool: async (client, args, ctx) => {
+            const [result, apiCall] = await resourcesManagementExportResourceToCommonCartridge(
+                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/resourcesManagementGetAllResources.ts

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

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