@settlemint/sdk-mcp 2.4.0-pr3fd1ae9a → 2.4.0-pr4d875c05

package/dist/mcp.js

@@ -62161,8 +62161,7 @@ class McpServer {
   }
 }
 var EMPTY_OBJECT_JSON_SCHEMA = {
-  type: "object",
-  properties: {}
+  type: "object"
 };
 function isZodRawShape(obj) {
   if (typeof obj !== "object" || obj === null)
@@ -90400,7 +90399,7 @@ var {
 var package_default = {
   name: "@settlemint/sdk-mcp",
   description: "MCP interface for SettleMint SDK, providing development tools and project management capabilities",
-  version: "2.4.0-pr3fd1ae9a",
+  version: "2.4.0-pr4d875c05",
   type: "module",
   private: false,
   license: "FSL-1.1-MIT",
@@ -90443,9 +90442,9 @@ var package_default = {
   dependencies: {
     "@graphql-tools/load": "8.1.0",
     "@graphql-tools/url-loader": "8.0.31",
-    "@modelcontextprotocol/sdk": "1.13.3",
-    "@settlemint/sdk-js": "2.4.0-pr3fd1ae9a",
-    "@settlemint/sdk-utils": "2.4.0-pr3fd1ae9a",
+    "@modelcontextprotocol/sdk": "1.13.2",
+    "@settlemint/sdk-js": "2.4.0-pr4d875c05",
+    "@settlemint/sdk-utils": "2.4.0-pr4d875c05",
     "@commander-js/extra-typings": "14.0.0",
     commander: "14.0.0",
     zod: "^3.25.0"
@@ -103570,9 +103569,8 @@ var workspaceList = (gqlClient) => {
     const { workspaces } = await gqlClient.request(getWorkspacesAndApplications);
     const allWorkspaces = workspaces.reduce((acc, workspace) => {
       acc.push(workspace);
-      if (workspace.childWorkspaces) {
+      if (workspace.childWorkspaces)
         acc.push(...workspace.childWorkspaces);
-      }
       return acc;
     }, []);
     return allWorkspaces.sort((a3, b) => a3.name.localeCompare(b.name));
@@ -103599,9 +103597,8 @@ var workspaceDelete = (gqlClient) => {
 var workspaceAddCredits = (gqlClient) => {
   return async (workspaceId, amount) => {
     const id = validate3(IdSchema2, workspaceId);
-    if (amount <= 0) {
+    if (amount <= 0)
       throw new Error("Credit amount must be a positive number");
-    }
     const { addCredits: result } = await gqlClient.request(addCredits, {
       workspaceId: id,
       amount
@@ -103723,9 +103720,8 @@ var applicationAccessTokenCreate = (gqlClient) => {
       ...otherArgs,
       applicationId: application.id
     });
-    if (!applicationAccessToken.token) {
+    if (!applicationAccessToken.token)
       throw new Error("Failed to create application access token");
-    }
     return applicationAccessToken.token;
   };
 };
@@ -103738,7 +103734,7 @@ function setClusterServiceDefaults(args) {
 }
 function setNetworkDefaults(args) {
   const clusterServiceArgs = setClusterServiceDefaults(args);
-  if (args.consensusAlgorithm === "BESU_QBFT") {
+  if (args.consensusAlgorithm === "BESU_QBFT")
     return {
       ...clusterServiceArgs,
       chainId: args.chainId ?? 46040,
@@ -103748,7 +103744,6 @@ function setNetworkDefaults(args) {
       gasPrice: args.gasPrice ?? 0,
       secondsPerBlock: args.secondsPerBlock ?? 2
     };
-  }
   return clusterServiceArgs;
 }
 var BlockchainNetworkFragment = graphql(`
@@ -103911,20 +103906,6 @@ var restartBlockchainNetwork = graphql(`
     }
   }
   `, [BlockchainNetworkFragment]);
-var pauseBlockchainNetwork = graphql(`
-  mutation PauseBlockchainNetwork($uniqueName: String!) {
-    pauseBlockchainNetworkByUniqueName(uniqueName: $uniqueName) {
-      ...BlockchainNetwork
-    }
-  }
-  `, [BlockchainNetworkFragment]);
-var resumeBlockchainNetwork = graphql(`
-  mutation ResumeBlockchainNetwork($uniqueName: String!) {
-    resumeBlockchainNetworkByUniqueName(uniqueName: $uniqueName) {
-      ...BlockchainNetwork
-    }
-  }
-  `, [BlockchainNetworkFragment]);
 var blockchainNetworkList = (gqlClient) => {
   return async (applicationUniqueName) => {
     const { blockchainNetworksByUniqueName: { items } } = await gqlClient.request(getBlockchainNetworks, { applicationUniqueName });
@@ -103959,14 +103940,6 @@ var blockchainNetworkRestart = (gqlClient) => async (blockchainNetworkUniqueName
   const { restartBlockchainNetworkByUniqueName: blockchainNetwork } = await gqlClient.request(restartBlockchainNetwork, { uniqueName: blockchainNetworkUniqueName });
   return blockchainNetwork;
 };
-var blockchainNetworkPause = (gqlClient) => async (blockchainNetworkUniqueName) => {
-  const { pauseBlockchainNetworkByUniqueName: blockchainNetwork } = await gqlClient.request(pauseBlockchainNetwork, { uniqueName: blockchainNetworkUniqueName });
-  return blockchainNetwork;
-};
-var blockchainNetworkResume = (gqlClient) => async (blockchainNetworkUniqueName) => {
-  const { resumeBlockchainNetworkByUniqueName: blockchainNetwork } = await gqlClient.request(resumeBlockchainNetwork, { uniqueName: blockchainNetworkUniqueName });
-  return blockchainNetwork;
-};
 var BlockchainNodeFragment = graphql(`
   fragment BlockchainNode on BlockchainNode {
     __typename
@@ -104100,20 +104073,6 @@ var restartBlockchainNode = graphql(`
       }
     }
   `, [BlockchainNodeFragment]);
-var pauseBlockchainNode = graphql(`
-    mutation PauseBlockchainNode($uniqueName: String!) {
-      pauseBlockchainNodeByUniqueName(uniqueName: $uniqueName) {
-        ...BlockchainNode
-      }
-    }
-  `, [BlockchainNodeFragment]);
-var resumeBlockchainNode = graphql(`
-    mutation ResumeBlockchainNode($uniqueName: String!) {
-      resumeBlockchainNodeByUniqueName(uniqueName: $uniqueName) {
-        ...BlockchainNode
-      }
-    }
-  `, [BlockchainNodeFragment]);
 var blockchainNodeList = (gqlClient) => {
   return async (applicationUniqueName) => {
     const { blockchainNodesByUniqueName: { items } } = await gqlClient.request(getBlockchainNodes, { applicationUniqueName });
@@ -104142,14 +104101,6 @@ var blockchainNodeRestart = (gqlClient) => async (blockchainNodeUniqueName) => {
   const { restartBlockchainNodeByUniqueName: blockchainNode } = await gqlClient.request(restartBlockchainNode, { uniqueName: blockchainNodeUniqueName });
   return blockchainNode;
 };
-var blockchainNodePause = (gqlClient) => async (blockchainNodeUniqueName) => {
-  const { pauseBlockchainNodeByUniqueName: blockchainNode } = await gqlClient.request(pauseBlockchainNode, { uniqueName: blockchainNodeUniqueName });
-  return blockchainNode;
-};
-var blockchainNodeResume = (gqlClient) => async (blockchainNodeUniqueName) => {
-  const { resumeBlockchainNodeByUniqueName: blockchainNode } = await gqlClient.request(resumeBlockchainNode, { uniqueName: blockchainNodeUniqueName });
-  return blockchainNode;
-};
 var CustomDeploymentFragment = graphql(`
   fragment CustomDeployment on CustomDeployment {
     id
@@ -104232,20 +104183,6 @@ var restartCustomDeployment = graphql(`
       }
     }
   `, [CustomDeploymentFragment]);
-var pauseCustomDeployment = graphql(`
-    mutation PauseCustomDeployment($uniqueName: String!) {
-      pauseCustomDeploymentByUniqueName(uniqueName: $uniqueName) {
-        ...CustomDeployment
-      }
-    }
-  `, [CustomDeploymentFragment]);
-var resumeCustomDeployment = graphql(`
-    mutation ResumeCustomDeployment($uniqueName: String!) {
-      resumeCustomDeploymentByUniqueName(uniqueName: $uniqueName) {
-        ...CustomDeployment
-      }
-    }
-  `, [CustomDeploymentFragment]);
 var customdeploymentList = (gqlClient) => {
   return async (applicationUniqueName) => {
     const { customDeploymentsByUniqueName: { items } } = await gqlClient.request(getCustomDeployments, { applicationUniqueName });
@@ -104282,14 +104219,6 @@ var customDeploymentRestart = (gqlClient) => async (customDeploymentUniqueName)
   const { restartCustomDeploymentByUniqueName: customDeployment } = await gqlClient.request(restartCustomDeployment, { uniqueName: customDeploymentUniqueName });
   return customDeployment;
 };
-var customDeploymentPause = (gqlClient) => async (customDeploymentUniqueName) => {
-  const { pauseCustomDeploymentByUniqueName: customDeployment } = await gqlClient.request(pauseCustomDeployment, { uniqueName: customDeploymentUniqueName });
-  return customDeployment;
-};
-var customDeploymentResume = (gqlClient) => async (customDeploymentUniqueName) => {
-  const { resumeCustomDeploymentByUniqueName: customDeployment } = await gqlClient.request(resumeCustomDeployment, { uniqueName: customDeploymentUniqueName });
-  return customDeployment;
-};
 var getFoundryEnvConfig = graphql(`
     query GetFoundryEnvConfig($blockchainNodeUniqueName: String!) {
       foundryEnvConfigByUniqueName(blockchainNodeUniqueName: $blockchainNodeUniqueName)
@@ -104366,20 +104295,6 @@ var restartLoadBalancer = graphql(`
       }
     }
   `, [LoadBalancerFragment]);
-var pauseLoadBalancer = graphql(`
-    mutation PauseLoadBalancer($uniqueName: String!) {
-      pauseLoadBalancerByUniqueName(uniqueName: $uniqueName) {
-        ...LoadBalancer
-      }
-    }
-  `, [LoadBalancerFragment]);
-var resumeLoadBalancer = graphql(`
-    mutation ResumeLoadBalancer($uniqueName: String!) {
-      resumeLoadBalancerByUniqueName(uniqueName: $uniqueName) {
-        ...LoadBalancer
-      }
-    }
-  `, [LoadBalancerFragment]);
 var loadBalancerRead = (gqlClient) => {
   return async (loadBalancerUniqueName) => {
     const { loadBalancerByUniqueName: loadBalancer } = await gqlClient.request(getLoadBalancer, { uniqueName: loadBalancerUniqueName });
@@ -104413,14 +104328,6 @@ var loadBalancerRestart = (gqlClient) => async (loadBalancerUniqueName) => {
   const { restartLoadBalancerByUniqueName: loadBalancer } = await gqlClient.request(restartLoadBalancer, { uniqueName: loadBalancerUniqueName });
   return loadBalancer;
 };
-var loadBalancerPause = (gqlClient) => async (loadBalancerUniqueName) => {
-  const { pauseLoadBalancerByUniqueName: loadBalancer } = await gqlClient.request(pauseLoadBalancer, { uniqueName: loadBalancerUniqueName });
-  return loadBalancer;
-};
-var loadBalancerResume = (gqlClient) => async (loadBalancerUniqueName) => {
-  const { resumeLoadBalancerByUniqueName: loadBalancer } = await gqlClient.request(resumeLoadBalancer, { uniqueName: loadBalancerUniqueName });
-  return loadBalancer;
-};
 var InsightsFragment = graphql(`
   fragment Insights on Insights {
     __typename
@@ -104494,20 +104401,6 @@ var restartInsights = graphql(`
       }
     }
   `, [InsightsFragment]);
-var pauseInsights = graphql(`
-    mutation PauseInsights($uniqueName: String!) {
-      pauseInsightsByUniqueName(uniqueName: $uniqueName) {
-        ...Insights
-      }
-    }
-  `, [InsightsFragment]);
-var resumeInsights = graphql(`
-    mutation ResumeInsights($uniqueName: String!) {
-      resumeInsightsByUniqueName(uniqueName: $uniqueName) {
-        ...Insights
-      }
-    }
-  `, [InsightsFragment]);
 var insightsList = (gqlClient) => {
   return async (applicationUniqueName) => {
     const { insightsListByUniqueName: { items } } = await gqlClient.request(getInsights, { applicationUniqueName });
@@ -104541,14 +104434,6 @@ var insightsRestart = (gqlClient) => async (insightsUniqueName) => {
   const { restartInsightsByUniqueName: insights } = await gqlClient.request(restartInsights, { uniqueName: insightsUniqueName });
   return insights;
 };
-var insightsPause = (gqlClient) => async (insightsUniqueName) => {
-  const { pauseInsightsByUniqueName: insights } = await gqlClient.request(pauseInsights, { uniqueName: insightsUniqueName });
-  return insights;
-};
-var insightsResume = (gqlClient) => async (insightsUniqueName) => {
-  const { resumeInsightsByUniqueName: insights } = await gqlClient.request(resumeInsights, { uniqueName: insightsUniqueName });
-  return insights;
-};
 var IntegrationFragment = graphql(`
   fragment Integration on Integration {
     __typename
@@ -104618,20 +104503,6 @@ var restartIntegrationTool = graphql(`
       }
     }
   `, [IntegrationFragment]);
-var pauseIntegrationTool = graphql(`
-    mutation PauseIntegrationTool($uniqueName: String!) {
-      pauseIntegrationByUniqueName(uniqueName: $uniqueName) {
-        ...Integration
-      }
-    }
-  `, [IntegrationFragment]);
-var resumeIntegrationTool = graphql(`
-    mutation ResumeIntegrationTool($uniqueName: String!) {
-      resumeIntegrationByUniqueName(uniqueName: $uniqueName) {
-        ...Integration
-      }
-    }
-  `, [IntegrationFragment]);
 var integrationToolList = (gqlClient) => {
   return async (applicationUniqueName) => {
     const { integrationsByUniqueName: { items } } = await gqlClient.request(getIntegrations, { applicationUniqueName });
@@ -104659,14 +104530,6 @@ var integrationToolRestart = (gqlClient) => async (integrationUniqueName) => {
   const { restartIntegrationByUniqueName: integration } = await gqlClient.request(restartIntegrationTool, { uniqueName: integrationUniqueName });
   return integration;
 };
-var integrationToolPause = (gqlClient) => async (integrationUniqueName) => {
-  const { pauseIntegrationByUniqueName: integration } = await gqlClient.request(pauseIntegrationTool, { uniqueName: integrationUniqueName });
-  return integration;
-};
-var integrationToolResume = (gqlClient) => async (integrationUniqueName) => {
-  const { resumeIntegrationByUniqueName: integration } = await gqlClient.request(resumeIntegrationTool, { uniqueName: integrationUniqueName });
-  return integration;
-};
 var StorageFragment = graphql(`
   fragment Storage on Storage {
     __typename
@@ -104736,20 +104599,6 @@ var restartStorage = graphql(`
       }
     }
   `, [StorageFragment]);
-var pauseStorage = graphql(`
-    mutation PauseStorage($uniqueName: String!) {
-      pauseStorageByUniqueName(uniqueName: $uniqueName) {
-        ...Storage
-      }
-    }
-  `, [StorageFragment]);
-var resumeStorage = graphql(`
-    mutation ResumeStorage($uniqueName: String!) {
-      resumeStorageByUniqueName(uniqueName: $uniqueName) {
-        ...Storage
-      }
-    }
-  `, [StorageFragment]);
 var storageList = (gqlClient) => {
   return async (applicationUniqueName) => {
     const { storagesByUniqueName: { items } } = await gqlClient.request(getStorages, { applicationUniqueName });
@@ -104777,14 +104626,6 @@ var storageRestart = (gqlClient) => async (storageUniqueName) => {
   const { restartStorageByUniqueName: storage } = await gqlClient.request(restartStorage, { uniqueName: storageUniqueName });
   return storage;
 };
-var storagePause = (gqlClient) => async (storageUniqueName) => {
-  const { pauseStorageByUniqueName: storage } = await gqlClient.request(pauseStorage, { uniqueName: storageUniqueName });
-  return storage;
-};
-var storageResume = (gqlClient) => async (storageUniqueName) => {
-  const { resumeStorageByUniqueName: storage } = await gqlClient.request(resumeStorage, { uniqueName: storageUniqueName });
-  return storage;
-};
 var MiddlewareFragment = graphql(`
   fragment Middleware on Middleware {
     __typename
@@ -104885,20 +104726,6 @@ var restartMiddleware = graphql(`
       }
     }
   `, [MiddlewareFragment]);
-var pauseMiddleware = graphql(`
-    mutation PauseMiddleware($uniqueName: String!) {
-      pauseMiddlewareByUniqueName(uniqueName: $uniqueName) {
-        ...Middleware
-      }
-    }
-  `, [MiddlewareFragment]);
-var resumeMiddleware = graphql(`
-    mutation ResumeMiddleware($uniqueName: String!) {
-      resumeMiddlewareByUniqueName(uniqueName: $uniqueName) {
-        ...Middleware
-      }
-    }
-  `, [MiddlewareFragment]);
 var middlewareList = (gqlClient) => {
   return async (applicationUniqueName) => {
     const { middlewaresByUniqueName: { items } } = await gqlClient.request(getMiddlewares, { applicationUniqueName });
@@ -104943,14 +104770,6 @@ var middlewareRestart = (gqlClient) => async (middlewareUniqueName) => {
   const { restartMiddlewareByUniqueName: middleware } = await gqlClient.request(restartMiddleware, { uniqueName: middlewareUniqueName });
   return middleware;
 };
-var middlewarePause = (gqlClient) => async (middlewareUniqueName) => {
-  const { pauseMiddlewareByUniqueName: middleware } = await gqlClient.request(pauseMiddleware, { uniqueName: middlewareUniqueName });
-  return middleware;
-};
-var middlewareResume = (gqlClient) => async (middlewareUniqueName) => {
-  const { resumeMiddlewareByUniqueName: middleware } = await gqlClient.request(resumeMiddleware, { uniqueName: middlewareUniqueName });
-  return middleware;
-};
 var getPlatformConfigQuery = graphql(`
     query platformConfig {
       config {
@@ -105083,20 +104902,6 @@ var restartPrivateKey = graphql(`
       }
     }
   `, [PrivateKeyFragment]);
-var pausePrivateKey = graphql(`
-    mutation PausePrivateKey($uniqueName: String!) {
-      pausePrivateKeyByUniqueName(uniqueName: $uniqueName) {
-        ...PrivateKey
-      }
-    }
-  `, [PrivateKeyFragment]);
-var resumePrivateKey = graphql(`
-    mutation ResumePrivateKey($uniqueName: String!) {
-      resumePrivateKeyByUniqueName(uniqueName: $uniqueName) {
-        ...PrivateKey
-      }
-    }
-  `, [PrivateKeyFragment]);
 var privateKeyList = (gqlClient) => {
   return async (applicationUniqueName) => {
     const { privateKeysByUniqueName: { items } } = await gqlClient.request(getPrivateKeys, { applicationUniqueName });
@@ -105135,14 +104940,6 @@ var privateKeyRestart = (gqlClient) => async (privateKeyUniqueName) => {
   const { restartPrivateKeyByUniqueName: privateKey } = await gqlClient.request(restartPrivateKey, { uniqueName: privateKeyUniqueName });
   return privateKey;
 };
-var privateKeyPause = (gqlClient) => async (privateKeyUniqueName) => {
-  const { pausePrivateKeyByUniqueName: privateKey } = await gqlClient.request(pausePrivateKey, { uniqueName: privateKeyUniqueName });
-  return privateKey;
-};
-var privateKeyResume = (gqlClient) => async (privateKeyUniqueName) => {
-  const { resumePrivateKeyByUniqueName: privateKey } = await gqlClient.request(resumePrivateKey, { uniqueName: privateKeyUniqueName });
-  return privateKey;
-};
 var ClientOptionsSchema = exports_external2.object({
   accessToken: AccessTokenSchema2,
   instance: UrlSchema2
@@ -105163,30 +104960,26 @@ async function getPincodeVerificationChallenges({ userWalletAddress, accessToken
     }
   });
   if (!response.ok) {
-    if (response.status === 404) {
+    if (response.status === 404)
       throw new Error(`No user wallet found with address '${userWalletAddress}' for node '${nodeId}'`);
-    }
     throw new Error("Failed to get verification challenge");
   }
   const verificationChallenges = await response.json();
   return verificationChallenges;
 }
 function getPincodeVerificationChallengeResponse({ verificationChallenge, pincode }) {
-  if (!verificationChallenge?.challenge?.secret || !verificationChallenge?.challenge?.salt) {
+  if (!verificationChallenge?.challenge?.secret || !verificationChallenge?.challenge?.salt)
     throw new Error("Could not authenticate pin code, invalid challenge format");
-  }
   const { secret, salt } = verificationChallenge.challenge;
   return generateResponse(pincode, salt, secret);
 }
 function createSettleMintClient(options) {
   ensureServer();
-  if (options.instance === STANDALONE_INSTANCE2 || options.instance === LOCAL_INSTANCE2) {
-    if (options.anonymous) {
+  if (options.instance === STANDALONE_INSTANCE2 || options.instance === LOCAL_INSTANCE2)
+    if (options.anonymous)
       options.instance = "https://console.settlemint.com";
-    } else {
+    else
       throw new Error("Standalone and local instances cannot connect to the SettleMint platform");
-    }
-  }
   const validatedOptions = options.anonymous ? validate3(exports_external2.object({
     ...ClientOptionsSchema.shape,
     accessToken: exports_external2.literal("")
@@ -105226,75 +105019,57 @@ function createSettleMintClient(options) {
       read: blockchainNetworkRead(gqlClient),
       create: blockchainNetworkCreate(gqlClient),
       delete: blockchainNetworkDelete(gqlClient),
-      restart: blockchainNetworkRestart(gqlClient),
-      pause: blockchainNetworkPause(gqlClient),
-      resume: blockchainNetworkResume(gqlClient)
+      restart: blockchainNetworkRestart(gqlClient)
     },
     blockchainNode: {
       list: blockchainNodeList(gqlClient),
       read: blockchainNodeRead(gqlClient),
       create: blockchainNodeCreate(gqlClient),
-      restart: blockchainNodeRestart(gqlClient),
-      pause: blockchainNodePause(gqlClient),
-      resume: blockchainNodeResume(gqlClient)
+      restart: blockchainNodeRestart(gqlClient)
     },
     loadBalancer: {
       list: loadBalancerList(gqlClient),
       read: loadBalancerRead(gqlClient),
       create: loadBalancerCreate(gqlClient),
-      restart: loadBalancerRestart(gqlClient),
-      pause: loadBalancerPause(gqlClient),
-      resume: loadBalancerResume(gqlClient)
+      restart: loadBalancerRestart(gqlClient)
     },
     middleware: {
       list: middlewareList(gqlClient),
       read: middlewareRead(gqlClient),
       graphSubgraphs: graphMiddlewareSubgraphs(gqlClient),
       create: middlewareCreate(gqlClient),
-      restart: middlewareRestart(gqlClient),
-      pause: middlewarePause(gqlClient),
-      resume: middlewareResume(gqlClient)
+      restart: middlewareRestart(gqlClient)
     },
     integrationTool: {
       list: integrationToolList(gqlClient),
       read: integrationToolRead(gqlClient),
       create: integrationToolCreate(gqlClient),
-      restart: integrationToolRestart(gqlClient),
-      pause: integrationToolPause(gqlClient),
-      resume: integrationToolResume(gqlClient)
+      restart: integrationToolRestart(gqlClient)
     },
     storage: {
       list: storageList(gqlClient),
       read: storageRead(gqlClient),
       create: storageCreate(gqlClient),
-      restart: storageRestart(gqlClient),
-      pause: storagePause(gqlClient),
-      resume: storageResume(gqlClient)
+      restart: storageRestart(gqlClient)
     },
     privateKey: {
       list: privateKeyList(gqlClient),
       read: privatekeyRead(gqlClient),
       create: privateKeyCreate(gqlClient),
-      restart: privateKeyRestart(gqlClient),
-      pause: privateKeyPause(gqlClient),
-      resume: privateKeyResume(gqlClient)
+      restart: privateKeyRestart(gqlClient)
     },
     insights: {
       list: insightsList(gqlClient),
       read: insightsRead(gqlClient),
       create: insightsCreate(gqlClient),
-      restart: insightsRestart(gqlClient),
-      pause: insightsPause(gqlClient),
-      resume: insightsResume(gqlClient)
+      restart: insightsRestart(gqlClient)
     },
     customDeployment: {
       list: customdeploymentList(gqlClient),
       read: customdeploymentRead(gqlClient),
       create: customdeploymentCreate(gqlClient),
       update: customdeploymentUpdate(gqlClient),
-      restart: customDeploymentRestart(gqlClient),
-      pause: customDeploymentPause(gqlClient),
-      resume: customDeploymentResume(gqlClient)
+      restart: customDeploymentRestart(gqlClient)
     },
     foundry: { env: getEnv(gqlClient) },
     applicationAccessToken: { create: applicationAccessTokenCreate(gqlClient) },
@@ -107118,4 +106893,4 @@ await main().catch((error41) => {
   process.exit(1);
 });
 
-//# debugId=DF56A27E10AD35DB64756E2164756E21
+//# debugId=B9505183571042C664756E2164756E21