@distilled.cloud/supabase 0.0.0 → 0.2.6

package/src/operations/v1DeleteABranch.ts

@@ -0,0 +1,30 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const V1DeleteABranchInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  branch_id_or_ref: Schema.String.pipe(T.PathParam()),
+  force: Schema.optional(Schema.Boolean),
+}).pipe(T.Http({ method: "DELETE", path: "/v1/branches/{branch_id_or_ref}" }));
+export type V1DeleteABranchInput = typeof V1DeleteABranchInput.Type;
+
+// Output Schema
+export const V1DeleteABranchOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  message: Schema.Literals(["ok"]),
+});
+export type V1DeleteABranchOutput = typeof V1DeleteABranchOutput.Type;
+
+// The operation
+/**
+ * Delete a database branch
+ *
+ * Deletes the specified database branch. By default, deletes immediately. Use force=false to schedule deletion with 1-hour grace period (only when soft deletion is enabled).
+ *
+ * @param branch_id_or_ref - Branch ID
+ * @param force - If set to false, schedule deletion with 1-hour grace period (only when soft deletion is enabled).
+ */
+export const v1DeleteABranch = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: V1DeleteABranchInput,
+  outputSchema: V1DeleteABranchOutput,
+}));

package/src/operations/v1DeleteAFunction.ts

@@ -0,0 +1,35 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const V1DeleteAFunctionInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
+  {
+    ref: Schema.String.pipe(T.PathParam()),
+    function_slug: Schema.String.pipe(T.PathParam()),
+  },
+).pipe(
+  T.Http({
+    method: "DELETE",
+    path: "/v1/projects/{ref}/functions/{function_slug}",
+  }),
+);
+export type V1DeleteAFunctionInput = typeof V1DeleteAFunctionInput.Type;
+
+// Output Schema
+export const V1DeleteAFunctionOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type V1DeleteAFunctionOutput = typeof V1DeleteAFunctionOutput.Type;
+
+// The operation
+/**
+ * Delete a function
+ *
+ * Deletes a function with the specified slug from the specified project.
+ *
+ * @param ref - Project ref
+ * @param function_slug - Function slug
+ */
+export const v1DeleteAFunction = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: V1DeleteAFunctionInput,
+  outputSchema: V1DeleteAFunctionOutput,
+}));

package/src/operations/v1DeleteAProject.ts

@@ -0,0 +1,30 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const V1DeleteAProjectInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  ref: Schema.String.pipe(T.PathParam()),
+}).pipe(T.Http({ method: "DELETE", path: "/v1/projects/{ref}" }));
+export type V1DeleteAProjectInput = typeof V1DeleteAProjectInput.Type;
+
+// Output Schema
+export const V1DeleteAProjectOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
+  {
+    id: Schema.Number,
+    ref: Schema.String,
+    name: Schema.String,
+  },
+);
+export type V1DeleteAProjectOutput = typeof V1DeleteAProjectOutput.Type;
+
+// The operation
+/**
+ * Deletes the given project
+ *
+ * @param ref - Project ref
+ */
+export const v1DeleteAProject = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: V1DeleteAProjectInput,
+  outputSchema: V1DeleteAProjectOutput,
+}));

package/src/operations/v1DeleteASsoProvider.ts

@@ -0,0 +1,77 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const V1DeleteASsoProviderInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    ref: Schema.String.pipe(T.PathParam()),
+    provider_id: Schema.String.pipe(T.PathParam()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      path: "/v1/projects/{ref}/config/auth/sso/providers/{provider_id}",
+    }),
+  );
+export type V1DeleteASsoProviderInput = typeof V1DeleteASsoProviderInput.Type;
+
+// Output Schema
+export const V1DeleteASsoProviderOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String,
+    saml: Schema.optional(
+      Schema.Struct({
+        id: Schema.String,
+        entity_id: Schema.String,
+        metadata_url: Schema.optional(Schema.String),
+        metadata_xml: Schema.optional(Schema.String),
+        attribute_mapping: Schema.optional(
+          Schema.Struct({
+            keys: Schema.Record(
+              Schema.String,
+              Schema.Struct({
+                name: Schema.optional(Schema.String),
+                names: Schema.optional(Schema.Array(Schema.String)),
+                default: Schema.optional(Schema.Unknown),
+                array: Schema.optional(Schema.Boolean),
+              }),
+            ),
+          }),
+        ),
+        name_id_format: Schema.optional(
+          Schema.Literals([
+            "urn:oasis:names:tc:SAML:1.1:nameid-format:unspecified",
+            "urn:oasis:names:tc:SAML:2.0:nameid-format:transient",
+            "urn:oasis:names:tc:SAML:1.1:nameid-format:emailAddress",
+            "urn:oasis:names:tc:SAML:2.0:nameid-format:persistent",
+          ]),
+        ),
+      }),
+    ),
+    domains: Schema.optional(
+      Schema.Array(
+        Schema.Struct({
+          id: Schema.String,
+          domain: Schema.optional(Schema.String),
+          created_at: Schema.optional(Schema.String),
+          updated_at: Schema.optional(Schema.String),
+        }),
+      ),
+    ),
+    created_at: Schema.optional(Schema.String),
+    updated_at: Schema.optional(Schema.String),
+  });
+export type V1DeleteASsoProviderOutput = typeof V1DeleteASsoProviderOutput.Type;
+
+// The operation
+/**
+ * Removes a SSO provider by its UUID
+ *
+ * @param ref - Project ref
+ */
+export const v1DeleteASsoProvider = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: V1DeleteASsoProviderInput,
+    outputSchema: V1DeleteASsoProviderOutput,
+  }),
+);

package/src/operations/v1DeleteHostnameConfig.ts

@@ -0,0 +1,32 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const V1DeleteHostnameConfigInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    ref: Schema.String.pipe(T.PathParam()),
+  }).pipe(
+    T.Http({ method: "DELETE", path: "/v1/projects/{ref}/custom-hostname" }),
+  );
+export type V1DeleteHostnameConfigInput =
+  typeof V1DeleteHostnameConfigInput.Type;
+
+// Output Schema
+export const V1DeleteHostnameConfigOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type V1DeleteHostnameConfigOutput =
+  typeof V1DeleteHostnameConfigOutput.Type;
+
+// The operation
+/**
+ * [Beta] Deletes a project's custom hostname configuration
+ *
+ * @param ref - Project ref
+ */
+export const v1DeleteHostnameConfig = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: V1DeleteHostnameConfigInput,
+    outputSchema: V1DeleteHostnameConfigOutput,
+  }),
+);

package/src/operations/v1DeleteJitAccess.ts

@@ -0,0 +1,34 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const V1DeleteJitAccessInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
+  {
+    ref: Schema.String.pipe(T.PathParam()),
+    user_id: Schema.String.pipe(T.PathParam()),
+  },
+).pipe(
+  T.Http({
+    method: "DELETE",
+    path: "/v1/projects/{ref}/database/jit/{user_id}",
+  }),
+);
+export type V1DeleteJitAccessInput = typeof V1DeleteJitAccessInput.Type;
+
+// Output Schema
+export const V1DeleteJitAccessOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type V1DeleteJitAccessOutput = typeof V1DeleteJitAccessOutput.Type;
+
+// The operation
+/**
+ * Delete JIT access by user-id
+ *
+ * Remove JIT mappings of a user, revoking all JIT database access
+ *
+ * @param ref - Project ref
+ */
+export const v1DeleteJitAccess = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: V1DeleteJitAccessInput,
+  outputSchema: V1DeleteJitAccessOutput,
+}));

package/src/operations/v1DeleteLoginRoles.ts

@@ -0,0 +1,30 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const V1DeleteLoginRolesInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    ref: Schema.String.pipe(T.PathParam()),
+  }).pipe(
+    T.Http({ method: "DELETE", path: "/v1/projects/{ref}/cli/login-role" }),
+  );
+export type V1DeleteLoginRolesInput = typeof V1DeleteLoginRolesInput.Type;
+
+// Output Schema
+export const V1DeleteLoginRolesOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    message: Schema.Literals(["ok"]),
+  });
+export type V1DeleteLoginRolesOutput = typeof V1DeleteLoginRolesOutput.Type;
+
+// The operation
+/**
+ * [Beta] Delete existing login roles used by CLI
+ *
+ * @param ref - Project ref
+ */
+export const v1DeleteLoginRoles = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: V1DeleteLoginRolesInput,
+  outputSchema: V1DeleteLoginRolesOutput,
+}));

package/src/operations/v1DeleteNetworkBans.ts

@@ -0,0 +1,31 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const V1DeleteNetworkBansInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    ref: Schema.String.pipe(T.PathParam()),
+    ipv4_addresses: Schema.Array(Schema.String),
+    requester_ip: Schema.optional(Schema.Boolean),
+    identifier: Schema.optional(Schema.String),
+  }).pipe(
+    T.Http({ method: "DELETE", path: "/v1/projects/{ref}/network-bans" }),
+  );
+export type V1DeleteNetworkBansInput = typeof V1DeleteNetworkBansInput.Type;
+
+// Output Schema
+export const V1DeleteNetworkBansOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type V1DeleteNetworkBansOutput = typeof V1DeleteNetworkBansOutput.Type;
+
+// The operation
+/**
+ * [Beta] Remove network bans.
+ *
+ * @param ref - Project ref
+ */
+export const v1DeleteNetworkBans = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: V1DeleteNetworkBansInput,
+  outputSchema: V1DeleteNetworkBansOutput,
+}));

package/src/operations/v1DeleteProjectApiKey.ts

@@ -0,0 +1,52 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const V1DeleteProjectApiKeyInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    ref: Schema.String.pipe(T.PathParam()),
+    id: Schema.String.pipe(T.PathParam()),
+    reveal: Schema.optional(Schema.Boolean),
+    was_compromised: Schema.optional(Schema.Boolean),
+    reason: Schema.optional(Schema.String),
+  }).pipe(
+    T.Http({ method: "DELETE", path: "/v1/projects/{ref}/api-keys/{id}" }),
+  );
+export type V1DeleteProjectApiKeyInput = typeof V1DeleteProjectApiKeyInput.Type;
+
+// Output Schema
+export const V1DeleteProjectApiKeyOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    api_key: Schema.optional(Schema.NullOr(Schema.String)),
+    id: Schema.optional(Schema.NullOr(Schema.String)),
+    type: Schema.optional(
+      Schema.NullOr(Schema.Literals(["legacy", "publishable", "secret"])),
+    ),
+    prefix: Schema.optional(Schema.NullOr(Schema.String)),
+    name: Schema.String,
+    description: Schema.optional(Schema.NullOr(Schema.String)),
+    hash: Schema.optional(Schema.NullOr(Schema.String)),
+    secret_jwt_template: Schema.optional(
+      Schema.NullOr(Schema.Record(Schema.String, Schema.Unknown)),
+    ),
+    inserted_at: Schema.optional(Schema.NullOr(Schema.String)),
+    updated_at: Schema.optional(Schema.NullOr(Schema.String)),
+  });
+export type V1DeleteProjectApiKeyOutput =
+  typeof V1DeleteProjectApiKeyOutput.Type;
+
+// The operation
+/**
+ * Deletes an API key for the project
+ *
+ * @param ref - Project ref
+ * @param reveal - Boolean string, true or false
+ * @param was_compromised - Boolean string, true or false
+ */
+export const v1DeleteProjectApiKey = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: V1DeleteProjectApiKeyInput,
+    outputSchema: V1DeleteProjectApiKeyOutput,
+  }),
+);

package/src/operations/v1DeleteProjectClaimToken.ts

@@ -0,0 +1,30 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const V1DeleteProjectClaimTokenInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    ref: Schema.String.pipe(T.PathParam()),
+  }).pipe(T.Http({ method: "DELETE", path: "/v1/projects/{ref}/claim-token" }));
+export type V1DeleteProjectClaimTokenInput =
+  typeof V1DeleteProjectClaimTokenInput.Type;
+
+// Output Schema
+export const V1DeleteProjectClaimTokenOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type V1DeleteProjectClaimTokenOutput =
+  typeof V1DeleteProjectClaimTokenOutput.Type;
+
+// The operation
+/**
+ * Revokes project claim token
+ *
+ * @param ref - Project ref
+ */
+export const v1DeleteProjectClaimToken = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: V1DeleteProjectClaimTokenInput,
+    outputSchema: V1DeleteProjectClaimTokenOutput,
+  }),
+);

package/src/operations/v1DeleteProjectTpaIntegration.ts

@@ -0,0 +1,45 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const V1DeleteProjectTpaIntegrationInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    ref: Schema.String.pipe(T.PathParam()),
+    tpa_id: Schema.String.pipe(T.PathParam()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      path: "/v1/projects/{ref}/config/auth/third-party-auth/{tpa_id}",
+    }),
+  );
+export type V1DeleteProjectTpaIntegrationInput =
+  typeof V1DeleteProjectTpaIntegrationInput.Type;
+
+// Output Schema
+export const V1DeleteProjectTpaIntegrationOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String,
+    type: Schema.String,
+    oidc_issuer_url: Schema.optional(Schema.NullOr(Schema.String)),
+    jwks_url: Schema.optional(Schema.NullOr(Schema.String)),
+    custom_jwks: Schema.optional(Schema.NullOr(Schema.Unknown)),
+    resolved_jwks: Schema.optional(Schema.NullOr(Schema.Unknown)),
+    inserted_at: Schema.String,
+    updated_at: Schema.String,
+    resolved_at: Schema.optional(Schema.NullOr(Schema.String)),
+  });
+export type V1DeleteProjectTpaIntegrationOutput =
+  typeof V1DeleteProjectTpaIntegrationOutput.Type;
+
+// The operation
+/**
+ * Removes a third-party auth integration
+ *
+ * @param ref - Project ref
+ */
+export const v1DeleteProjectTpaIntegration =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: V1DeleteProjectTpaIntegrationInput,
+    outputSchema: V1DeleteProjectTpaIntegrationOutput,
+  }));

package/src/operations/v1DeployAFunction.ts

@@ -0,0 +1,45 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const V1DeployAFunctionInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
+  {
+    ref: Schema.String.pipe(T.PathParam()),
+    slug: Schema.optional(Schema.String),
+    bundleOnly: Schema.optional(Schema.Boolean),
+  },
+).pipe(T.Http({ method: "POST", path: "/v1/projects/{ref}/functions/deploy" }));
+export type V1DeployAFunctionInput = typeof V1DeployAFunctionInput.Type;
+
+// Output Schema
+export const V1DeployAFunctionOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String,
+    slug: Schema.String,
+    name: Schema.String,
+    status: Schema.Literals(["ACTIVE", "REMOVED", "THROTTLED"]),
+    version: Schema.Number,
+    created_at: Schema.optional(Schema.Number),
+    updated_at: Schema.optional(Schema.Number),
+    verify_jwt: Schema.optional(Schema.Boolean),
+    import_map: Schema.optional(Schema.Boolean),
+    entrypoint_path: Schema.optional(Schema.String),
+    import_map_path: Schema.optional(Schema.String),
+    ezbr_sha256: Schema.optional(Schema.String),
+  });
+export type V1DeployAFunctionOutput = typeof V1DeployAFunctionOutput.Type;
+
+// The operation
+/**
+ * Deploy a function
+ *
+ * A new endpoint to deploy functions. It will create if function does not exist.
+ *
+ * @param ref - Project ref
+ * @param bundleOnly - Boolean string, true or false
+ */
+export const v1DeployAFunction = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: V1DeployAFunctionInput,
+  outputSchema: V1DeployAFunctionOutput,
+}));

package/src/operations/v1DiffABranch.ts

@@ -0,0 +1,31 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const V1DiffABranchInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  branch_id_or_ref: Schema.String.pipe(T.PathParam()),
+  included_schemas: Schema.optional(Schema.String),
+  pgdelta: Schema.optional(Schema.Boolean),
+}).pipe(
+  T.Http({ method: "GET", path: "/v1/branches/{branch_id_or_ref}/diff" }),
+);
+export type V1DiffABranchInput = typeof V1DiffABranchInput.Type;
+
+// Output Schema
+export const V1DiffABranchOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type V1DiffABranchOutput = typeof V1DiffABranchOutput.Type;
+
+// The operation
+/**
+ * [Beta] Diffs a database branch
+ *
+ * Diffs the specified database branch
+ *
+ * @param branch_id_or_ref - Branch ID
+ * @param pgdelta - Use pg-delta instead of Migra for diffing when true
+ */
+export const v1DiffABranch = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: V1DiffABranchInput,
+  outputSchema: V1DiffABranchOutput,
+}));

package/src/operations/v1DisablePreviewBranching.ts

@@ -0,0 +1,32 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const V1DisablePreviewBranchingInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    ref: Schema.String.pipe(T.PathParam()),
+  }).pipe(T.Http({ method: "DELETE", path: "/v1/projects/{ref}/branches" }));
+export type V1DisablePreviewBranchingInput =
+  typeof V1DisablePreviewBranchingInput.Type;
+
+// Output Schema
+export const V1DisablePreviewBranchingOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type V1DisablePreviewBranchingOutput =
+  typeof V1DisablePreviewBranchingOutput.Type;
+
+// The operation
+/**
+ * Disables preview branching
+ *
+ * Disables preview branching for the specified project
+ *
+ * @param ref - Project ref
+ */
+export const v1DisablePreviewBranching = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: V1DisablePreviewBranchingInput,
+    outputSchema: V1DisablePreviewBranchingOutput,
+  }),
+);

package/src/operations/v1DisableReadonlyModeTemporarily.ts

@@ -0,0 +1,34 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const V1DisableReadonlyModeTemporarilyInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    ref: Schema.String.pipe(T.PathParam()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/v1/projects/{ref}/readonly/temporary-disable",
+    }),
+  );
+export type V1DisableReadonlyModeTemporarilyInput =
+  typeof V1DisableReadonlyModeTemporarilyInput.Type;
+
+// Output Schema
+export const V1DisableReadonlyModeTemporarilyOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type V1DisableReadonlyModeTemporarilyOutput =
+  typeof V1DisableReadonlyModeTemporarilyOutput.Type;
+
+// The operation
+/**
+ * Disables project's readonly mode for the next 15 minutes
+ *
+ * @param ref - Project ref
+ */
+export const v1DisableReadonlyModeTemporarily =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: V1DisableReadonlyModeTemporarilyInput,
+    outputSchema: V1DisableReadonlyModeTemporarilyOutput,
+  }));

package/src/operations/v1EnableDatabaseWebhook.ts

@@ -0,0 +1,35 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const V1EnableDatabaseWebhookInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    ref: Schema.String.pipe(T.PathParam()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/v1/projects/{ref}/database/webhooks/enable",
+    }),
+  );
+export type V1EnableDatabaseWebhookInput =
+  typeof V1EnableDatabaseWebhookInput.Type;
+
+// Output Schema
+export const V1EnableDatabaseWebhookOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type V1EnableDatabaseWebhookOutput =
+  typeof V1EnableDatabaseWebhookOutput.Type;
+
+// The operation
+/**
+ * [Beta] Enables Database Webhooks on the project
+ *
+ * @param ref - Project ref
+ */
+export const v1EnableDatabaseWebhook = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: V1EnableDatabaseWebhookInput,
+    outputSchema: V1EnableDatabaseWebhookOutput,
+  }),
+);

package/src/operations/v1ExchangeOauthToken.ts

@@ -0,0 +1,31 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const V1ExchangeOauthTokenInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({}).pipe(
+    T.Http({ method: "POST", path: "/v1/oauth/token" }),
+  );
+export type V1ExchangeOauthTokenInput = typeof V1ExchangeOauthTokenInput.Type;
+
+// Output Schema
+export const V1ExchangeOauthTokenOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    access_token: Schema.String,
+    refresh_token: Schema.String,
+    expires_in: Schema.Number,
+    token_type: Schema.Literals(["Bearer"]),
+  });
+export type V1ExchangeOauthTokenOutput = typeof V1ExchangeOauthTokenOutput.Type;
+
+// The operation
+/**
+ * [Beta] Exchange auth code for user's access and refresh token
+ */
+export const v1ExchangeOauthToken = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: V1ExchangeOauthTokenInput,
+    outputSchema: V1ExchangeOauthTokenOutput,
+  }),
+);