@settlemint/sdk-js 2.4.0-prc1e1fd02 → 2.4.0-prc7747625

package/dist/settlemint.cjs

@@ -597,26 +597,6 @@ const restartBlockchainNetwork = graphql(`
   }
   `, [BlockchainNetworkFragment]);
 /**
-* Mutation to pause a blockchain network.
-*/
-const pauseBlockchainNetwork = graphql(`
-  mutation PauseBlockchainNetwork($uniqueName: String!) {
-    pauseBlockchainNetworkByUniqueName(uniqueName: $uniqueName) {
-      ...BlockchainNetwork
-    }
-  }
-  `, [BlockchainNetworkFragment]);
-/**
-* Mutation to resume a blockchain network.
-*/
-const resumeBlockchainNetwork = graphql(`
-  mutation ResumeBlockchainNetwork($uniqueName: String!) {
-    resumeBlockchainNetworkByUniqueName(uniqueName: $uniqueName) {
-      ...BlockchainNetwork
-    }
-  }
-  `, [BlockchainNetworkFragment]);
-/**
 * Creates a function to list blockchain networks for a given application.
 *
 * @param gqlClient - The GraphQL client instance
@@ -685,28 +665,6 @@ const blockchainNetworkRestart = (gqlClient) => async (blockchainNetworkUniqueNa
 	const { restartBlockchainNetworkByUniqueName: blockchainNetwork } = await gqlClient.request(restartBlockchainNetwork, { uniqueName: blockchainNetworkUniqueName });
 	return blockchainNetwork;
 };
-/**
-* Creates a function to pause a blockchain network.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that pauses a network by unique name
-* @throws If the network cannot be found or the pause fails
-*/
-const blockchainNetworkPause = (gqlClient) => async (blockchainNetworkUniqueName) => {
-	const { pauseBlockchainNetworkByUniqueName: blockchainNetwork } = await gqlClient.request(pauseBlockchainNetwork, { uniqueName: blockchainNetworkUniqueName });
-	return blockchainNetwork;
-};
-/**
-* Creates a function to resume a blockchain network.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that resumes a network by unique name
-* @throws If the network cannot be found or the resume fails
-*/
-const blockchainNetworkResume = (gqlClient) => async (blockchainNetworkUniqueName) => {
-	const { resumeBlockchainNetworkByUniqueName: blockchainNetwork } = await gqlClient.request(resumeBlockchainNetwork, { uniqueName: blockchainNetworkUniqueName });
-	return blockchainNetwork;
-};
 
 //#endregion
 //#region src/graphql/blockchain-node.ts
@@ -859,26 +817,6 @@ const restartBlockchainNode = graphql(`
     }
   `, [BlockchainNodeFragment]);
 /**
-* Mutation to pause a blockchain node.
-*/
-const pauseBlockchainNode = graphql(`
-    mutation PauseBlockchainNode($uniqueName: String!) {
-      pauseBlockchainNodeByUniqueName(uniqueName: $uniqueName) {
-        ...BlockchainNode
-      }
-    }
-  `, [BlockchainNodeFragment]);
-/**
-* Mutation to resume a blockchain node.
-*/
-const resumeBlockchainNode = graphql(`
-    mutation ResumeBlockchainNode($uniqueName: String!) {
-      resumeBlockchainNodeByUniqueName(uniqueName: $uniqueName) {
-        ...BlockchainNode
-      }
-    }
-  `, [BlockchainNodeFragment]);
-/**
 * Creates a function to list blockchain nodes for an application.
 *
 * @param gqlClient - The GraphQL client instance
@@ -934,28 +872,6 @@ const blockchainNodeRestart = (gqlClient) => async (blockchainNodeUniqueName) =>
 	const { restartBlockchainNodeByUniqueName: blockchainNode } = await gqlClient.request(restartBlockchainNode, { uniqueName: blockchainNodeUniqueName });
 	return blockchainNode;
 };
-/**
-* Creates a function to pause a blockchain node.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that pauses a blockchain node by unique name
-* @throws If the blockchain node cannot be found or the pause fails
-*/
-const blockchainNodePause = (gqlClient) => async (blockchainNodeUniqueName) => {
-	const { pauseBlockchainNodeByUniqueName: blockchainNode } = await gqlClient.request(pauseBlockchainNode, { uniqueName: blockchainNodeUniqueName });
-	return blockchainNode;
-};
-/**
-* Creates a function to resume a blockchain node.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that resumes a blockchain node by unique name
-* @throws If the blockchain node cannot be found or the resume fails
-*/
-const blockchainNodeResume = (gqlClient) => async (blockchainNodeUniqueName) => {
-	const { resumeBlockchainNodeByUniqueName: blockchainNode } = await gqlClient.request(resumeBlockchainNode, { uniqueName: blockchainNodeUniqueName });
-	return blockchainNode;
-};
 
 //#endregion
 //#region src/graphql/custom-deployment.ts
@@ -1060,26 +976,6 @@ const restartCustomDeployment = graphql(`
     }
   `, [CustomDeploymentFragment]);
 /**
-* Mutation to pause a custom deployment.
-*/
-const pauseCustomDeployment = graphql(`
-    mutation PauseCustomDeployment($uniqueName: String!) {
-      pauseCustomDeploymentByUniqueName(uniqueName: $uniqueName) {
-        ...CustomDeployment
-      }
-    }
-  `, [CustomDeploymentFragment]);
-/**
-* Mutation to resume a custom deployment.
-*/
-const resumeCustomDeployment = graphql(`
-    mutation ResumeCustomDeployment($uniqueName: String!) {
-      resumeCustomDeploymentByUniqueName(uniqueName: $uniqueName) {
-        ...CustomDeployment
-      }
-    }
-  `, [CustomDeploymentFragment]);
-/**
 * Creates a function to list custom deployments for an application.
 *
 * @param gqlClient - The GraphQL client instance
@@ -1150,28 +1046,6 @@ const customDeploymentRestart = (gqlClient) => async (customDeploymentUniqueName
 	const { restartCustomDeploymentByUniqueName: customDeployment } = await gqlClient.request(restartCustomDeployment, { uniqueName: customDeploymentUniqueName });
 	return customDeployment;
 };
-/**
-* Creates a function to pause a custom deployment.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that pauses a custom deployment by unique name
-* @throws If the custom deployment cannot be found or the pause fails
-*/
-const customDeploymentPause = (gqlClient) => async (customDeploymentUniqueName) => {
-	const { pauseCustomDeploymentByUniqueName: customDeployment } = await gqlClient.request(pauseCustomDeployment, { uniqueName: customDeploymentUniqueName });
-	return customDeployment;
-};
-/**
-* Creates a function to resume a custom deployment.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that resumes a custom deployment by unique name
-* @throws If the custom deployment cannot be found or the resume fails
-*/
-const customDeploymentResume = (gqlClient) => async (customDeploymentUniqueName) => {
-	const { resumeCustomDeploymentByUniqueName: customDeployment } = await gqlClient.request(resumeCustomDeployment, { uniqueName: customDeploymentUniqueName });
-	return customDeployment;
-};
 
 //#endregion
 //#region src/graphql/foundry.ts
@@ -1280,26 +1154,6 @@ const restartLoadBalancer = graphql(`
     }
   `, [LoadBalancerFragment]);
 /**
-* Mutation to pause a load balancer.
-*/
-const pauseLoadBalancer = graphql(`
-    mutation PauseLoadBalancer($uniqueName: String!) {
-      pauseLoadBalancerByUniqueName(uniqueName: $uniqueName) {
-        ...LoadBalancer
-      }
-    }
-  `, [LoadBalancerFragment]);
-/**
-* Mutation to resume a load balancer.
-*/
-const resumeLoadBalancer = graphql(`
-    mutation ResumeLoadBalancer($uniqueName: String!) {
-      resumeLoadBalancerByUniqueName(uniqueName: $uniqueName) {
-        ...LoadBalancer
-      }
-    }
-  `, [LoadBalancerFragment]);
-/**
 * Creates a function to fetch a specific load balancer.
 *
 * @param gqlClient - The GraphQL client instance
@@ -1360,28 +1214,6 @@ const loadBalancerRestart = (gqlClient) => async (loadBalancerUniqueName) => {
 	const { restartLoadBalancerByUniqueName: loadBalancer } = await gqlClient.request(restartLoadBalancer, { uniqueName: loadBalancerUniqueName });
 	return loadBalancer;
 };
-/**
-* Creates a function to pause a load balancer.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that pauses a load balancer
-* @throws If the load balancer cannot be paused or the request fails
-*/
-const loadBalancerPause = (gqlClient) => async (loadBalancerUniqueName) => {
-	const { pauseLoadBalancerByUniqueName: loadBalancer } = await gqlClient.request(pauseLoadBalancer, { uniqueName: loadBalancerUniqueName });
-	return loadBalancer;
-};
-/**
-* Creates a function to resume a load balancer.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that resumes a load balancer
-* @throws If the load balancer cannot be resumed or the request fails
-*/
-const loadBalancerResume = (gqlClient) => async (loadBalancerUniqueName) => {
-	const { resumeLoadBalancerByUniqueName: loadBalancer } = await gqlClient.request(resumeLoadBalancer, { uniqueName: loadBalancerUniqueName });
-	return loadBalancer;
-};
 
 //#endregion
 //#region src/graphql/insights.ts
@@ -1474,26 +1306,6 @@ const restartInsights = graphql(`
     }
   `, [InsightsFragment]);
 /**
-* Mutation to pause insights.
-*/
-const pauseInsights = graphql(`
-    mutation PauseInsights($uniqueName: String!) {
-      pauseInsightsByUniqueName(uniqueName: $uniqueName) {
-        ...Insights
-      }
-    }
-  `, [InsightsFragment]);
-/**
-* Mutation to resume insights.
-*/
-const resumeInsights = graphql(`
-    mutation ResumeInsights($uniqueName: String!) {
-      resumeInsightsByUniqueName(uniqueName: $uniqueName) {
-        ...Insights
-      }
-    }
-  `, [InsightsFragment]);
-/**
 * Creates a function to list insights for an application.
 *
 * @param gqlClient - The GraphQL client instance
@@ -1554,28 +1366,6 @@ const insightsRestart = (gqlClient) => async (insightsUniqueName) => {
 	const { restartInsightsByUniqueName: insights } = await gqlClient.request(restartInsights, { uniqueName: insightsUniqueName });
 	return insights;
 };
-/**
-* Creates a function to pause insights.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that pauses insights by unique name
-* @throws If the insights cannot be found or the pause fails
-*/
-const insightsPause = (gqlClient) => async (insightsUniqueName) => {
-	const { pauseInsightsByUniqueName: insights } = await gqlClient.request(pauseInsights, { uniqueName: insightsUniqueName });
-	return insights;
-};
-/**
-* Creates a function to resume insights.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that resumes insights by unique name
-* @throws If the insights cannot be found or the resume fails
-*/
-const insightsResume = (gqlClient) => async (insightsUniqueName) => {
-	const { resumeInsightsByUniqueName: insights } = await gqlClient.request(resumeInsights, { uniqueName: insightsUniqueName });
-	return insights;
-};
 
 //#endregion
 //#region src/graphql/integration-tool.ts
@@ -1664,26 +1454,6 @@ const restartIntegrationTool = graphql(`
     }
   `, [IntegrationFragment]);
 /**
-* Mutation to pause an integration.
-*/
-const pauseIntegrationTool = graphql(`
-    mutation PauseIntegrationTool($uniqueName: String!) {
-      pauseIntegrationByUniqueName(uniqueName: $uniqueName) {
-        ...Integration
-      }
-    }
-  `, [IntegrationFragment]);
-/**
-* Mutation to resume an integration.
-*/
-const resumeIntegrationTool = graphql(`
-    mutation ResumeIntegrationTool($uniqueName: String!) {
-      resumeIntegrationByUniqueName(uniqueName: $uniqueName) {
-        ...Integration
-      }
-    }
-  `, [IntegrationFragment]);
-/**
 * Creates a function to list integration tools for an application.
 *
 * @param gqlClient - The GraphQL client instance
@@ -1738,28 +1508,6 @@ const integrationToolRestart = (gqlClient) => async (integrationUniqueName) => {
 	const { restartIntegrationByUniqueName: integration } = await gqlClient.request(restartIntegrationTool, { uniqueName: integrationUniqueName });
 	return integration;
 };
-/**
-* Creates a function to pause an integration tool.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that pauses integration tool by unique name
-* @throws If the integration tool cannot be found or the pause fails
-*/
-const integrationToolPause = (gqlClient) => async (integrationUniqueName) => {
-	const { pauseIntegrationByUniqueName: integration } = await gqlClient.request(pauseIntegrationTool, { uniqueName: integrationUniqueName });
-	return integration;
-};
-/**
-* Creates a function to resume an integration tool.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that resumes integration tool by unique name
-* @throws If the integration tool cannot be found or the resume fails
-*/
-const integrationToolResume = (gqlClient) => async (integrationUniqueName) => {
-	const { resumeIntegrationByUniqueName: integration } = await gqlClient.request(resumeIntegrationTool, { uniqueName: integrationUniqueName });
-	return integration;
-};
 
 //#endregion
 //#region src/graphql/storage.ts
@@ -1848,26 +1596,6 @@ const restartStorage = graphql(`
     }
   `, [StorageFragment]);
 /**
-* Mutation to pause a storage.
-*/
-const pauseStorage = graphql(`
-    mutation PauseStorage($uniqueName: String!) {
-      pauseStorageByUniqueName(uniqueName: $uniqueName) {
-        ...Storage
-      }
-    }
-  `, [StorageFragment]);
-/**
-* Mutation to resume a storage.
-*/
-const resumeStorage = graphql(`
-    mutation ResumeStorage($uniqueName: String!) {
-      resumeStorageByUniqueName(uniqueName: $uniqueName) {
-        ...Storage
-      }
-    }
-  `, [StorageFragment]);
-/**
 * Creates a function to list storages for an application.
 *
 * @param gqlClient - The GraphQL client instance
@@ -1922,28 +1650,6 @@ const storageRestart = (gqlClient) => async (storageUniqueName) => {
 	const { restartStorageByUniqueName: storage } = await gqlClient.request(restartStorage, { uniqueName: storageUniqueName });
 	return storage;
 };
-/**
-* Creates a function to pause a storage.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that pauses storage by unique name
-* @throws If the storage cannot be found or the pause fails
-*/
-const storagePause = (gqlClient) => async (storageUniqueName) => {
-	const { pauseStorageByUniqueName: storage } = await gqlClient.request(pauseStorage, { uniqueName: storageUniqueName });
-	return storage;
-};
-/**
-* Creates a function to resume a storage.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that resumes storage by unique name
-* @throws If the storage cannot be found or the resume fails
-*/
-const storageResume = (gqlClient) => async (storageUniqueName) => {
-	const { resumeStorageByUniqueName: storage } = await gqlClient.request(resumeStorage, { uniqueName: storageUniqueName });
-	return storage;
-};
 
 //#endregion
 //#region src/graphql/middleware.ts
@@ -2066,26 +1772,6 @@ const restartMiddleware = graphql(`
     }
   `, [MiddlewareFragment]);
 /**
-* Mutation to pause a middleware.
-*/
-const pauseMiddleware = graphql(`
-    mutation PauseMiddleware($uniqueName: String!) {
-      pauseMiddlewareByUniqueName(uniqueName: $uniqueName) {
-        ...Middleware
-      }
-    }
-  `, [MiddlewareFragment]);
-/**
-* Mutation to resume a middleware.
-*/
-const resumeMiddleware = graphql(`
-    mutation ResumeMiddleware($uniqueName: String!) {
-      resumeMiddlewareByUniqueName(uniqueName: $uniqueName) {
-        ...Middleware
-      }
-    }
-  `, [MiddlewareFragment]);
-/**
 * Creates a function to list middlewares for an application.
 *
 * @param gqlClient - The GraphQL client instance
@@ -2164,28 +1850,6 @@ const middlewareRestart = (gqlClient) => async (middlewareUniqueName) => {
 	const { restartMiddlewareByUniqueName: middleware } = await gqlClient.request(restartMiddleware, { uniqueName: middlewareUniqueName });
 	return middleware;
 };
-/**
-* Creates a function to pause a middleware.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that pauses middleware by unique name
-* @throws If the middleware cannot be found or the pause fails
-*/
-const middlewarePause = (gqlClient) => async (middlewareUniqueName) => {
-	const { pauseMiddlewareByUniqueName: middleware } = await gqlClient.request(pauseMiddleware, { uniqueName: middlewareUniqueName });
-	return middleware;
-};
-/**
-* Creates a function to resume a middleware.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that resumes middleware by unique name
-* @throws If the middleware cannot be found or the resume fails
-*/
-const middlewareResume = (gqlClient) => async (middlewareUniqueName) => {
-	const { resumeMiddlewareByUniqueName: middleware } = await gqlClient.request(resumeMiddleware, { uniqueName: middlewareUniqueName });
-	return middleware;
-};
 
 //#endregion
 //#region src/graphql/platform.ts
@@ -2350,26 +2014,6 @@ const restartPrivateKey = graphql(`
     }
   `, [PrivateKeyFragment]);
 /**
-* Mutation to pause a private key.
-*/
-const pausePrivateKey = graphql(`
-    mutation PausePrivateKey($uniqueName: String!) {
-      pausePrivateKeyByUniqueName(uniqueName: $uniqueName) {
-        ...PrivateKey
-      }
-    }
-  `, [PrivateKeyFragment]);
-/**
-* Mutation to resume a private key.
-*/
-const resumePrivateKey = graphql(`
-    mutation ResumePrivateKey($uniqueName: String!) {
-      resumePrivateKeyByUniqueName(uniqueName: $uniqueName) {
-        ...PrivateKey
-      }
-    }
-  `, [PrivateKeyFragment]);
-/**
 * Creates a function to list private keys for an application.
 *
 * @param gqlClient - The GraphQL client instance
@@ -2435,28 +2079,6 @@ const privateKeyRestart = (gqlClient) => async (privateKeyUniqueName) => {
 	const { restartPrivateKeyByUniqueName: privateKey } = await gqlClient.request(restartPrivateKey, { uniqueName: privateKeyUniqueName });
 	return privateKey;
 };
-/**
-* Creates a function to pause a private key.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that pauses private key by unique name
-* @throws If the private key cannot be found or the pause fails
-*/
-const privateKeyPause = (gqlClient) => async (privateKeyUniqueName) => {
-	const { pausePrivateKeyByUniqueName: privateKey } = await gqlClient.request(pausePrivateKey, { uniqueName: privateKeyUniqueName });
-	return privateKey;
-};
-/**
-* Creates a function to resume a private key.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that resumes private key by unique name
-* @throws If the private key cannot be found or the resume fails
-*/
-const privateKeyResume = (gqlClient) => async (privateKeyUniqueName) => {
-	const { resumePrivateKeyByUniqueName: privateKey } = await gqlClient.request(resumePrivateKey, { uniqueName: privateKeyUniqueName });
-	return privateKey;
-};
 
 //#endregion
 //#region src/helpers/client-options.schema.ts
@@ -2581,75 +2203,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) },