Generated SDK endpoints and resources for Metorial API. Contains auto-generated TypeScript interfaces, API clients, and comprehensive type definitions for all Metorial API endpoints.
npm install @metorial/generatedGenerated SDK endpoints and resources for Metorial API. Contains auto-generated TypeScript interfaces, API clients, and comprehensive type definitions for all Metorial API endpoints.
``bash`
npm install @metorial/generatedor
yarn add @metorial/generatedor
pnpm add @metorial/generatedor
bun add @metorial/generated
`typescript
import {
MetorialInstanceEndpoint,
MetorialSecretsEndpoint,
MetorialServersEndpoint,
MetorialSessionsEndpoint
} from '@metorial/generated';
// Create endpoint instances with a manager
let manager = {
apiKey: 'your-metorial-api-key',
apiHost: 'https://api.metorial.com',
headers: {}
};
// Instance endpoint
let instanceEndpoint = new MetorialInstanceEndpoint(manager);
let instanceInfo = await instanceEndpoint.get();
console.log('Instance:', instanceInfo);
// Secrets endpoint
let secretsEndpoint = new MetorialSecretsEndpoint(manager);
let secrets = await secretsEndpoint.list();
console.log('Secrets:', secrets);
// Servers endpoint
let serversEndpoint = new MetorialServersEndpoint(manager);
let servers = await serversEndpoint.list();
console.log('Servers:', servers);
// Sessions endpoint
let sessionsEndpoint = new MetorialSessionsEndpoint(manager);
let sessions = await sessionsEndpoint.list();
console.log('Sessions:', sessions);
`
`typescript
import {
MetorialServersDeploymentsEndpoint,
MetorialServersImplementationsEndpoint,
MetorialServersVariantsEndpoint,
MetorialServersVersionsEndpoint,
MetorialServersCapabilitiesEndpoint,
MetorialServerRunsEndpoint,
MetorialServerRunErrorsEndpoint
} from '@metorial/generated';
let manager = {
apiKey: 'your-metorial-api-key',
apiHost: 'https://api.metorial.com',
headers: {}
};
// Server deployments
let deploymentsEndpoint = new MetorialServersDeploymentsEndpoint(manager);
let deployments = await deploymentsEndpoint.list();
console.log('Deployments:', deployments);
let deployment = await deploymentsEndpoint.get('deployment-id');
console.log('Deployment:', deployment);
let newDeployment = await deploymentsEndpoint.create({
serverId: 'server-id',
variantId: 'variant-id',
versionId: 'version-id'
});
console.log('New deployment:', newDeployment);
// Server implementations
let implementationsEndpoint = new MetorialServersImplementationsEndpoint(manager);
let implementations = await implementationsEndpoint.list();
console.log('Implementations:', implementations);
let implementation = await implementationsEndpoint.get('implementation-id');
console.log('Implementation:', implementation);
let newImplementation = await implementationsEndpoint.create({
serverId: 'server-id',
name: 'My Implementation',
description: 'Custom implementation'
});
console.log('New implementation:', newImplementation);
// Server variants
let variantsEndpoint = new MetorialServersVariantsEndpoint(manager);
let variants = await variantsEndpoint.list();
console.log('Variants:', variants);
let variant = await variantsEndpoint.get('variant-id');
console.log('Variant:', variant);
// Server versions
let versionsEndpoint = new MetorialServersVersionsEndpoint(manager);
let versions = await versionsEndpoint.list();
console.log('Versions:', versions);
let version = await versionsEndpoint.get('version-id');
console.log('Version:', version);
// Server capabilities
let capabilitiesEndpoint = new MetorialServersCapabilitiesEndpoint(manager);
let capabilities = await capabilitiesEndpoint.list();
console.log('Capabilities:', capabilities);
// Server runs
let runsEndpoint = new MetorialServerRunsEndpoint(manager);
let runs = await runsEndpoint.list();
console.log('Runs:', runs);
let run = await runsEndpoint.get('run-id');
console.log('Run:', run);
// Server run errors
let errorsEndpoint = new MetorialServerRunErrorsEndpoint(manager);
let errors = await errorsEndpoint.list();
console.log('Errors:', errors);
let error = await errorsEndpoint.get('error-id');
console.log('Error:', error);
`
`typescript
import {
MetorialSessionsMessagesEndpoint,
MetorialSessionsConnectionsEndpoint
} from '@metorial/generated';
let manager = {
apiKey: 'your-metorial-api-key',
apiHost: 'https://api.metorial.com',
headers: {}
};
// Session messages
let messagesEndpoint = new MetorialSessionsMessagesEndpoint(manager);
let messages = await messagesEndpoint.list('session-id');
console.log('Messages:', messages);
let message = await messagesEndpoint.get('session-id', 'message-id');
console.log('Message:', message);
// Session connections
let connectionsEndpoint = new MetorialSessionsConnectionsEndpoint(manager);
let connections = await connectionsEndpoint.list('session-id');
console.log('Connections:', connections);
let connection = await connectionsEndpoint.get('session-id', 'connection-id');
console.log('Connection:', connection);
`
`typescript
import type {
SecretsGetOutput,
SecretsListOutput,
ServersGetOutput,
ServersListOutput,
ServerDeploymentsGetOutput,
ServerDeploymentsListOutput,
ServerDeploymentsCreateBody,
ServerDeploymentsUpdateBody,
SessionsGetOutput,
SessionsListOutput,
SessionsCreateBody,
SessionMessagesGetOutput,
SessionMessagesListOutput,
SessionConnectionsGetOutput,
SessionConnectionsListOutput
} from '@metorial/generated';
// Use the comprehensive type definitions
let secret: SecretsGetOutput;
let secretsList: SecretsListOutput;
let server: ServersGetOutput;
let serversList: ServersListOutput;
let deployment: ServerDeploymentsGetOutput;
let deploymentsList: ServerDeploymentsListOutput;
let deploymentCreateData: ServerDeploymentsCreateBody;
let deploymentUpdateData: ServerDeploymentsUpdateBody;
let session: SessionsGetOutput;
let sessionsList: SessionsListOutput;
let sessionCreateData: SessionsCreateBody;
let message: SessionMessagesGetOutput;
let messagesList: SessionMessagesListOutput;
let connection: SessionConnectionsGetOutput;
let connectionsList: SessionConnectionsListOutput;
`
`typescript
import { MetorialServersDeploymentsEndpoint } from '@metorial/generated';
let manager = {
apiKey: 'your-metorial-api-key',
apiHost: 'https://api.metorial.com',
headers: {}
};
let deploymentsEndpoint = new MetorialServersDeploymentsEndpoint(manager);
// List with pagination
let deployments = await deploymentsEndpoint.list({
limit: 10,
offset: 0
});
console.log('Paginated deployments:', deployments);
// List with filtering
let filteredDeployments = await deploymentsEndpoint.list({
serverId: 'specific-server-id',
status: 'active'
});
console.log('Filtered deployments:', filteredDeployments);
// List with sorting
let sortedDeployments = await deploymentsEndpoint.list({
sortBy: 'createdAt',
sortOrder: 'desc'
});
console.log('Sorted deployments:', sortedDeployments);
`
`typescript
import { MetorialServersEndpoint } from '@metorial/generated';
let manager = {
apiKey: 'your-metorial-api-key',
apiHost: 'https://api.metorial.com',
headers: {}
};
let serversEndpoint = new MetorialServersEndpoint(manager);
try {
let server = await serversEndpoint.get('invalid-id');
console.log('Server:', server);
} catch (error) {
if (error instanceof Error) {
console.log('Error:', error.message);
}
// Handle specific API errors
if (error.status === 404) {
console.log('Server not found');
} else if (error.status === 401) {
console.log('Unauthorized');
}
}
`
#### Core Endpoints
- MetorialInstanceEndpoint: Instance informationMetorialSecretsEndpoint
- : Secrets managementMetorialServersEndpoint
- : Server managementMetorialSessionsEndpoint
- : Session management
#### Server-Related Endpoints
- MetorialServersDeploymentsEndpoint: Server deploymentsMetorialServersImplementationsEndpoint
- : Server implementationsMetorialServersVariantsEndpoint
- : Server variantsMetorialServersVersionsEndpoint
- : Server versionsMetorialServersCapabilitiesEndpoint
- : Server capabilitiesMetorialServerRunsEndpoint
- : Server runsMetorialServerRunErrorsEndpoint
- : Server run errors
#### Session-Related Endpoints
- MetorialSessionsMessagesEndpoint: Session messagesMetorialSessionsConnectionsEndpoint
- : Session connections
Each endpoint provides standard CRUD operations:
- list(query?): List resources with optional query parametersget(id)
- : Get a specific resource by IDcreate(data)
- : Create a new resourceupdate(id, data)
- : Update an existing resourcedelete(id)
- : Delete a resource (where applicable)
The package exports comprehensive TypeScript types for all API resources:
- Input Types: Request bodies for create/update operations
- Output Types: Response data structures
- Query Types: Query parameter structures for list operations
- List Types: Paginated list response structures
All endpoints require a manager object with:
`typescript`
{
apiKey: string;
apiHost?: string;
headers?: Record
}
Common query parameters supported by list endpoints:
- limit: Number of items to returnoffset
- : Number of items to skipsortBy
- : Field to sort bysortOrder
- : Sort direction ('asc' or 'desc')filter`: Filter criteria (endpoint-specific)
-
MIT License - see LICENSE file for details.