@settlemint/sdk-js 2.4.0-pr04db78f3 → 2.4.0-pr0b5fc197

package/dist/settlemint.cjs

@@ -597,6 +597,26 @@ 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
@@ -665,6 +685,28 @@ 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
@@ -817,6 +859,26 @@ 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
@@ -872,6 +934,28 @@ 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
@@ -976,6 +1060,26 @@ 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
@@ -1046,6 +1150,28 @@ 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
@@ -1154,6 +1280,26 @@ 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
@@ -1214,6 +1360,28 @@ 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
@@ -1306,6 +1474,26 @@ 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
@@ -1366,6 +1554,28 @@ 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
@@ -1454,6 +1664,26 @@ 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
@@ -1508,6 +1738,28 @@ 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
@@ -1596,6 +1848,26 @@ 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
@@ -1650,6 +1922,28 @@ 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
@@ -1772,6 +2066,26 @@ 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
@@ -1850,6 +2164,28 @@ 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
@@ -2014,6 +2350,26 @@ 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
@@ -2079,6 +2435,28 @@ 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
@@ -2203,57 +2581,75 @@ function createSettleMintClient(options) {
 			read: blockchainNetworkRead(gqlClient),
 			create: blockchainNetworkCreate(gqlClient),
 			delete: blockchainNetworkDelete(gqlClient),
-			restart: blockchainNetworkRestart(gqlClient)
+			restart: blockchainNetworkRestart(gqlClient),
+			pause: blockchainNetworkPause(gqlClient),
+			resume: blockchainNetworkResume(gqlClient)
 		},
 		blockchainNode: {
 			list: blockchainNodeList(gqlClient),
 			read: blockchainNodeRead(gqlClient),
 			create: blockchainNodeCreate(gqlClient),
-			restart: blockchainNodeRestart(gqlClient)
+			restart: blockchainNodeRestart(gqlClient),
+			pause: blockchainNodePause(gqlClient),
+			resume: blockchainNodeResume(gqlClient)
 		},
 		loadBalancer: {
 			list: loadBalancerList(gqlClient),
 			read: loadBalancerRead(gqlClient),
 			create: loadBalancerCreate(gqlClient),
-			restart: loadBalancerRestart(gqlClient)
+			restart: loadBalancerRestart(gqlClient),
+			pause: loadBalancerPause(gqlClient),
+			resume: loadBalancerResume(gqlClient)
 		},
 		middleware: {
 			list: middlewareList(gqlClient),
 			read: middlewareRead(gqlClient),
 			graphSubgraphs: graphMiddlewareSubgraphs(gqlClient),
 			create: middlewareCreate(gqlClient),
-			restart: middlewareRestart(gqlClient)
+			restart: middlewareRestart(gqlClient),
+			pause: middlewarePause(gqlClient),
+			resume: middlewareResume(gqlClient)
 		},
 		integrationTool: {
 			list: integrationToolList(gqlClient),
 			read: integrationToolRead(gqlClient),
 			create: integrationToolCreate(gqlClient),
-			restart: integrationToolRestart(gqlClient)
+			restart: integrationToolRestart(gqlClient),
+			pause: integrationToolPause(gqlClient),
+			resume: integrationToolResume(gqlClient)
 		},
 		storage: {
 			list: storageList(gqlClient),
 			read: storageRead(gqlClient),
 			create: storageCreate(gqlClient),
-			restart: storageRestart(gqlClient)
+			restart: storageRestart(gqlClient),
+			pause: storagePause(gqlClient),
+			resume: storageResume(gqlClient)
 		},
 		privateKey: {
 			list: privateKeyList(gqlClient),
 			read: privatekeyRead(gqlClient),
 			create: privateKeyCreate(gqlClient),
-			restart: privateKeyRestart(gqlClient)
+			restart: privateKeyRestart(gqlClient),
+			pause: privateKeyPause(gqlClient),
+			resume: privateKeyResume(gqlClient)
 		},
 		insights: {
 			list: insightsList(gqlClient),
 			read: insightsRead(gqlClient),
 			create: insightsCreate(gqlClient),
-			restart: insightsRestart(gqlClient)
+			restart: insightsRestart(gqlClient),
+			pause: insightsPause(gqlClient),
+			resume: insightsResume(gqlClient)
 		},
 		customDeployment: {
 			list: customdeploymentList(gqlClient),
 			read: customdeploymentRead(gqlClient),
 			create: customdeploymentCreate(gqlClient),
 			update: customdeploymentUpdate(gqlClient),
-			restart: customDeploymentRestart(gqlClient)
+			restart: customDeploymentRestart(gqlClient),
+			pause: customDeploymentPause(gqlClient),
+			resume: customDeploymentResume(gqlClient)
 		},
 		foundry: { env: getEnv(gqlClient) },
 		applicationAccessToken: { create: applicationAccessTokenCreate(gqlClient) },