@distilled.cloud/turso 0.4.0 → 0.5.1

package/src/operations/getOrganization.ts

@@ -0,0 +1,42 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const GetOrganizationInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  organizationSlug: Schema.String.pipe(T.PathParam()),
+}).pipe(
+  T.Http({ method: "GET", path: "/v1/organizations/{organizationSlug}" }),
+);
+export type GetOrganizationInput = typeof GetOrganizationInput.Type;
+
+// Output Schema
+export const GetOrganizationOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  organization: Schema.optional(
+    Schema.Struct({
+      name: Schema.optional(Schema.String),
+      slug: Schema.optional(Schema.String),
+      type: Schema.optional(Schema.Literals(["personal", "team"])),
+      overages: Schema.optional(Schema.Boolean),
+      blocked_reads: Schema.optional(Schema.Boolean),
+      blocked_writes: Schema.optional(Schema.Boolean),
+      plan_id: Schema.optional(Schema.String),
+      plan_timeline: Schema.optional(Schema.String),
+      platform: Schema.optional(Schema.String),
+    }),
+  ),
+});
+export type GetOrganizationOutput = typeof GetOrganizationOutput.Type;
+
+// The operation
+/**
+ * Retrieve Organization
+ *
+ * Retrieve details of a specific organization.
+ *
+ * @param organizationSlug - The slug of the organization or user account.
+ */
+export const getOrganization = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetOrganizationInput,
+  outputSchema: GetOrganizationOutput,
+}));

package/src/operations/getOrganizationMember.ts

@@ -0,0 +1,48 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const GetOrganizationMemberInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    organizationSlug: Schema.String.pipe(T.PathParam()),
+    username: Schema.String.pipe(T.PathParam()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      path: "/v1/organizations/{organizationSlug}/members/{username}",
+    }),
+  );
+export type GetOrganizationMemberInput = typeof GetOrganizationMemberInput.Type;
+
+// Output Schema
+export const GetOrganizationMemberOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    member: Schema.optional(
+      Schema.Struct({
+        username: Schema.optional(Schema.String),
+        role: Schema.optional(
+          Schema.Literals(["owner", "admin", "member", "viewer"]),
+        ),
+        email: Schema.optional(Schema.String),
+      }),
+    ),
+  });
+export type GetOrganizationMemberOutput =
+  typeof GetOrganizationMemberOutput.Type;
+
+// The operation
+/**
+ * Retrieve Member
+ *
+ * Retrieve details of a specific member in the organization.
+ *
+ * @param organizationSlug - The slug of the organization or user account.
+ * @param username - The username of a Turso user or organization member.
+ */
+export const getOrganizationMember = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: GetOrganizationMemberInput,
+    outputSchema: GetOrganizationMemberOutput,
+  }),
+);

package/src/operations/getOrganizationSubscription.ts

@@ -0,0 +1,46 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const GetOrganizationSubscriptionInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    organizationSlug: Schema.String.pipe(T.PathParam()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      path: "/v1/organizations/{organizationSlug}/subscription",
+    }),
+  );
+export type GetOrganizationSubscriptionInput =
+  typeof GetOrganizationSubscriptionInput.Type;
+
+// Output Schema
+export const GetOrganizationSubscriptionOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    subscription: Schema.optional(
+      Schema.Struct({
+        name: Schema.optional(Schema.String),
+        overages: Schema.optional(Schema.Boolean),
+        plan: Schema.optional(Schema.String),
+        timeline: Schema.optional(Schema.String),
+      }),
+    ),
+  });
+export type GetOrganizationSubscriptionOutput =
+  typeof GetOrganizationSubscriptionOutput.Type;
+
+// The operation
+/**
+ * Current Subscription
+ *
+ * Returns the current subscription details for the organization.
+ *
+ * @param organizationSlug - The slug of the organization or user account.
+ */
+export const getOrganizationSubscription = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: GetOrganizationSubscriptionInput,
+    outputSchema: GetOrganizationSubscriptionOutput,
+  }),
+);

package/src/operations/getOrganizationUsage.ts

@@ -0,0 +1,82 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const GetOrganizationUsageInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    organizationSlug: Schema.String.pipe(T.PathParam()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      path: "/v1/organizations/{organizationSlug}/usage",
+    }),
+  );
+export type GetOrganizationUsageInput = typeof GetOrganizationUsageInput.Type;
+
+// Output Schema
+export const GetOrganizationUsageOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    organization: Schema.optional(
+      Schema.Struct({
+        uuid: Schema.optional(Schema.String),
+        usage: Schema.optional(
+          Schema.Struct({
+            rows_read: Schema.optional(Schema.Number),
+            rows_written: Schema.optional(Schema.Number),
+            databases: Schema.optional(Schema.Number),
+            locations: Schema.optional(Schema.Number),
+            storage_bytes: Schema.optional(Schema.Number),
+            groups: Schema.optional(Schema.Number),
+            bytes_synced: Schema.optional(Schema.Number),
+          }),
+        ),
+        databases: Schema.optional(
+          Schema.Array(
+            Schema.Struct({
+              uuid: Schema.optional(Schema.String),
+              instances: Schema.optional(
+                Schema.Array(
+                  Schema.Struct({
+                    uuid: Schema.optional(Schema.String),
+                    usage: Schema.optional(
+                      Schema.Struct({
+                        rows_read: Schema.optional(Schema.Number),
+                        rows_written: Schema.optional(Schema.Number),
+                        storage_bytes: Schema.optional(Schema.Number),
+                        bytes_synced: Schema.optional(Schema.Number),
+                      }),
+                    ),
+                  }),
+                ),
+              ),
+              total: Schema.optional(
+                Schema.Struct({
+                  rows_read: Schema.optional(Schema.Number),
+                  rows_written: Schema.optional(Schema.Number),
+                  storage_bytes: Schema.optional(Schema.Number),
+                  bytes_synced: Schema.optional(Schema.Number),
+                }),
+              ),
+            }),
+          ),
+        ),
+      }),
+    ),
+  });
+export type GetOrganizationUsageOutput = typeof GetOrganizationUsageOutput.Type;
+
+// The operation
+/**
+ * Organization Usage
+ *
+ * Fetch current billing cycle usage for an organization.
+ *
+ * @param organizationSlug - The slug of the organization or user account.
+ */
+export const getOrganizationUsage = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: GetOrganizationUsageInput,
+    outputSchema: GetOrganizationUsageOutput,
+  }),
+);

package/src/operations/index.ts

@@ -1,2 +1,46 @@
-// Generated operations will be placed here by the code generator.
-// Run `bun run generate` to populate this directory.
+export * from "./listDatabases";
+export * from "./createDatabase";
+export * from "./getDatabase";
+export * from "./deleteDatabase";
+export * from "./getDatabaseConfiguration";
+export * from "./updateDatabaseConfiguration";
+export * from "./listDatabaseInstances";
+export * from "./getDatabaseInstance";
+export * from "./createDatabaseToken";
+export * from "./getDatabaseUsage";
+export * from "./getDatabaseStats";
+export * from "./invalidateDatabaseTokens";
+export * from "./listGroups";
+export * from "./createGroup";
+export * from "./getGroup";
+export * from "./deleteGroup";
+export * from "./getGroupConfiguration";
+export * from "./updateGroupConfiguration";
+export * from "./transferGroup";
+export * from "./unarchiveGroup";
+export * from "./addLocationToGroup";
+export * from "./removeLocationFromGroup";
+export * from "./updateGroupDatabases";
+export * from "./createGroupToken";
+export * from "./invalidateGroupTokens";
+export * from "./listLocations";
+export * from "./listOrganizations";
+export * from "./getOrganization";
+export * from "./updateOrganization";
+export * from "./listOrganizationPlans";
+export * from "./listOrganizationInvoices";
+export * from "./getOrganizationSubscription";
+export * from "./getOrganizationUsage";
+export * from "./listOrganizationMembers";
+export * from "./addOrganizationMember";
+export * from "./getOrganizationMember";
+export * from "./updateMemberRole";
+export * from "./removeOrganizationMember";
+export * from "./listOrganizationInvites";
+export * from "./inviteOrganizationMember";
+export * from "./deleteOrganizationInviteByEmail";
+export * from "./validateAPIToken";
+export * from "./listAPITokens";
+export * from "./createAPIToken";
+export * from "./revokeAPIToken";
+export * from "./listOrganizationAuditLogs";

package/src/operations/invalidateDatabaseTokens.ts

@@ -0,0 +1,39 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const InvalidateDatabaseTokensInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    organizationSlug: Schema.String.pipe(T.PathParam()),
+    databaseName: Schema.String.pipe(T.PathParam()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/v1/organizations/{organizationSlug}/databases/{databaseName}/auth/rotate",
+    }),
+  );
+export type InvalidateDatabaseTokensInput =
+  typeof InvalidateDatabaseTokensInput.Type;
+
+// Output Schema
+export const InvalidateDatabaseTokensOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type InvalidateDatabaseTokensOutput =
+  typeof InvalidateDatabaseTokensOutput.Type;
+
+// The operation
+/**
+ * Invalidate All Database Auth Tokens
+ *
+ * Invalidates all authorization tokens for the specified database.
+ *
+ * @param organizationSlug - The slug of the organization or user account.
+ * @param databaseName - The name of the database.
+ */
+export const invalidateDatabaseTokens = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: InvalidateDatabaseTokensInput,
+    outputSchema: InvalidateDatabaseTokensOutput,
+  }),
+);

package/src/operations/invalidateGroupTokens.ts

@@ -0,0 +1,38 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const InvalidateGroupTokensInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    organizationSlug: Schema.String.pipe(T.PathParam()),
+    groupName: Schema.String.pipe(T.PathParam()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/v1/organizations/{organizationSlug}/groups/{groupName}/auth/rotate",
+    }),
+  );
+export type InvalidateGroupTokensInput = typeof InvalidateGroupTokensInput.Type;
+
+// Output Schema
+export const InvalidateGroupTokensOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type InvalidateGroupTokensOutput =
+  typeof InvalidateGroupTokensOutput.Type;
+
+// The operation
+/**
+ * Invalidate All Group Auth Tokens
+ *
+ * Invalidates all authorization tokens for the specified group.
+ *
+ * @param organizationSlug - The slug of the organization or user account.
+ * @param groupName - The name of the group.
+ */
+export const invalidateGroupTokens = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: InvalidateGroupTokensInput,
+    outputSchema: InvalidateGroupTokensOutput,
+  }),
+);

package/src/operations/inviteOrganizationMember.ts

@@ -0,0 +1,66 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const InviteOrganizationMemberInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    organizationSlug: Schema.String.pipe(T.PathParam()),
+    email: Schema.String,
+    role: Schema.optional(Schema.Literals(["admin", "member", "viewer"])),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/v1/organizations/{organizationSlug}/invites",
+    }),
+  );
+export type InviteOrganizationMemberInput =
+  typeof InviteOrganizationMemberInput.Type;
+
+// Output Schema
+export const InviteOrganizationMemberOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    invited: Schema.optional(
+      Schema.Struct({
+        ID: Schema.optional(Schema.Number),
+        CreatedAt: Schema.optional(Schema.String),
+        UpdatedAt: Schema.optional(Schema.String),
+        DeletedAt: Schema.optional(Schema.String),
+        Role: Schema.optional(Schema.Literals(["admin", "member", "viewer"])),
+        Email: Schema.optional(Schema.String),
+        OrganizationID: Schema.optional(Schema.Number),
+        Token: Schema.optional(Schema.String),
+        Organization: Schema.optional(
+          Schema.Struct({
+            name: Schema.optional(Schema.String),
+            slug: Schema.optional(Schema.String),
+            type: Schema.optional(Schema.Literals(["personal", "team"])),
+            overages: Schema.optional(Schema.Boolean),
+            blocked_reads: Schema.optional(Schema.Boolean),
+            blocked_writes: Schema.optional(Schema.Boolean),
+            plan_id: Schema.optional(Schema.String),
+            plan_timeline: Schema.optional(Schema.String),
+            platform: Schema.optional(Schema.String),
+          }),
+        ),
+        Accepted: Schema.optional(Schema.Boolean),
+      }),
+    ),
+  });
+export type InviteOrganizationMemberOutput =
+  typeof InviteOrganizationMemberOutput.Type;
+
+// The operation
+/**
+ * Invite Organization Member
+ *
+ * Invite a user (who isn't already a Turso user) to an organization.
+ *
+ * @param organizationSlug - The slug of the organization or user account.
+ */
+export const inviteOrganizationMember = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: InviteOrganizationMemberInput,
+    outputSchema: InviteOrganizationMemberOutput,
+  }),
+);

package/src/operations/listAPITokens.ts

@@ -0,0 +1,33 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const ListAPITokensInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
+  {},
+).pipe(T.Http({ method: "GET", path: "/v1/auth/api-tokens" }));
+export type ListAPITokensInput = typeof ListAPITokensInput.Type;
+
+// Output Schema
+export const ListAPITokensOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  tokens: Schema.optional(
+    Schema.Array(
+      Schema.Struct({
+        name: Schema.optional(Schema.String),
+        id: Schema.optional(Schema.String),
+      }),
+    ),
+  ),
+});
+export type ListAPITokensOutput = typeof ListAPITokensOutput.Type;
+
+// The operation
+/**
+ * List API Tokens
+ *
+ * Returns a list of API tokens belonging to a user.
+ */
+export const listAPITokens = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: ListAPITokensInput,
+  outputSchema: ListAPITokensOutput,
+}));

package/src/operations/listDatabaseInstances.ts

@@ -0,0 +1,50 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const ListDatabaseInstancesInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    organizationSlug: Schema.String.pipe(T.PathParam()),
+    databaseName: Schema.String.pipe(T.PathParam()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      path: "/v1/organizations/{organizationSlug}/databases/{databaseName}/instances",
+    }),
+  );
+export type ListDatabaseInstancesInput = typeof ListDatabaseInstancesInput.Type;
+
+// Output Schema
+export const ListDatabaseInstancesOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    instances: Schema.optional(
+      Schema.Array(
+        Schema.Struct({
+          uuid: Schema.optional(Schema.String),
+          name: Schema.optional(Schema.String),
+          type: Schema.optional(Schema.Literals(["primary", "replica"])),
+          region: Schema.optional(Schema.String),
+          hostname: Schema.optional(Schema.String),
+        }),
+      ),
+    ),
+  });
+export type ListDatabaseInstancesOutput =
+  typeof ListDatabaseInstancesOutput.Type;
+
+// The operation
+/**
+ * List Database Instances
+ *
+ * Returns a list of instances of a database. Instances are the individual primary or replica databases in each region defined by the group.
+ *
+ * @param organizationSlug - The slug of the organization or user account.
+ * @param databaseName - The name of the database.
+ */
+export const listDatabaseInstances = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: ListDatabaseInstancesInput,
+    outputSchema: ListDatabaseInstancesOutput,
+  }),
+);

package/src/operations/listDatabases.ts

@@ -0,0 +1,62 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const ListDatabasesInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  organizationSlug: Schema.String.pipe(T.PathParam()),
+  group: Schema.optional(Schema.String),
+  schema: Schema.optional(Schema.String),
+  parent: Schema.optional(Schema.String),
+}).pipe(
+  T.Http({
+    method: "GET",
+    path: "/v1/organizations/{organizationSlug}/databases",
+  }),
+);
+export type ListDatabasesInput = typeof ListDatabasesInput.Type;
+
+// Output Schema
+export const ListDatabasesOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  databases: Schema.optional(
+    Schema.Array(
+      Schema.Struct({
+        Name: Schema.optional(Schema.String),
+        DbId: Schema.optional(Schema.String),
+        Hostname: Schema.optional(Schema.String),
+        block_reads: Schema.optional(Schema.Boolean),
+        block_writes: Schema.optional(Schema.Boolean),
+        regions: Schema.optional(Schema.Array(Schema.String)),
+        primaryRegion: Schema.optional(Schema.String),
+        group: Schema.optional(Schema.String),
+        delete_protection: Schema.optional(Schema.Boolean),
+        parent: Schema.optional(
+          Schema.NullOr(
+            Schema.Struct({
+              id: Schema.optional(Schema.String),
+              name: Schema.optional(Schema.String),
+              branched_at: Schema.optional(Schema.String),
+            }),
+          ),
+        ),
+      }),
+    ),
+  ),
+});
+export type ListDatabasesOutput = typeof ListDatabasesOutput.Type;
+
+// The operation
+/**
+ * List Databases
+ *
+ * Returns a list of databases belonging to the organization or user.
+ *
+ * @param organizationSlug - The slug of the organization or user account.
+ * @param group - Filter databases by group name.
+ * @param schema - The schema database name that can be used to get databases that belong to that parent schema.
+ * @param parent - Filter database branches by using their parent database ID.
+ */
+export const listDatabases = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: ListDatabasesInput,
+  outputSchema: ListDatabasesOutput,
+}));

package/src/operations/listGroups.ts

@@ -0,0 +1,44 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const ListGroupsInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  organizationSlug: Schema.String.pipe(T.PathParam()),
+}).pipe(
+  T.Http({
+    method: "GET",
+    path: "/v1/organizations/{organizationSlug}/groups",
+  }),
+);
+export type ListGroupsInput = typeof ListGroupsInput.Type;
+
+// Output Schema
+export const ListGroupsOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  groups: Schema.optional(
+    Schema.Array(
+      Schema.Struct({
+        name: Schema.optional(Schema.String),
+        version: Schema.optional(Schema.String),
+        uuid: Schema.optional(Schema.String),
+        locations: Schema.optional(Schema.Array(Schema.String)),
+        primary: Schema.optional(Schema.String),
+        delete_protection: Schema.optional(Schema.Boolean),
+      }),
+    ),
+  ),
+});
+export type ListGroupsOutput = typeof ListGroupsOutput.Type;
+
+// The operation
+/**
+ * List Groups
+ *
+ * Returns a list of groups belonging to the organization or user.
+ *
+ * @param organizationSlug - The slug of the organization or user account.
+ */
+export const listGroups = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: ListGroupsInput,
+  outputSchema: ListGroupsOutput,
+}));

package/src/operations/listLocations.ts

@@ -0,0 +1,26 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const ListLocationsInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
+  {},
+).pipe(T.Http({ method: "GET", path: "/v1/locations" }));
+export type ListLocationsInput = typeof ListLocationsInput.Type;
+
+// Output Schema
+export const ListLocationsOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  locations: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+});
+export type ListLocationsOutput = typeof ListLocationsOutput.Type;
+
+// The operation
+/**
+ * List Locations
+ *
+ * Returns a list of locations where you can create or replicate databases.
+ */
+export const listLocations = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: ListLocationsInput,
+  outputSchema: ListLocationsOutput,
+}));