@openziti/ziti-mcp-server 0.1.0

package/dist/tools/identities.js

@@ -0,0 +1,741 @@
+import { createErrorResponse } from '../utils/http-utility.js';
+import { withAuthenticatedClient } from '../utils/authenticated-client.js';
+import { listIdentities, detailIdentity, createIdentity, deleteIdentity, patchIdentity, listIdentityRoleAttributes, listIdentityServices, listIdentityEdgeRouters, listIdentityServicePolicies, listIdentitysEdgeRouterPolicies, listIdentitysServiceConfigs, getIdentityPolicyAdvice, disableIdentity, enableIdentity, getIdentityAuthenticators, getIdentityEnrollments, getIdentityFailedServiceRequests, getIdentityPostureData, removeIdentityMfa, updateIdentityTracing, associateIdentitysServiceConfigs, disassociateIdentitysServiceConfigs, } from '../utils/controller-client/sdk.gen.js';
+// Define all available Identity tools
+export const IDENTITY_TOOLS = [
+    {
+        name: 'listIdentities',
+        description: 'List all Identities in the Ziti network',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+        _meta: {
+            requiredScopes: ['read:identities'],
+            readOnly: true,
+        },
+        annotations: {
+            title: 'List all Identities defined in the Ziti network.',
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    },
+    {
+        name: 'listIdentity',
+        description: 'Get details about a specific Ziti identity',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'ID of the identity to retrieve' },
+            },
+            required: ['id'],
+        },
+        _meta: {
+            requiredScopes: ['read:identities'],
+            readOnly: true,
+        },
+        annotations: {
+            title: 'Get Ziti Identity Details',
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    },
+    {
+        name: 'createIdentity',
+        description: 'Create a new Ziti Identity.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Name of the identity to create' },
+                admin: { type: 'boolean', description: 'Make an Admin or not.', default: false },
+                authPolicy: {
+                    type: 'string',
+                    description: 'The name or id of the auth policy to assign to the identity (default "default")',
+                    default: 'default',
+                },
+                externalId: { type: 'string', description: 'An external id to give to the identity' },
+                roleAttributes: {
+                    type: 'string',
+                    description: 'Comma-separated role attributes for the new identity',
+                },
+            },
+            required: ['name'],
+        },
+        _meta: {
+            requiredScopes: ['write:identities'],
+            readOnly: true,
+        },
+        annotations: {
+            title: 'Create a new Identity in the Ziti network.',
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    },
+    {
+        name: 'deleteIdentity',
+        description: 'Delete a Ziti Identity.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'ID of the identity to delete' },
+            },
+            required: ['id'],
+        },
+        _meta: {
+            requiredScopes: ['write:identities'],
+            readOnly: true,
+        },
+        annotations: {
+            title: 'Delete an Identity from the Ziti network.',
+            readOnlyHint: true,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
+    },
+    {
+        name: 'updateIdentity',
+        description: 'Update an existing Ziti Identity.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'ID of the identity to update' },
+                name: { type: 'string', description: 'Name to give the identity' },
+                admin: { type: 'boolean', description: 'Make an Admin or not.' },
+                authPolicy: {
+                    type: 'string',
+                    description: 'The name or id of the auth policy to assign to the identity',
+                },
+                externalId: { type: 'string', description: 'An external id to give to the identity' },
+                roleAttributes: {
+                    type: 'string',
+                    description: 'Comma-separated role attributes for the new identity',
+                },
+            },
+            required: ['id'],
+        },
+        _meta: {
+            requiredScopes: ['write:identities'],
+            readOnly: false,
+        },
+        annotations: {
+            title: 'Update an existing Identity in the Ziti network.',
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    },
+    {
+        name: 'listIdentityServices',
+        description: 'List all Services accessible by a specific Identity',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'ID of the identity' },
+            },
+            required: ['id'],
+        },
+        _meta: {
+            requiredScopes: ['read:identities'],
+            readOnly: true,
+        },
+        annotations: {
+            title: 'List Services for an Identity.',
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    },
+    {
+        name: 'listIdentityEdgeRouters',
+        description: 'List all Edge Routers accessible by a specific Identity',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'ID of the identity' },
+            },
+            required: ['id'],
+        },
+        _meta: {
+            requiredScopes: ['read:identities'],
+            readOnly: true,
+        },
+        annotations: {
+            title: 'List Edge Routers for an Identity.',
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    },
+    {
+        name: 'listIdentityServicePolicies',
+        description: 'List all Service Policies that apply to a specific Identity',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'ID of the identity' },
+            },
+            required: ['id'],
+        },
+        _meta: {
+            requiredScopes: ['read:identities'],
+            readOnly: true,
+        },
+        annotations: {
+            title: 'List Service Policies for an Identity.',
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    },
+    {
+        name: 'listIdentityEdgeRouterPolicies',
+        description: 'List all Edge Router Policies that apply to a specific Identity',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'ID of the identity' },
+            },
+            required: ['id'],
+        },
+        _meta: {
+            requiredScopes: ['read:identities'],
+            readOnly: true,
+        },
+        annotations: {
+            title: 'List Edge Router Policies for an Identity.',
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    },
+    {
+        name: 'listIdentityServiceConfigs',
+        description: 'List all Service Configs associated with a specific Identity',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'ID of the identity' },
+            },
+            required: ['id'],
+        },
+        _meta: {
+            requiredScopes: ['read:identities'],
+            readOnly: true,
+        },
+        annotations: {
+            title: 'List Service Configs for an Identity.',
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    },
+    {
+        name: 'getIdentityPolicyAdvice',
+        description: 'Check whether an Identity can dial or bind a specific Service and get policy advice explaining why or why not',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'ID of the identity' },
+                serviceId: { type: 'string', description: 'ID of the service to check access for' },
+            },
+            required: ['id', 'serviceId'],
+        },
+        _meta: {
+            requiredScopes: ['read:identities'],
+            readOnly: true,
+        },
+        annotations: {
+            title: 'Get policy advice for an Identity and Service.',
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    },
+    {
+        name: 'listIdentityRoleAttributes',
+        description: 'List all role attributes in use by Identities in the Ziti network',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+        _meta: {
+            requiredScopes: ['read:identities'],
+            readOnly: true,
+        },
+        annotations: {
+            title: 'List all Identity role attributes.',
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    },
+    {
+        name: 'disableIdentity',
+        description: 'Temporarily disable a Ziti Identity for a specified duration',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'ID of the identity to disable' },
+                durationMinutes: {
+                    type: 'number',
+                    description: 'Number of minutes to disable the identity for',
+                },
+            },
+            required: ['id', 'durationMinutes'],
+        },
+        _meta: {
+            requiredScopes: ['write:identities'],
+            readOnly: false,
+        },
+        annotations: {
+            title: 'Disable a Ziti Identity.',
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    },
+    {
+        name: 'enableIdentity',
+        description: 'Re-enable a previously disabled Ziti Identity',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'ID of the identity to enable' },
+            },
+            required: ['id'],
+        },
+        _meta: {
+            requiredScopes: ['write:identities'],
+            readOnly: false,
+        },
+        annotations: {
+            title: 'Enable a Ziti Identity.',
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    },
+    {
+        name: 'getIdentityAuthenticators',
+        description: 'List all Authenticators for a specific Identity',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'ID of the identity' },
+            },
+            required: ['id'],
+        },
+        _meta: {
+            requiredScopes: ['read:identities'],
+            readOnly: true,
+        },
+        annotations: {
+            title: 'Get Authenticators for an Identity.',
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    },
+    {
+        name: 'getIdentityEnrollments',
+        description: 'List all Enrollments for a specific Identity',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'ID of the identity' },
+            },
+            required: ['id'],
+        },
+        _meta: {
+            requiredScopes: ['read:identities'],
+            readOnly: true,
+        },
+        annotations: {
+            title: 'Get Enrollments for an Identity.',
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    },
+    {
+        name: 'getIdentityFailedServiceRequests',
+        description: 'List failed service requests for a specific Identity',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'ID of the identity' },
+            },
+            required: ['id'],
+        },
+        _meta: {
+            requiredScopes: ['read:identities'],
+            readOnly: true,
+        },
+        annotations: {
+            title: 'Get failed service requests for an Identity.',
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    },
+    {
+        name: 'getIdentityPostureData',
+        description: 'Get posture data for a specific Identity',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'ID of the identity' },
+            },
+            required: ['id'],
+        },
+        _meta: {
+            requiredScopes: ['read:identities'],
+            readOnly: true,
+        },
+        annotations: {
+            title: 'Get posture data for an Identity.',
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    },
+    {
+        name: 'removeIdentityMfa',
+        description: 'Remove MFA from a specific Identity',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'ID of the identity' },
+            },
+            required: ['id'],
+        },
+        _meta: {
+            requiredScopes: ['write:identities'],
+            readOnly: false,
+        },
+        annotations: {
+            title: 'Remove MFA from an Identity.',
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    },
+    {
+        name: 'updateIdentityTracing',
+        description: 'Update tracing configuration for a specific Identity',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'ID of the identity' },
+                enabled: { type: 'boolean', description: 'Whether tracing is enabled' },
+                duration: { type: 'string', description: 'Duration for tracing (e.g. "5m", "1h")' },
+                traceId: { type: 'string', description: 'Trace ID to use' },
+                channels: {
+                    type: 'string',
+                    description: 'Comma-separated list of channels to trace',
+                },
+            },
+            required: ['id'],
+        },
+        _meta: {
+            requiredScopes: ['write:identities'],
+            readOnly: false,
+        },
+        annotations: {
+            title: 'Update tracing for an Identity.',
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    },
+    {
+        name: 'associateIdentityServiceConfigs',
+        description: 'Associate service configs with a specific Identity',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'ID of the identity' },
+                serviceConfigs: {
+                    type: 'string',
+                    description: 'JSON array of objects with serviceId and configId, e.g. [{"serviceId":"abc","configId":"def"}]',
+                },
+            },
+            required: ['id', 'serviceConfigs'],
+        },
+        _meta: {
+            requiredScopes: ['write:identities'],
+            readOnly: false,
+        },
+        annotations: {
+            title: 'Associate service configs with an Identity.',
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    },
+    {
+        name: 'disassociateIdentityServiceConfigs',
+        description: 'Remove service config associations from a specific Identity',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'ID of the identity' },
+                serviceConfigs: {
+                    type: 'string',
+                    description: 'JSON array of objects with serviceId and configId, e.g. [{"serviceId":"abc","configId":"def"}]',
+                },
+            },
+            required: ['id', 'serviceConfigs'],
+        },
+        _meta: {
+            requiredScopes: ['write:identities'],
+            readOnly: false,
+        },
+        annotations: {
+            title: 'Disassociate service configs from an Identity.',
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    },
+];
+// Define handlers for each Identity tool
+export const IDENTITY_HANDLERS = {
+    listIdentities: (request, config) => withAuthenticatedClient(request, config, 'list identities', (client, ztSession) => listIdentities({ client, headers: { 'zt-session': ztSession } })),
+    listIdentity: (request, config) => {
+        const { id } = request.parameters;
+        if (!id)
+            return Promise.resolve(createErrorResponse('Error: id is required'));
+        return withAuthenticatedClient(request, config, 'get identity', (client, ztSession) => detailIdentity({ path: { id }, client, headers: { 'zt-session': ztSession } }));
+    },
+    createIdentity: (request, config) => {
+        const { name, admin = false, authPolicy = 'default', externalId, roleAttributes, } = request.parameters;
+        if (!name)
+            return Promise.resolve(createErrorResponse('Error: name is required'));
+        return withAuthenticatedClient(request, config, 'create identity', (client, ztSession) => createIdentity({
+            body: {
+                authPolicyId: authPolicy,
+                externalId,
+                isAdmin: admin,
+                name,
+                roleAttributes: roleAttributes
+                    ? roleAttributes.split(',').map((attr) => attr.trim())
+                    : undefined,
+                type: 'User',
+            },
+            client,
+            headers: { 'zt-session': ztSession },
+        }));
+    },
+    deleteIdentity: (request, config) => {
+        const { id } = request.parameters;
+        if (!id)
+            return Promise.resolve(createErrorResponse('Error: id is required'));
+        return withAuthenticatedClient(request, config, 'delete identity', (client, ztSession) => deleteIdentity({ path: { id }, client, headers: { 'zt-session': ztSession } }));
+    },
+    listIdentityServices: (request, config) => {
+        const { id } = request.parameters;
+        if (!id)
+            return Promise.resolve(createErrorResponse('Error: id is required'));
+        return withAuthenticatedClient(request, config, 'list identity services', (client, ztSession) => listIdentityServices({ path: { id }, client, headers: { 'zt-session': ztSession } }));
+    },
+    listIdentityEdgeRouters: (request, config) => {
+        const { id } = request.parameters;
+        if (!id)
+            return Promise.resolve(createErrorResponse('Error: id is required'));
+        return withAuthenticatedClient(request, config, 'list identity edge routers', (client, ztSession) => listIdentityEdgeRouters({ path: { id }, client, headers: { 'zt-session': ztSession } }));
+    },
+    listIdentityServicePolicies: (request, config) => {
+        const { id } = request.parameters;
+        if (!id)
+            return Promise.resolve(createErrorResponse('Error: id is required'));
+        return withAuthenticatedClient(request, config, 'list identity service policies', (client, ztSession) => listIdentityServicePolicies({ path: { id }, client, headers: { 'zt-session': ztSession } }));
+    },
+    listIdentityEdgeRouterPolicies: (request, config) => {
+        const { id } = request.parameters;
+        if (!id)
+            return Promise.resolve(createErrorResponse('Error: id is required'));
+        return withAuthenticatedClient(request, config, 'list identity edge router policies', (client, ztSession) => listIdentitysEdgeRouterPolicies({
+            path: { id },
+            client,
+            headers: { 'zt-session': ztSession },
+        }));
+    },
+    listIdentityServiceConfigs: (request, config) => {
+        const { id } = request.parameters;
+        if (!id)
+            return Promise.resolve(createErrorResponse('Error: id is required'));
+        return withAuthenticatedClient(request, config, 'list identity service configs', (client, ztSession) => listIdentitysServiceConfigs({
+            path: { id },
+            client,
+            headers: { 'zt-session': ztSession },
+        }));
+    },
+    getIdentityPolicyAdvice: (request, config) => {
+        const { id, serviceId } = request.parameters;
+        if (!id)
+            return Promise.resolve(createErrorResponse('Error: id is required'));
+        if (!serviceId)
+            return Promise.resolve(createErrorResponse('Error: serviceId is required'));
+        return withAuthenticatedClient(request, config, 'get identity policy advice', (client, ztSession) => getIdentityPolicyAdvice({
+            path: { id, serviceId },
+            client,
+            headers: { 'zt-session': ztSession },
+        }));
+    },
+    listIdentityRoleAttributes: (request, config) => withAuthenticatedClient(request, config, 'list identity role attributes', (client, ztSession) => listIdentityRoleAttributes({ client, headers: { 'zt-session': ztSession } })),
+    updateIdentity: (request, config) => {
+        const { id, name, admin, authPolicy, externalId, roleAttributes } = request.parameters;
+        if (!id)
+            return Promise.resolve(createErrorResponse('Error: id is required'));
+        return withAuthenticatedClient(request, config, 'update identity', (client, ztSession) => patchIdentity({
+            path: { id },
+            body: {
+                authPolicyId: authPolicy,
+                externalId,
+                isAdmin: admin,
+                name,
+                roleAttributes: roleAttributes
+                    ? roleAttributes.split(',').map((attr) => attr.trim())
+                    : undefined,
+            },
+            client,
+            headers: { 'zt-session': ztSession },
+        }));
+    },
+    disableIdentity: (request, config) => {
+        const { id, durationMinutes } = request.parameters;
+        if (!id)
+            return Promise.resolve(createErrorResponse('Error: id is required'));
+        if (durationMinutes === undefined)
+            return Promise.resolve(createErrorResponse('Error: durationMinutes is required'));
+        return withAuthenticatedClient(request, config, 'disable identity', (client, ztSession) => disableIdentity({
+            path: { id },
+            body: { durationMinutes },
+            client,
+            headers: { 'zt-session': ztSession },
+        }));
+    },
+    enableIdentity: (request, config) => {
+        const { id } = request.parameters;
+        if (!id)
+            return Promise.resolve(createErrorResponse('Error: id is required'));
+        return withAuthenticatedClient(request, config, 'enable identity', (client, ztSession) => enableIdentity({ path: { id }, client, headers: { 'zt-session': ztSession } }));
+    },
+    getIdentityAuthenticators: (request, config) => {
+        const { id } = request.parameters;
+        if (!id)
+            return Promise.resolve(createErrorResponse('Error: id is required'));
+        return withAuthenticatedClient(request, config, 'get identity authenticators', (client, ztSession) => getIdentityAuthenticators({ path: { id }, client, headers: { 'zt-session': ztSession } }));
+    },
+    getIdentityEnrollments: (request, config) => {
+        const { id } = request.parameters;
+        if (!id)
+            return Promise.resolve(createErrorResponse('Error: id is required'));
+        return withAuthenticatedClient(request, config, 'get identity enrollments', (client, ztSession) => getIdentityEnrollments({ path: { id }, client, headers: { 'zt-session': ztSession } }));
+    },
+    getIdentityFailedServiceRequests: (request, config) => {
+        const { id } = request.parameters;
+        if (!id)
+            return Promise.resolve(createErrorResponse('Error: id is required'));
+        return withAuthenticatedClient(request, config, 'get identity failed service requests', (client, ztSession) => getIdentityFailedServiceRequests({
+            path: { id },
+            client,
+            headers: { 'zt-session': ztSession },
+        }));
+    },
+    getIdentityPostureData: (request, config) => {
+        const { id } = request.parameters;
+        if (!id)
+            return Promise.resolve(createErrorResponse('Error: id is required'));
+        return withAuthenticatedClient(request, config, 'get identity posture data', (client, ztSession) => getIdentityPostureData({ path: { id }, client, headers: { 'zt-session': ztSession } }));
+    },
+    removeIdentityMfa: (request, config) => {
+        const { id } = request.parameters;
+        if (!id)
+            return Promise.resolve(createErrorResponse('Error: id is required'));
+        return withAuthenticatedClient(request, config, 'remove identity mfa', (client, ztSession) => removeIdentityMfa({ path: { id }, client, headers: { 'zt-session': ztSession } }));
+    },
+    updateIdentityTracing: (request, config) => {
+        const { id, enabled, duration, traceId, channels } = request.parameters;
+        if (!id)
+            return Promise.resolve(createErrorResponse('Error: id is required'));
+        return withAuthenticatedClient(request, config, 'update identity tracing', (client, ztSession) => updateIdentityTracing({
+            path: { id },
+            body: {
+                enabled,
+                duration,
+                traceId,
+                channels: channels ? channels.split(',').map((c) => c.trim()) : undefined,
+            },
+            client,
+            headers: { 'zt-session': ztSession },
+        }));
+    },
+    associateIdentityServiceConfigs: (request, config) => {
+        const { id, serviceConfigs } = request.parameters;
+        if (!id)
+            return Promise.resolve(createErrorResponse('Error: id is required'));
+        if (!serviceConfigs)
+            return Promise.resolve(createErrorResponse('Error: serviceConfigs is required'));
+        let parsed;
+        try {
+            parsed = JSON.parse(serviceConfigs);
+        }
+        catch {
+            return Promise.resolve(createErrorResponse('Error: serviceConfigs must be valid JSON array'));
+        }
+        return withAuthenticatedClient(request, config, 'associate identity service configs', (client, ztSession) => associateIdentitysServiceConfigs({
+            path: { id },
+            body: parsed,
+            client,
+            headers: { 'zt-session': ztSession },
+        }));
+    },
+    disassociateIdentityServiceConfigs: (request, config) => {
+        const { id, serviceConfigs } = request.parameters;
+        if (!id)
+            return Promise.resolve(createErrorResponse('Error: id is required'));
+        if (!serviceConfigs)
+            return Promise.resolve(createErrorResponse('Error: serviceConfigs is required'));
+        let parsed;
+        try {
+            parsed = JSON.parse(serviceConfigs);
+        }
+        catch {
+            return Promise.resolve(createErrorResponse('Error: serviceConfigs must be valid JSON array'));
+        }
+        return withAuthenticatedClient(request, config, 'disassociate identity service configs', (client, ztSession) => disassociateIdentitysServiceConfigs({
+            path: { id },
+            body: parsed,
+            client,
+            headers: { 'zt-session': ztSession },
+        }));
+    },
+};
+//# sourceMappingURL=identities.js.map