@rnsk/toolkits 0.0.10 → 0.0.12

package/dist/toolkits/postman/tools/scim_users_teams.js

@@ -0,0 +1,156 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { postmanRequest, toPostmanError } from './client.js';
+const authField = {
+    postmanApiKey: z.string().optional().describe('Injected by system; do not provide'),
+};
+function missingKey() {
+    return { error: 'Postman API key is required. Connect Postman first.' };
+}
+;
+// ---- Team users (GET /users) ----
+export const postmanGetAllTeamUsers = tool({
+    description: 'Get information about all users on the Postman team. Use when you need to list all team members and their details including roles and join dates. Returns an array of user objects with their IDs, names, usernames, emails, roles, and join timestamps.',
+    inputSchema: z.object({
+        ...authField,
+        groupId: z.string().optional().describe('Filter users by group ID'),
+    }),
+    execute: async ({ postmanApiKey, groupId }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'GET', '/users', {
+                query: { groupId },
+            });
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to get team users');
+        }
+    },
+});
+export const postmanGetATeamUser = tool({
+    description: 'Get information about a user on the Postman team. Use when you need to retrieve details about a specific team member including their ID, name, email, roles, and join date.',
+    inputSchema: z.object({
+        ...authField,
+        userId: z.number().int().describe('The ID of the user to retrieve information about'),
+    }),
+    execute: async ({ postmanApiKey, userId }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'GET', `/users/${encodeURIComponent(String(userId))}`);
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to get team user');
+        }
+    },
+});
+export const postmanGetAuthenticatedUser = tool({
+    description: 'Get information about the authenticated user. Use when you need to retrieve details about the current authenticated user, including their user ID, username, and email address.',
+    inputSchema: z.object({
+        ...authField,
+    }),
+    execute: async ({ postmanApiKey }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'GET', '/me');
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to get authenticated user');
+        }
+    },
+});
+// ---- Groups (GET /groups) ----
+export const postmanGetAllGroups = tool({
+    description: 'Get all user groups in a Postman team. Use when you need to list all groups and their details including member counts and timestamps. Returns an array of group objects with their IDs, names, team IDs, user counts, and creation/update timestamps.',
+    inputSchema: z.object({
+        ...authField,
+        limit: z.number().int().min(1).optional().describe('Maximum number of groups to return per page'),
+        cursor: z.string().optional().describe('Pagination cursor from a previous response'),
+    }),
+    execute: async ({ postmanApiKey, limit, cursor }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'GET', '/groups', {
+                query: { limit, cursor },
+            });
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to get groups');
+        }
+    },
+});
+// ---- SCIM (GET /scim/v2/...) ----
+export const postmanGetResourceTypes = tool({
+    description: "Get all resource types supported by Postman's SCIM API. Use when you need to discover what resource types (e.g., User, Group) are available in the SCIM API and their corresponding endpoints and schemas.",
+    inputSchema: z.object({
+        ...authField,
+    }),
+    execute: async ({ postmanApiKey }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'GET', '/scim/v2/ResourceTypes');
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to get resource types');
+        }
+    },
+});
+export const postmanGetServiceProviderConfiguration = tool({
+    description: "Get Postman's SCIM API service provider configuration information. Use when you need to discover supported SCIM operations, capabilities, and authentication schemes. Returns configuration details including support for PATCH, bulk operations, filtering, sorting, and ETag handling.",
+    inputSchema: z.object({
+        ...authField,
+    }),
+    execute: async ({ postmanApiKey }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'GET', '/scim/v2/ServiceProviderConfig');
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to get service provider configuration');
+        }
+    },
+});
+// ---- Billing (GET /accounts) ----
+export const postmanGetBillingAccountDetails = tool({
+    description: 'Retrieve Postman billing account details for the authenticated team. Use when you need to access account information such as account ID, team ID, account state, billing slots, sales channel, or billing email.',
+    inputSchema: z.object({
+        ...authField,
+    }),
+    execute: async ({ postmanApiKey }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'GET', '/accounts');
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to get billing accounts');
+        }
+    },
+});
+export const postmanListAccountInvoices = tool({
+    description: 'Get all invoices for a Postman billing account filtered by status. Use when you need to retrieve invoice history for an account. The account ID must first be obtained from the billing accounts endpoint.',
+    inputSchema: z.object({
+        ...authField,
+        accountId: z.string().describe('The billing account ID obtained from the billing accounts endpoint'),
+        status: z.string().optional().describe("Filter invoices by status, e.g. 'PAID'. If not provided, returns all invoices"),
+    }),
+    execute: async ({ postmanApiKey, accountId, status }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'GET', `/accounts/${encodeURIComponent(accountId)}/invoices`, {
+                query: { status },
+            });
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to list account invoices');
+        }
+    },
+});
+//# sourceMappingURL=scim_users_teams.js.map

package/dist/toolkits/postman/tools/specs.d.ts

@@ -0,0 +1,100 @@
+export declare const postmanCreateASpec: import("ai").Tool<{
+    type: "OPENAPI:2.0" | "OPENAPI:3.0" | "OPENAPI:3.1" | "ASYNCAPI:2.0" | "ASYNCAPI:3.0" | "PROTOBUF:2" | "PROTOBUF:3" | "GRAPHQL" | "SMITHY:2.0";
+    name: string;
+    files: {
+        path: string;
+        content: string;
+    }[];
+    workspaceId: string;
+    postmanApiKey?: string | undefined;
+}, any>;
+export declare const postmanGetAllApiSpecifications: import("ai").Tool<{
+    workspaceId: string;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+    postmanApiKey?: string | undefined;
+}, any>;
+export declare const postmanGetApiSpecification: import("ai").Tool<{
+    specId: string;
+    postmanApiKey?: string | undefined;
+}, any>;
+export declare const postmanDeleteASpec: import("ai").Tool<{
+    specId: string;
+    postmanApiKey?: string | undefined;
+}, any>;
+export declare const postmanUpdateSpecProperties: import("ai").Tool<{
+    specId: string;
+    name?: string | undefined;
+    postmanApiKey?: string | undefined;
+}, any>;
+export declare const postmanCreateSpecFile: import("ai").Tool<{
+    path: string;
+    content: string;
+    specId: string;
+    postmanApiKey?: string | undefined;
+}, any>;
+export declare const postmanGetSpecFileContents: import("ai").Tool<{
+    filePath: string;
+    specId: string;
+    postmanApiKey?: string | undefined;
+}, any>;
+export declare const postmanUpdateSpecFile: import("ai").Tool<{
+    content: string;
+    filePath: string;
+    specId: string;
+    postmanApiKey?: string | undefined;
+}, any>;
+export declare const postmanDeleteSpecFile: import("ai").Tool<{
+    filePath: string;
+    specId: string;
+    postmanApiKey?: string | undefined;
+}, any>;
+export declare const postmanGetSpecificationFiles: import("ai").Tool<{
+    specId: string;
+    postmanApiKey?: string | undefined;
+}, any>;
+export declare const postmanGetSpecDefinition: import("ai").Tool<{
+    specId: string;
+    postmanApiKey?: string | undefined;
+}, any>;
+export declare const postmanGetSpecsGeneratedCollections: import("ai").Tool<{
+    specId: string;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+    postmanApiKey?: string | undefined;
+}, any>;
+export declare const postmanGenerateCollectionFromSpec: import("ai").Tool<{
+    name: string;
+    specId: string;
+    postmanApiKey?: string | undefined;
+    folderStrategy?: "Paths" | "Tags" | undefined;
+    requestNameSource?: "Fallback" | "URL" | undefined;
+}, any>;
+export declare const postmanGenerateSpecFromCollection: import("ai").Tool<{
+    type: "OPENAPI:2.0" | "OPENAPI:3.0" | "OPENAPI:3.1";
+    name: string;
+    format: string;
+    collectionUid: string;
+    postmanApiKey?: string | undefined;
+}, any>;
+export declare const postmanGetGeneratedSpec: import("ai").Tool<{
+    collectionUid: string;
+    postmanApiKey?: string | undefined;
+}, any>;
+export declare const postmanSyncCollectionWithSpec: import("ai").Tool<{
+    collectionUid: string;
+    specId: string;
+    postmanApiKey?: string | undefined;
+}, any>;
+export declare const postmanSyncSpecWithCollection: import("ai").Tool<{
+    collectionUid: string;
+    specId: string;
+    postmanApiKey?: string | undefined;
+}, any>;
+export declare const postmanImportOpenApiSpecification: import("ai").Tool<{
+    type: string;
+    input: string;
+    workspaceId: string;
+    postmanApiKey?: string | undefined;
+}, any>;
+//# sourceMappingURL=specs.d.ts.map

package/dist/toolkits/postman/tools/specs.js

@@ -0,0 +1,380 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { postmanRequest, toPostmanError } from './client.js';
+const authField = {
+    postmanApiKey: z.string().optional().describe('Injected by system; do not provide'),
+};
+function missingKey() {
+    return { error: 'Postman API key is required. Connect Postman first.' };
+}
+const specType = z
+    .enum(['OPENAPI:2.0', 'OPENAPI:3.0', 'OPENAPI:3.1', 'ASYNCAPI:2.0', 'ASYNCAPI:3.0', 'PROTOBUF:2', 'PROTOBUF:3', 'GRAPHQL', 'SMITHY:2.0'])
+    .describe('The type of specification');
+const specFileInput = z
+    .object({
+    path: z.string().describe("The file path within the specification, e.g. 'index.yaml' or 'paths/users.yaml'"),
+    content: z.string().describe('The content of the file as a YAML or JSON string'),
+})
+    .describe('File in the API specification');
+export const postmanCreateASpec = tool({
+    description: "Create an API specification in Postman's Spec Hub. Use when you need to create single or multi-file specifications in a workspace. Supports various spec types including OpenAPI 3.0, OpenAPI 3.1, and AsyncAPI 2.0.",
+    inputSchema: z.object({
+        ...authField,
+        workspaceId: z.string().describe('The workspace ID where the spec will be created'),
+        name: z.string().describe('The name of the API specification to create'),
+        type: specType,
+        files: z
+            .array(specFileInput)
+            .min(1)
+            .describe('Array of files for the specification. For single-file specs provide one file; for multi-file specs provide multiple files'),
+    }),
+    execute: async ({ postmanApiKey, workspaceId, name, type, files }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'POST', '/specs', {
+                query: { workspaceId },
+                body: { name, type, files },
+            });
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to create spec');
+        }
+    },
+});
+export const postmanGetAllApiSpecifications = tool({
+    description: 'Get all API specifications in a workspace. Use when you need to list or retrieve API specs from a specific Postman workspace. Returns an array of spec objects with their IDs, names, types, and timestamps, along with pagination metadata.',
+    inputSchema: z.object({
+        ...authField,
+        workspaceId: z.string().describe('The workspace ID to fetch API specifications from'),
+        limit: z.number().int().min(1).optional().describe('Maximum number of specs to return per page'),
+        cursor: z.string().optional().describe('Pagination cursor from a previous response'),
+    }),
+    execute: async ({ postmanApiKey, workspaceId, limit, cursor }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'GET', '/specs', {
+                query: { workspaceId, limit, cursor },
+            });
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to get specs');
+        }
+    },
+});
+export const postmanGetApiSpecification = tool({
+    description: 'Retrieve information about an API specification in Postman. Use when you need to fetch spec details including name, type, and timestamps.',
+    inputSchema: z.object({
+        ...authField,
+        specId: z.string().describe('The unique identifier (UUID) of the API specification to retrieve'),
+    }),
+    execute: async ({ postmanApiKey, specId }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'GET', `/specs/${encodeURIComponent(specId)}`);
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to get spec');
+        }
+    },
+});
+export const postmanDeleteASpec = tool({
+    description: 'Delete an API specification from Postman. Use when you need to permanently remove a specification. On success, returns HTTP 204 No Content.',
+    inputSchema: z.object({
+        ...authField,
+        specId: z.string().describe('The ID of the API specification to delete'),
+    }),
+    execute: async ({ postmanApiKey, specId }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'DELETE', `/specs/${encodeURIComponent(specId)}`);
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to delete spec');
+        }
+    },
+});
+export const postmanUpdateSpecProperties = tool({
+    description: "Update an API specification's properties such as its name. Use when you need to modify metadata of an existing spec.",
+    inputSchema: z.object({
+        ...authField,
+        specId: z.string().describe('The unique identifier (UUID) of the API specification to update'),
+        name: z.string().optional().describe('The new name for the API specification'),
+    }),
+    execute: async ({ postmanApiKey, specId, name }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'PATCH', `/specs/${encodeURIComponent(specId)}`, {
+                body: { ...(name !== undefined ? { name } : {}) },
+            });
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to update spec properties');
+        }
+    },
+});
+export const postmanCreateSpecFile = tool({
+    description: 'Create a new file in an API specification. Use when you need to add a new file (such as schema definitions, path configurations, or components) to an existing spec.',
+    inputSchema: z.object({
+        ...authField,
+        specId: z.string().describe('The unique identifier of the API specification in which to create the file'),
+        path: z.string().describe("The file path within the spec, e.g. 'components/schemas.yaml' or 'openapi.yaml'"),
+        content: z.string().describe('The content of the file to create as a valid YAML or JSON string'),
+    }),
+    execute: async ({ postmanApiKey, specId, path, content }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'POST', `/specs/${encodeURIComponent(specId)}/files`, {
+                body: { path, content },
+            });
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to create spec file');
+        }
+    },
+});
+export const postmanGetSpecFileContents = tool({
+    description: "Get the contents of an API specification's file. Use when you need to retrieve the actual content and metadata of a specific file within a spec.",
+    inputSchema: z.object({
+        ...authField,
+        specId: z.string().describe('The ID of the API specification'),
+        filePath: z.string().describe("The path of the file within the spec, e.g. 'openapi.yaml' or 'components/schemas.yaml'"),
+    }),
+    execute: async ({ postmanApiKey, specId, filePath }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'GET', `/specs/${encodeURIComponent(specId)}/files/${encodeURIComponent(filePath)}`);
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to get spec file');
+        }
+    },
+});
+export const postmanUpdateSpecFile = tool({
+    description: "Update an API specification file's content. Use when you need to modify the contents of a specific file within a spec.",
+    inputSchema: z.object({
+        ...authField,
+        specId: z.string().describe('The unique identifier of the API specification'),
+        filePath: z.string().describe("The path of the file within the spec to update, e.g. 'openapi.yaml'"),
+        content: z.string().describe('The updated content of the spec file in YAML or JSON format'),
+    }),
+    execute: async ({ postmanApiKey, specId, filePath, content }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'PATCH', `/specs/${encodeURIComponent(specId)}/files/${encodeURIComponent(filePath)}`, { body: { content } });
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to update spec file');
+        }
+    },
+});
+export const postmanDeleteSpecFile = tool({
+    description: 'Delete a file from an API specification. Use when you need to remove a specific file from a multi-file specification.',
+    inputSchema: z.object({
+        ...authField,
+        specId: z.string().describe('The unique identifier of the API specification containing the file to delete'),
+        filePath: z.string().describe("The path of the file within the specification to delete, e.g. 'components/schemas.yaml'"),
+    }),
+    execute: async ({ postmanApiKey, specId, filePath }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'DELETE', `/specs/${encodeURIComponent(specId)}/files/${encodeURIComponent(filePath)}`);
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to delete spec file');
+        }
+    },
+});
+export const postmanGetSpecificationFiles = tool({
+    description: 'Retrieve all files in an API specification from Postman. Use when you need to list or view specification files for a specific spec ID. Returns file metadata including IDs, names, paths, types, and timestamps.',
+    inputSchema: z.object({
+        ...authField,
+        specId: z.string().describe('The ID of the API specification whose files you want to retrieve'),
+    }),
+    execute: async ({ postmanApiKey, specId }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'GET', `/specs/${encodeURIComponent(specId)}/files`);
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to get spec files');
+        }
+    },
+});
+export const postmanGetSpecDefinition = tool({
+    description: "Get the complete contents of an API specification's definition. Use when you need to retrieve the full OpenAPI/Swagger specification content for a spec. Returns the raw definition content as a string.",
+    inputSchema: z.object({
+        ...authField,
+        specId: z.string().describe('The unique identifier (UUID) of the API specification to retrieve the definition for'),
+    }),
+    execute: async ({ postmanApiKey, specId }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'GET', `/specs/${encodeURIComponent(specId)}/definitions`);
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to get spec definition');
+        }
+    },
+});
+export const postmanGetSpecsGeneratedCollections = tool({
+    description: "Retrieve all collections generated from an API specification in Postman. Use when you need to fetch collections that have been auto-generated from a spec. Returns metadata and an array of generated collections.",
+    inputSchema: z.object({
+        ...authField,
+        specId: z.string().describe('The unique identifier of the API specification'),
+        limit: z.number().int().min(1).optional().describe('Maximum number of collections to return per page'),
+        cursor: z.string().optional().describe('Pagination cursor from a previous response'),
+    }),
+    execute: async ({ postmanApiKey, specId, limit, cursor }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'GET', `/specs/${encodeURIComponent(specId)}/generations/collection`, {
+                query: { limit, cursor },
+            });
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to get generated collections');
+        }
+    },
+});
+export const postmanGenerateCollectionFromSpec = tool({
+    description: 'Generate a Postman collection from an OpenAPI 2.0, 3.0, or 3.1 specification. Use when you need to create a collection from an existing API spec. The operation is asynchronous and returns a task ID and polling URL to check the generation status.',
+    inputSchema: z.object({
+        ...authField,
+        specId: z.string().describe('The unique identifier of the API specification from which to generate the collection'),
+        name: z.string().describe('The name for the generated collection'),
+        folderStrategy: z.enum(['Paths', 'Tags']).optional().describe("How folders are organized: 'Paths' organizes by API paths, 'Tags' by OpenAPI tags"),
+        requestNameSource: z.enum(['Fallback', 'URL']).optional().describe("Source for request names: 'Fallback' uses operationId/summary/URL, 'URL' uses the endpoint URL"),
+    }),
+    execute: async ({ postmanApiKey, specId, name, folderStrategy, requestNameSource }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            const options = {};
+            if (folderStrategy !== undefined)
+                options.folderStrategy = folderStrategy;
+            if (requestNameSource !== undefined)
+                options.requestNameSource = requestNameSource;
+            return await postmanRequest(postmanApiKey, 'POST', `/specs/${encodeURIComponent(specId)}/generations/collection`, {
+                body: { name, ...(Object.keys(options).length > 0 ? { options } : {}) },
+            });
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to generate collection from spec');
+        }
+    },
+});
+export const postmanGenerateSpecFromCollection = tool({
+    description: 'Generate an API specification from a Postman collection. Use when you need to create an OpenAPI 3.0 specification from an existing collection. The operation is asynchronous and returns a task ID and polling URL to check the generation status.',
+    inputSchema: z.object({
+        ...authField,
+        collectionUid: z.string().describe('The UID of the collection to generate the specification from'),
+        name: z.string().describe('The name for the generated API specification'),
+        type: z.enum(['OPENAPI:2.0', 'OPENAPI:3.0', 'OPENAPI:3.1']).describe('The specification type to generate'),
+        format: z.string().describe("The format of the generated specification file: 'JSON' or 'YAML'"),
+    }),
+    execute: async ({ postmanApiKey, collectionUid, name, type, format }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'POST', `/collections/${encodeURIComponent(collectionUid)}/generations/spec`, {
+                body: { name, type, format },
+            });
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to generate spec from collection');
+        }
+    },
+});
+export const postmanGetGeneratedSpec = tool({
+    description: 'Retrieve the API specification generated for a Postman collection. Use when you need to fetch OpenAPI/Swagger specs that have been auto-generated from a collection. Returns metadata and an array of generated specifications.',
+    inputSchema: z.object({
+        ...authField,
+        collectionUid: z.string().describe('The UID of the collection (with team/user prefix) to get generated specifications for'),
+    }),
+    execute: async ({ postmanApiKey, collectionUid }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'GET', `/collections/${encodeURIComponent(collectionUid)}/generations/spec`);
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to get generated spec');
+        }
+    },
+});
+export const postmanSyncCollectionWithSpec = tool({
+    description: 'Sync a collection generated from an API specification. This is an asynchronous operation that returns HTTP 202 Accepted. Use when you need to update a collection to match the latest version of its source API specification. The collection must have been generated from a spec.',
+    inputSchema: z.object({
+        ...authField,
+        collectionUid: z.string().describe('The UID of a collection generated from an API specification to synchronize'),
+        specId: z.string().describe('The ID of the source API specification to sync with'),
+    }),
+    execute: async ({ postmanApiKey, collectionUid, specId }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'PUT', `/collections/${encodeURIComponent(collectionUid)}/synchronizations`, {
+                query: { specId },
+            });
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to sync collection with spec');
+        }
+    },
+});
+export const postmanSyncSpecWithCollection = tool({
+    description: 'Sync an API specification with a linked collection. This is an asynchronous operation that returns HTTP 202 Accepted with task tracking information. Use when you need to synchronize changes from a spec to its generated collection. Prerequisites: the collection must be generated from the spec, and the spec must be single-file.',
+    inputSchema: z.object({
+        ...authField,
+        specId: z.string().describe('The UUID of the API specification to sync'),
+        collectionUid: z.string().describe('The UID of the collection generated from this spec to sync with'),
+    }),
+    execute: async ({ postmanApiKey, specId, collectionUid }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'PUT', `/specs/${encodeURIComponent(specId)}/synchronizations`, {
+                query: { collectionUid },
+            });
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to sync spec with collection');
+        }
+    },
+});
+export const postmanImportOpenApiSpecification = tool({
+    description: 'Import an OpenAPI specification into Postman as a new collection. Use when you need to convert an OpenAPI 3.0+ specification into a Postman collection within a specific workspace. The imported specification is automatically converted to a Postman collection with all endpoints, request parameters, and documentation.',
+    inputSchema: z.object({
+        ...authField,
+        workspaceId: z.string().describe('The workspace ID where the OpenAPI specification will be imported as a collection'),
+        type: z.string().describe("The type of import input. Use 'string' when providing the specification as a JSON/YAML string, or 'file' when uploading a file"),
+        input: z.string().describe("The OpenAPI specification content as a JSON or YAML string. Must be a valid OpenAPI 3.0+ specification with 'openapi', 'info', and 'paths'"),
+    }),
+    execute: async ({ postmanApiKey, workspaceId, type, input }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'POST', '/import/openapi', {
+                query: { workspace: workspaceId },
+                body: { type, input },
+            });
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to import OpenAPI specification');
+        }
+    },
+});
+//# sourceMappingURL=specs.js.map

package/dist/toolkits/postman/tools/webhooks.d.ts

@@ -0,0 +1,8 @@
+export declare const postmanCreateAWebhook: import("ai").Tool<{
+    name: string;
+    collectionId: string;
+    workspaceId: string;
+    postmanApiKey?: string | undefined;
+    environmentId?: string | undefined;
+}, any>;
+//# sourceMappingURL=webhooks.d.ts.map