@distilled.cloud/mongodb-atlas 0.0.0-john

package/src/operations/createGroupIntegration.ts

@@ -0,0 +1,62 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const CreateGroupIntegrationInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    integrationType: Schema.Literals([
+      "PAGER_DUTY",
+      "SLACK",
+      "DATADOG",
+      "NEW_RELIC",
+      "OPS_GENIE",
+      "VICTOR_OPS",
+      "WEBHOOK",
+      "HIP_CHAT",
+      "PROMETHEUS",
+      "MICROSOFT_TEAMS",
+    ]).pipe(T.PathParam()),
+    groupId: Schema.String.pipe(T.PathParam()),
+    envelope: Schema.optional(Schema.Boolean),
+    includeCount: Schema.optional(Schema.Boolean),
+    itemsPerPage: Schema.optional(Schema.Number),
+    pageNum: Schema.optional(Schema.Number),
+    pretty: Schema.optional(Schema.Boolean),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/api/atlas/v2/groups/{groupId}/integrations/{integrationType}",
+    }),
+  );
+export type CreateGroupIntegrationInput =
+  typeof CreateGroupIntegrationInput.Type;
+
+// Output Schema
+export const CreateGroupIntegrationOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type CreateGroupIntegrationOutput =
+  typeof CreateGroupIntegrationOutput.Type;
+
+// The operation
+/**
+ * Create One Third-Party Service Integration
+ *
+ * Adds the settings for configuring one third-party service integration. These settings apply to all databases managed in the specified MongoDB Cloud project. Each project can have only one configuration per `{INTEGRATION-TYPE}`. To use this resource, the requesting Service Account or API Key must have the Organization Owner or Project Owner role.
+ *
+ * @param integrationType - Human-readable label that identifies the service which you want to integrate with MongoDB Cloud.
+ * @param envelope - Flag that indicates whether Application wraps the response in an `envelope` JSON object. Some API clients cannot access the HTTP response headers or status code. To remediate this, set envelope=true in the query. Endpoints that return a list of results use the results object as an envelope. Application adds the status parameter to the response body.
+ * @param groupId - Unique 24-hexadecimal digit string that identifies your project. Use the [/groups](#tag/Projects/operation/listProjects) endpoint to retrieve all projects to which the authenticated user has access.
+
+**NOTE**: Groups and projects are synonymous terms. Your group id is the same as your project id. For existing groups, your group/project id remains the same. The resource and corresponding endpoints use the term groups.
+ * @param includeCount - Flag that indicates whether the response returns the total number of items (`totalCount`) in the response.
+ * @param itemsPerPage - Number of items that the response returns per page.
+ * @param pageNum - Number of the page that displays the current set of the total objects that the response returns.
+ * @param pretty - Flag that indicates whether the response body should be in the prettyprint format.
+ */
+export const createGroupIntegration = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: CreateGroupIntegrationInput,
+    outputSchema: CreateGroupIntegrationOutput,
+  }),
+);

package/src/operations/createGroupLiveMigration.ts

@@ -0,0 +1,46 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const CreateGroupLiveMigrationInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    groupId: Schema.String.pipe(T.PathParam()),
+    envelope: Schema.optional(Schema.Boolean),
+    pretty: Schema.optional(Schema.Boolean),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/api/atlas/v2/groups/{groupId}/liveMigrations",
+    }),
+  );
+export type CreateGroupLiveMigrationInput =
+  typeof CreateGroupLiveMigrationInput.Type;
+
+// Output Schema
+export const CreateGroupLiveMigrationOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type CreateGroupLiveMigrationOutput =
+  typeof CreateGroupLiveMigrationOutput.Type;
+
+// The operation
+/**
+ * Create One Migration for One Local Managed Cluster to MongoDB Atlas
+ *
+ * Migrate one cluster that Cloud or Ops Manager manages to MongoDB Atlas.
+ * Please make sure to validate your migration before initiating it.
+ * You can use this API endpoint for push live migrations only. Your API Key must have the Organization Owner role to successfully call this resource.
+ * **NOTE**: Migrating time-series collections is not yet supported on MongoDB 6.0 or higher. Migrations on MongoDB 6.0 or higher will skip any time-series collections on the source cluster. Deprecated versions: v2-{2023-01-01}
+ *
+ * @param groupId - Unique 24-hexadecimal digit string that identifies your project. Use the [/groups](#tag/Projects/operation/listProjects) endpoint to retrieve all projects to which the authenticated user has access.
+
+**NOTE**: Groups and projects are synonymous terms. Your group id is the same as your project id. For existing groups, your group/project id remains the same. The resource and corresponding endpoints use the term groups.
+ * @param envelope - Flag that indicates whether Application wraps the response in an `envelope` JSON object. Some API clients cannot access the HTTP response headers or status code. To remediate this, set envelope=true in the query. Endpoints that return a list of results use the results object as an envelope. Application adds the status parameter to the response body.
+ * @param pretty - Flag that indicates whether the response body should be in the prettyprint format.
+ */
+export const createGroupLiveMigration = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: CreateGroupLiveMigrationInput,
+    outputSchema: CreateGroupLiveMigrationOutput,
+  }),
+);

package/src/operations/createGroupLogIntegration.ts

@@ -0,0 +1,43 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const CreateGroupLogIntegrationInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    groupId: Schema.String.pipe(T.PathParam()),
+    envelope: Schema.optional(Schema.Boolean),
+    pretty: Schema.optional(Schema.Boolean),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/api/atlas/v2/groups/{groupId}/logIntegrations",
+    }),
+  );
+export type CreateGroupLogIntegrationInput =
+  typeof CreateGroupLogIntegrationInput.Type;
+
+// Output Schema
+export const CreateGroupLogIntegrationOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type CreateGroupLogIntegrationOutput =
+  typeof CreateGroupLogIntegrationOutput.Type;
+
+// The operation
+/**
+ * Create One Log Integration
+ *
+ * Creates a new log integration configuration identified by a unique ID. To use this resource, the requesting Service Account or API Key must have the Organization Owner or Project Owner role.
+ *
+ * @param envelope - Flag that indicates whether Application wraps the response in an `envelope` JSON object. Some API clients cannot access the HTTP response headers or status code. To remediate this, set envelope=true in the query. Endpoints that return a list of results use the results object as an envelope. Application adds the status parameter to the response body.
+ * @param groupId - Unique 24-hexadecimal digit string that identifies your project. Use the [/groups](#tag/Projects/operation/listProjects) endpoint to retrieve all projects to which the authenticated user has access.
+
+**NOTE**: Groups and projects are synonymous terms. Your group id is the same as your project id. For existing groups, your group/project id remains the same. The resource and corresponding endpoints use the term groups.
+ * @param pretty - Flag that indicates whether the response body should be in the prettyprint format.
+ */
+export const createGroupLogIntegration = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: CreateGroupLogIntegrationInput,
+    outputSchema: CreateGroupLogIntegrationOutput,
+  }),
+);

package/src/operations/createGroupPeer.ts

@@ -0,0 +1,34 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const CreateGroupPeerInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  groupId: Schema.String.pipe(T.PathParam()),
+  envelope: Schema.optional(Schema.Boolean),
+  pretty: Schema.optional(Schema.Boolean),
+}).pipe(
+  T.Http({ method: "POST", path: "/api/atlas/v2/groups/{groupId}/peers" }),
+);
+export type CreateGroupPeerInput = typeof CreateGroupPeerInput.Type;
+
+// Output Schema
+export const CreateGroupPeerOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type CreateGroupPeerOutput = typeof CreateGroupPeerOutput.Type;
+
+// The operation
+/**
+ * Create One Network Peering Connection
+ *
+ * Creates one new network peering connection in the specified project. Network peering allows multiple cloud-hosted applications to securely connect to the same project. To use this resource, the requesting Service Account or API Key must have the Project Owner role or Project Network Access Manager role. To learn more about considerations and prerequisites, see the Network Peering Documentation.
+ *
+ * @param envelope - Flag that indicates whether Application wraps the response in an `envelope` JSON object. Some API clients cannot access the HTTP response headers or status code. To remediate this, set envelope=true in the query. Endpoints that return a list of results use the results object as an envelope. Application adds the status parameter to the response body.
+ * @param groupId - Unique 24-hexadecimal digit string that identifies your project. Use the [/groups](#tag/Projects/operation/listProjects) endpoint to retrieve all projects to which the authenticated user has access.
+
+**NOTE**: Groups and projects are synonymous terms. Your group id is the same as your project id. For existing groups, your group/project id remains the same. The resource and corresponding endpoints use the term groups.
+ * @param pretty - Flag that indicates whether the response body should be in the prettyprint format.
+ */
+export const createGroupPeer = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: CreateGroupPeerInput,
+  outputSchema: CreateGroupPeerOutput,
+}));

package/src/operations/createGroupPrivateEndpointEndpointService.ts

@@ -0,0 +1,42 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const CreateGroupPrivateEndpointEndpointServiceInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    groupId: Schema.String.pipe(T.PathParam()),
+    envelope: Schema.optional(Schema.Boolean),
+    pretty: Schema.optional(Schema.Boolean),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/api/atlas/v2/groups/{groupId}/privateEndpoint/endpointService",
+    }),
+  );
+export type CreateGroupPrivateEndpointEndpointServiceInput =
+  typeof CreateGroupPrivateEndpointEndpointServiceInput.Type;
+
+// Output Schema
+export const CreateGroupPrivateEndpointEndpointServiceOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type CreateGroupPrivateEndpointEndpointServiceOutput =
+  typeof CreateGroupPrivateEndpointEndpointServiceOutput.Type;
+
+// The operation
+/**
+ * Create One Private Endpoint Service for One Provider
+ *
+ * Creates one private endpoint service for the specified cloud service provider. This cloud service provider manages the private endpoint service for the project. When you create a private endpoint service, MongoDB Cloud creates a network container in the project for the cloud provider for which you create the private endpoint service if one doesn't already exist. To learn more about private endpoint terminology in MongoDB Cloud, see Private Endpoint Concepts. To use this resource, the requesting Service Account or API Key must have the Project Owner role.
+ *
+ * @param envelope - Flag that indicates whether Application wraps the response in an `envelope` JSON object. Some API clients cannot access the HTTP response headers or status code. To remediate this, set envelope=true in the query. Endpoints that return a list of results use the results object as an envelope. Application adds the status parameter to the response body.
+ * @param groupId - Unique 24-hexadecimal digit string that identifies your project. Use the [/groups](#tag/Projects/operation/listProjects) endpoint to retrieve all projects to which the authenticated user has access.
+
+**NOTE**: Groups and projects are synonymous terms. Your group id is the same as your project id. For existing groups, your group/project id remains the same. The resource and corresponding endpoints use the term groups.
+ * @param pretty - Flag that indicates whether the response body should be in the prettyprint format.
+ */
+export const createGroupPrivateEndpointEndpointService =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: CreateGroupPrivateEndpointEndpointServiceInput,
+    outputSchema: CreateGroupPrivateEndpointEndpointServiceOutput,
+  }));

package/src/operations/createGroupPrivateEndpointEndpointServiceEndpoint.ts

@@ -0,0 +1,46 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const CreateGroupPrivateEndpointEndpointServiceEndpointInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    groupId: Schema.String.pipe(T.PathParam()),
+    cloudProvider: Schema.Literals(["AWS", "AZURE", "GCP"]).pipe(T.PathParam()),
+    endpointServiceId: Schema.String.pipe(T.PathParam()),
+    envelope: Schema.optional(Schema.Boolean),
+    pretty: Schema.optional(Schema.Boolean),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/api/atlas/v2/groups/{groupId}/privateEndpoint/{cloudProvider}/endpointService/{endpointServiceId}/endpoint",
+    }),
+  );
+export type CreateGroupPrivateEndpointEndpointServiceEndpointInput =
+  typeof CreateGroupPrivateEndpointEndpointServiceEndpointInput.Type;
+
+// Output Schema
+export const CreateGroupPrivateEndpointEndpointServiceEndpointOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type CreateGroupPrivateEndpointEndpointServiceEndpointOutput =
+  typeof CreateGroupPrivateEndpointEndpointServiceEndpointOutput.Type;
+
+// The operation
+/**
+ * Create One Private Endpoint for One Provider
+ *
+ * Creates one private endpoint for the specified cloud service provider. This cloud service provider manages the private endpoint service, which in turn manages the private endpoints for the project. To use this resource, the requesting Service Account or API Key must have the Project Owner role. To learn more about considerations, limitations, and prerequisites, see the MongoDB documentation for setting up a private endpoint.
+ *
+ * @param envelope - Flag that indicates whether Application wraps the response in an `envelope` JSON object. Some API clients cannot access the HTTP response headers or status code. To remediate this, set envelope=true in the query. Endpoints that return a list of results use the results object as an envelope. Application adds the status parameter to the response body.
+ * @param groupId - Unique 24-hexadecimal digit string that identifies your project. Use the [/groups](#tag/Projects/operation/listProjects) endpoint to retrieve all projects to which the authenticated user has access.
+
+**NOTE**: Groups and projects are synonymous terms. Your group id is the same as your project id. For existing groups, your group/project id remains the same. The resource and corresponding endpoints use the term groups.
+ * @param pretty - Flag that indicates whether the response body should be in the prettyprint format.
+ * @param cloudProvider - Cloud service provider that manages this private endpoint.
+ * @param endpointServiceId - Unique 24-hexadecimal digit string that identifies the private endpoint service for which you want to create a private endpoint.
+ */
+export const createGroupPrivateEndpointEndpointServiceEndpoint =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: CreateGroupPrivateEndpointEndpointServiceEndpointInput,
+    outputSchema: CreateGroupPrivateEndpointEndpointServiceEndpointOutput,
+  }));

package/src/operations/createGroupPrivateNetworkSettingEndpointId.ts

@@ -0,0 +1,51 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const CreateGroupPrivateNetworkSettingEndpointIdInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    groupId: Schema.String.pipe(T.PathParam()),
+    envelope: Schema.optional(Schema.Boolean),
+    pretty: Schema.optional(Schema.Boolean),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/api/atlas/v2/groups/{groupId}/privateNetworkSettings/endpointIds",
+    }),
+  );
+export type CreateGroupPrivateNetworkSettingEndpointIdInput =
+  typeof CreateGroupPrivateNetworkSettingEndpointIdInput.Type;
+
+// Output Schema
+export const CreateGroupPrivateNetworkSettingEndpointIdOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type CreateGroupPrivateNetworkSettingEndpointIdOutput =
+  typeof CreateGroupPrivateNetworkSettingEndpointIdOutput.Type;
+
+// The operation
+/**
+ * Create One Federated Database Instance and Online Archive Private Endpoint for One Project
+ *
+ * Adds one private endpoint for Federated Database Instances and Online Archives to the specified projects. If the endpoint ID already exists and the associated comment is unchanged, Atlas Data Federation makes no change to the endpoint ID list. If the endpoint ID already exists and the associated comment is changed, Atlas Data Federation updates the comment value only in the endpoint ID list. If the endpoint ID doesn't exist, Atlas Data Federation appends the new endpoint to the list of endpoints in the endpoint ID list. Each region has an associated service name for the various endpoints in each region.
+ * `us-east-1` is `com.amazonaws.vpce.us-east-1.vpce-svc-00e311695874992b4`.
+ * `us-west-1` is `com.amazonaws.vpce.us-west-2.vpce-svc-09d86b19e59d1b4bb`.
+ * `eu-west-1` is `com.amazonaws.vpce.eu-west-1.vpce-svc-0824460b72e1a420e`.
+ * `eu-west-2` is `com.amazonaws.vpce.eu-west-2.vpce-svc-052f1840aa0c4f1f9`.
+ * `eu-central-1` is `com.amazonaws.vpce.eu-central-1.vpce-svc-0ac8ce91871138c0d`.
+ * `sa-east-1` is `com.amazonaws.vpce.sa-east-1.vpce-svc-0b56e75e8cdf50044`.
+ * `ap-southeast-2` is `com.amazonaws.vpce.ap-southeast-2.vpce-svc-036f1de74d761706e`.
+ * `ap-south-1` is `com.amazonaws.vpce.ap-south-1.vpce-svc-03eb8a541f96d356d`.
+ * To use this resource, the requesting Service Account or API Key must have the Project Owner or Project Charts Admin roles.
+ *
+ * @param envelope - Flag that indicates whether Application wraps the response in an `envelope` JSON object. Some API clients cannot access the HTTP response headers or status code. To remediate this, set envelope=true in the query. Endpoints that return a list of results use the results object as an envelope. Application adds the status parameter to the response body.
+ * @param groupId - Unique 24-hexadecimal digit string that identifies your project. Use the [/groups](#tag/Projects/operation/listProjects) endpoint to retrieve all projects to which the authenticated user has access.
+
+**NOTE**: Groups and projects are synonymous terms. Your group id is the same as your project id. For existing groups, your group/project id remains the same. The resource and corresponding endpoints use the term groups.
+ * @param pretty - Flag that indicates whether the response body should be in the prettyprint format.
+ */
+export const createGroupPrivateNetworkSettingEndpointId =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: CreateGroupPrivateNetworkSettingEndpointIdInput,
+    outputSchema: CreateGroupPrivateNetworkSettingEndpointIdOutput,
+  }));

package/src/operations/createGroupServiceAccount.ts

@@ -0,0 +1,43 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const CreateGroupServiceAccountInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    groupId: Schema.String.pipe(T.PathParam()),
+    envelope: Schema.optional(Schema.Boolean),
+    pretty: Schema.optional(Schema.Boolean),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/api/atlas/v2/groups/{groupId}/serviceAccounts",
+    }),
+  );
+export type CreateGroupServiceAccountInput =
+  typeof CreateGroupServiceAccountInput.Type;
+
+// Output Schema
+export const CreateGroupServiceAccountOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type CreateGroupServiceAccountOutput =
+  typeof CreateGroupServiceAccountOutput.Type;
+
+// The operation
+/**
+ * Create One Project Service Account
+ *
+ * Creates one Service Account for the specified Project. The Service Account will automatically be added as an Organization Member to the Organization that the specified Project is a part of.
+ *
+ * @param groupId - Unique 24-hexadecimal digit string that identifies your project. Use the [/groups](#tag/Projects/operation/listProjects) endpoint to retrieve all projects to which the authenticated user has access.
+
+**NOTE**: Groups and projects are synonymous terms. Your group id is the same as your project id. For existing groups, your group/project id remains the same. The resource and corresponding endpoints use the term groups.
+ * @param envelope - Flag that indicates whether Application wraps the response in an `envelope` JSON object. Some API clients cannot access the HTTP response headers or status code. To remediate this, set envelope=true in the query. Endpoints that return a list of results use the results object as an envelope. Application adds the status parameter to the response body.
+ * @param pretty - Flag that indicates whether the response body should be in the prettyprint format.
+ */
+export const createGroupServiceAccount = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: CreateGroupServiceAccountInput,
+    outputSchema: CreateGroupServiceAccountOutput,
+  }),
+);

package/src/operations/createGroupServiceAccountAccessList.ts

@@ -0,0 +1,50 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const CreateGroupServiceAccountAccessListInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    groupId: Schema.String.pipe(T.PathParam()),
+    clientId: Schema.String.pipe(T.PathParam()),
+    envelope: Schema.optional(Schema.Boolean),
+    includeCount: Schema.optional(Schema.Boolean),
+    itemsPerPage: Schema.optional(Schema.Number),
+    pageNum: Schema.optional(Schema.Number),
+    pretty: Schema.optional(Schema.Boolean),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/api/atlas/v2/groups/{groupId}/serviceAccounts/{clientId}/accessList",
+    }),
+  );
+export type CreateGroupServiceAccountAccessListInput =
+  typeof CreateGroupServiceAccountAccessListInput.Type;
+
+// Output Schema
+export const CreateGroupServiceAccountAccessListOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type CreateGroupServiceAccountAccessListOutput =
+  typeof CreateGroupServiceAccountAccessListOutput.Type;
+
+// The operation
+/**
+ * Add Access List Entries for One Project Service Account
+ *
+ * Add Access List Entries for the specified Service Account for the project. Resources require all API requests to originate from IP addresses on the API access list. To use this resource, the requesting Service Account or API Key must have the Project Owner role or Project Access Manager role.
+ *
+ * @param envelope - Flag that indicates whether Application wraps the response in an `envelope` JSON object. Some API clients cannot access the HTTP response headers or status code. To remediate this, set envelope=true in the query. Endpoints that return a list of results use the results object as an envelope. Application adds the status parameter to the response body.
+ * @param includeCount - Flag that indicates whether the response returns the total number of items (`totalCount`) in the response.
+ * @param itemsPerPage - Number of items that the response returns per page.
+ * @param groupId - Unique 24-hexadecimal digit string that identifies your project. Use the [/groups](#tag/Projects/operation/listProjects) endpoint to retrieve all projects to which the authenticated user has access.
+
+**NOTE**: Groups and projects are synonymous terms. Your group id is the same as your project id. For existing groups, your group/project id remains the same. The resource and corresponding endpoints use the term groups.
+ * @param pageNum - Number of the page that displays the current set of the total objects that the response returns.
+ * @param pretty - Flag that indicates whether the response body should be in the prettyprint format.
+ * @param clientId - The Client ID of the Service Account.
+ */
+export const createGroupServiceAccountAccessList =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: CreateGroupServiceAccountAccessListInput,
+    outputSchema: CreateGroupServiceAccountAccessListOutput,
+  }));

package/src/operations/createGroupServiceAccountSecret.ts

@@ -0,0 +1,44 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const CreateGroupServiceAccountSecretInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    groupId: Schema.String.pipe(T.PathParam()),
+    clientId: Schema.String.pipe(T.PathParam()),
+    envelope: Schema.optional(Schema.Boolean),
+    pretty: Schema.optional(Schema.Boolean),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/api/atlas/v2/groups/{groupId}/serviceAccounts/{clientId}/secrets",
+    }),
+  );
+export type CreateGroupServiceAccountSecretInput =
+  typeof CreateGroupServiceAccountSecretInput.Type;
+
+// Output Schema
+export const CreateGroupServiceAccountSecretOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type CreateGroupServiceAccountSecretOutput =
+  typeof CreateGroupServiceAccountSecretOutput.Type;
+
+// The operation
+/**
+ * Create One Project Service Account Secret
+ *
+ * Create a secret for the specified Service Account in the specified Project.
+ *
+ * @param groupId - Unique 24-hexadecimal digit string that identifies your project. Use the [/groups](#tag/Projects/operation/listProjects) endpoint to retrieve all projects to which the authenticated user has access.
+
+**NOTE**: Groups and projects are synonymous terms. Your group id is the same as your project id. For existing groups, your group/project id remains the same. The resource and corresponding endpoints use the term groups.
+ * @param clientId - The Client ID of the Service Account.
+ * @param envelope - Flag that indicates whether Application wraps the response in an `envelope` JSON object. Some API clients cannot access the HTTP response headers or status code. To remediate this, set envelope=true in the query. Endpoints that return a list of results use the results object as an envelope. Application adds the status parameter to the response body.
+ * @param pretty - Flag that indicates whether the response body should be in the prettyprint format.
+ */
+export const createGroupServiceAccountSecret =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: CreateGroupServiceAccountSecretInput,
+    outputSchema: CreateGroupServiceAccountSecretOutput,
+  }));

package/src/operations/createGroupStreamConnection.ts

@@ -0,0 +1,45 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const CreateGroupStreamConnectionInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    groupId: Schema.String.pipe(T.PathParam()),
+    tenantName: Schema.String.pipe(T.PathParam()),
+    envelope: Schema.optional(Schema.Boolean),
+    pretty: Schema.optional(Schema.Boolean),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/api/atlas/v2/groups/{groupId}/streams/{tenantName}/connections",
+    }),
+  );
+export type CreateGroupStreamConnectionInput =
+  typeof CreateGroupStreamConnectionInput.Type;
+
+// Output Schema
+export const CreateGroupStreamConnectionOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type CreateGroupStreamConnectionOutput =
+  typeof CreateGroupStreamConnectionOutput.Type;
+
+// The operation
+/**
+ * Create One Stream Connection
+ *
+ * Creates one connection for a stream workspace in the specified project. To use this resource, the requesting Service Account or API Key must have the Project Owner or Project Stream Processing Owner role.
+ *
+ * @param envelope - Flag that indicates whether Application wraps the response in an `envelope` JSON object. Some API clients cannot access the HTTP response headers or status code. To remediate this, set envelope=true in the query. Endpoints that return a list of results use the results object as an envelope. Application adds the status parameter to the response body.
+ * @param pretty - Flag that indicates whether the response body should be in the prettyprint format.
+ * @param groupId - Unique 24-hexadecimal digit string that identifies your project. Use the [/groups](#tag/Projects/operation/listProjects) endpoint to retrieve all projects to which the authenticated user has access.
+
+**NOTE**: Groups and projects are synonymous terms. Your group id is the same as your project id. For existing groups, your group/project id remains the same. The resource and corresponding endpoints use the term groups.
+ * @param tenantName - Label that identifies the stream workspace.
+ */
+export const createGroupStreamConnection = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: CreateGroupStreamConnectionInput,
+    outputSchema: CreateGroupStreamConnectionOutput,
+  }),
+);

package/src/operations/createGroupStreamPrivateLinkConnection.ts

@@ -0,0 +1,42 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const CreateGroupStreamPrivateLinkConnectionInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    groupId: Schema.String.pipe(T.PathParam()),
+    envelope: Schema.optional(Schema.Boolean),
+    pretty: Schema.optional(Schema.Boolean),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/api/atlas/v2/groups/{groupId}/streams/privateLinkConnections",
+    }),
+  );
+export type CreateGroupStreamPrivateLinkConnectionInput =
+  typeof CreateGroupStreamPrivateLinkConnectionInput.Type;
+
+// Output Schema
+export const CreateGroupStreamPrivateLinkConnectionOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type CreateGroupStreamPrivateLinkConnectionOutput =
+  typeof CreateGroupStreamPrivateLinkConnectionOutput.Type;
+
+// The operation
+/**
+ * Create One Private Link Connection
+ *
+ * Creates one Private Link in the specified project. To use this resource, the requesting Service Account or API Key must have the Project Owner or Project Stream Processing Owner role.
+ *
+ * @param envelope - Flag that indicates whether Application wraps the response in an `envelope` JSON object. Some API clients cannot access the HTTP response headers or status code. To remediate this, set envelope=true in the query. Endpoints that return a list of results use the results object as an envelope. Application adds the status parameter to the response body.
+ * @param pretty - Flag that indicates whether the response body should be in the prettyprint format.
+ * @param groupId - Unique 24-hexadecimal digit string that identifies your project. Use the [/groups](#tag/Projects/operation/listProjects) endpoint to retrieve all projects to which the authenticated user has access.
+
+**NOTE**: Groups and projects are synonymous terms. Your group id is the same as your project id. For existing groups, your group/project id remains the same. The resource and corresponding endpoints use the term groups.
+ */
+export const createGroupStreamPrivateLinkConnection =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: CreateGroupStreamPrivateLinkConnectionInput,
+    outputSchema: CreateGroupStreamPrivateLinkConnectionOutput,
+  }));

package/src/operations/createGroupStreamProcessor.ts

@@ -0,0 +1,45 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const CreateGroupStreamProcessorInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    groupId: Schema.String.pipe(T.PathParam()),
+    tenantName: Schema.String.pipe(T.PathParam()),
+    envelope: Schema.optional(Schema.Boolean),
+    pretty: Schema.optional(Schema.Boolean),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/api/atlas/v2/groups/{groupId}/streams/{tenantName}/processor",
+    }),
+  );
+export type CreateGroupStreamProcessorInput =
+  typeof CreateGroupStreamProcessorInput.Type;
+
+// Output Schema
+export const CreateGroupStreamProcessorOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type CreateGroupStreamProcessorOutput =
+  typeof CreateGroupStreamProcessorOutput.Type;
+
+// The operation
+/**
+ * Create One Stream Processor
+ *
+ * Create one Stream Processor within the specified stream workspace. To use this resource, the requesting Service Account or API Key must have the Project Owner role or Project Stream Processing Owner role.
+ *
+ * @param envelope - Flag that indicates whether Application wraps the response in an `envelope` JSON object. Some API clients cannot access the HTTP response headers or status code. To remediate this, set envelope=true in the query. Endpoints that return a list of results use the results object as an envelope. Application adds the status parameter to the response body.
+ * @param pretty - Flag that indicates whether the response body should be in the prettyprint format.
+ * @param groupId - Unique 24-hexadecimal digit string that identifies your project. Use the [/groups](#tag/Projects/operation/listProjects) endpoint to retrieve all projects to which the authenticated user has access.
+
+**NOTE**: Groups and projects are synonymous terms. Your group id is the same as your project id. For existing groups, your group/project id remains the same. The resource and corresponding endpoints use the term groups.
+ * @param tenantName - Label that identifies the stream workspace.
+ */
+export const createGroupStreamProcessor = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: CreateGroupStreamProcessorInput,
+    outputSchema: CreateGroupStreamProcessorOutput,
+  }),
+);

package/src/operations/createGroupStreamWorkspace.ts

@@ -0,0 +1,40 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const CreateGroupStreamWorkspaceInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    groupId: Schema.String.pipe(T.PathParam()),
+    envelope: Schema.optional(Schema.Boolean),
+    pretty: Schema.optional(Schema.Boolean),
+  }).pipe(
+    T.Http({ method: "POST", path: "/api/atlas/v2/groups/{groupId}/streams" }),
+  );
+export type CreateGroupStreamWorkspaceInput =
+  typeof CreateGroupStreamWorkspaceInput.Type;
+
+// Output Schema
+export const CreateGroupStreamWorkspaceOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type CreateGroupStreamWorkspaceOutput =
+  typeof CreateGroupStreamWorkspaceOutput.Type;
+
+// The operation
+/**
+ * Create One Stream Workspace
+ *
+ * Creates one stream workspace in the specified project. To use this resource, the requesting Service Account or API Key must have the Project Data Access Admin role, Project Owner role or Project Stream Processing Owner role.
+ *
+ * @param envelope - Flag that indicates whether Application wraps the response in an `envelope` JSON object. Some API clients cannot access the HTTP response headers or status code. To remediate this, set envelope=true in the query. Endpoints that return a list of results use the results object as an envelope. Application adds the status parameter to the response body.
+ * @param pretty - Flag that indicates whether the response body should be in the prettyprint format.
+ * @param groupId - Unique 24-hexadecimal digit string that identifies your project. Use the [/groups](#tag/Projects/operation/listProjects) endpoint to retrieve all projects to which the authenticated user has access.
+
+**NOTE**: Groups and projects are synonymous terms. Your group id is the same as your project id. For existing groups, your group/project id remains the same. The resource and corresponding endpoints use the term groups.
+ */
+export const createGroupStreamWorkspace = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: CreateGroupStreamWorkspaceInput,
+    outputSchema: CreateGroupStreamWorkspaceOutput,
+  }),
+);