@distilled.cloud/axiom 0.0.0 → 0.13.0

package/src/operations/v2/deleteAnnotation.ts

@@ -0,0 +1,26 @@
+import * as Schema from "effect/Schema";
+import { API } from "../../client";
+import * as T from "../../traits";
+import { BadRequest, NotFound } from "../../errors";
+
+// Input Schema
+export const DeleteAnnotationInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  id: Schema.String.pipe(T.PathParam()),
+}).pipe(T.Http({ method: "DELETE", path: "/v2/annotations/{id}" }));
+export type DeleteAnnotationInput = typeof DeleteAnnotationInput.Type;
+
+// Output Schema
+export const DeleteAnnotationOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type DeleteAnnotationOutput = typeof DeleteAnnotationOutput.Type;
+
+// The operation
+/**
+ * Delete annotation
+ *
+ * @param id - Unique ID of the annotation
+ */
+export const deleteAnnotation = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: DeleteAnnotationInput,
+  outputSchema: DeleteAnnotationOutput,
+  errors: [BadRequest, NotFound] as const,
+}));

package/src/operations/v2/deleteDashboard.ts

@@ -0,0 +1,26 @@
+import * as Schema from "effect/Schema";
+import { API } from "../../client";
+import * as T from "../../traits";
+import { NotFound } from "../../errors";
+
+// Input Schema
+export const DeleteDashboardInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  uid: Schema.String.pipe(T.PathParam()),
+}).pipe(T.Http({ method: "DELETE", path: "/v2/dashboards/uid/{uid}" }));
+export type DeleteDashboardInput = typeof DeleteDashboardInput.Type;
+
+// Output Schema
+export const DeleteDashboardOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type DeleteDashboardOutput = typeof DeleteDashboardOutput.Type;
+
+// The operation
+/**
+ * Delete dashboard
+ *
+ * Delete a dashboard by UID.
+ */
+export const deleteDashboard = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: DeleteDashboardInput,
+  outputSchema: DeleteDashboardOutput,
+  errors: [NotFound] as const,
+}));

package/src/operations/v2/deleteDataset.ts

@@ -0,0 +1,24 @@
+import * as Schema from "effect/Schema";
+import { API } from "../../client";
+import * as T from "../../traits";
+import { Forbidden, NotFound } from "../../errors";
+
+// Input Schema
+export const DeleteDatasetInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  dataset_id: Schema.String.pipe(T.PathParam()),
+}).pipe(T.Http({ method: "DELETE", path: "/v2/datasets/{dataset_id}" }));
+export type DeleteDatasetInput = typeof DeleteDatasetInput.Type;
+
+// Output Schema
+export const DeleteDatasetOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type DeleteDatasetOutput = typeof DeleteDatasetOutput.Type;
+
+// The operation
+/**
+ * Delete dataset
+ */
+export const deleteDataset = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: DeleteDatasetInput,
+  outputSchema: DeleteDatasetOutput,
+  errors: [Forbidden, NotFound] as const,
+}));

package/src/operations/v2/deleteGroup.ts

@@ -0,0 +1,28 @@
+import * as Schema from "effect/Schema";
+import { API } from "../../client";
+import * as T from "../../traits";
+import { NotFound } from "../../errors";
+
+// Input Schema
+export const DeleteGroupInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  id: Schema.String.pipe(T.PathParam()),
+}).pipe(T.Http({ method: "DELETE", path: "/v2/rbac/groups/{id}" }));
+export type DeleteGroupInput = typeof DeleteGroupInput.Type;
+
+// Output Schema
+export const DeleteGroupOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type DeleteGroupOutput = typeof DeleteGroupOutput.Type;
+
+// The operation
+/**
+ * Delete group
+ *
+ * Permanently removes a group from the organization.
+ *
+ * @param id - Unique identifier of the group to delete
+ */
+export const deleteGroup = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: DeleteGroupInput,
+  outputSchema: DeleteGroupOutput,
+  errors: [NotFound] as const,
+}));

package/src/operations/v2/deleteMapField.ts

@@ -0,0 +1,27 @@
+import * as Schema from "effect/Schema";
+import { API } from "../../client";
+import * as T from "../../traits";
+import { NotFound } from "../../errors";
+
+// Input Schema
+export const DeleteMapFieldInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  dataset_id: Schema.String.pipe(T.PathParam()),
+  map_field_name: Schema.String.pipe(T.PathParam()),
+}).pipe(
+  T.Http({
+    method: "DELETE",
+    path: "/v2/datasets/{dataset_id}/mapfields/{map_field_name}",
+  }),
+);
+export type DeleteMapFieldInput = typeof DeleteMapFieldInput.Type;
+
+// Output Schema
+export const DeleteMapFieldOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type DeleteMapFieldOutput = typeof DeleteMapFieldOutput.Type;
+
+// The operation
+export const deleteMapField = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: DeleteMapFieldInput,
+  outputSchema: DeleteMapFieldOutput,
+  errors: [NotFound] as const,
+}));

package/src/operations/v2/deleteMonitor.ts

@@ -0,0 +1,24 @@
+import * as Schema from "effect/Schema";
+import { API } from "../../client";
+import * as T from "../../traits";
+import { NotFound } from "../../errors";
+
+// Input Schema
+export const DeleteMonitorInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  id: Schema.String.pipe(T.PathParam()),
+}).pipe(T.Http({ method: "DELETE", path: "/v2/monitors/{id}" }));
+export type DeleteMonitorInput = typeof DeleteMonitorInput.Type;
+
+// Output Schema
+export const DeleteMonitorOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type DeleteMonitorOutput = typeof DeleteMonitorOutput.Type;
+
+// The operation
+/**
+ * Delete monitor
+ */
+export const deleteMonitor = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: DeleteMonitorInput,
+  outputSchema: DeleteMonitorOutput,
+  errors: [NotFound] as const,
+}));

package/src/operations/v2/deleteNotifier.ts

@@ -0,0 +1,24 @@
+import * as Schema from "effect/Schema";
+import { API } from "../../client";
+import * as T from "../../traits";
+import { NotFound } from "../../errors";
+
+// Input Schema
+export const DeleteNotifierInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  id: Schema.String.pipe(T.PathParam()),
+}).pipe(T.Http({ method: "DELETE", path: "/v2/notifiers/{id}" }));
+export type DeleteNotifierInput = typeof DeleteNotifierInput.Type;
+
+// Output Schema
+export const DeleteNotifierOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type DeleteNotifierOutput = typeof DeleteNotifierOutput.Type;
+
+// The operation
+/**
+ * Delete notifier
+ */
+export const deleteNotifier = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: DeleteNotifierInput,
+  outputSchema: DeleteNotifierOutput,
+  errors: [NotFound] as const,
+}));

package/src/operations/v2/deleteRole.ts

@@ -0,0 +1,28 @@
+import * as Schema from "effect/Schema";
+import { API } from "../../client";
+import * as T from "../../traits";
+import { NotFound } from "../../errors";
+
+// Input Schema
+export const DeleteRoleInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  id: Schema.String.pipe(T.PathParam()),
+}).pipe(T.Http({ method: "DELETE", path: "/v2/rbac/roles/{id}" }));
+export type DeleteRoleInput = typeof DeleteRoleInput.Type;
+
+// Output Schema
+export const DeleteRoleOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type DeleteRoleOutput = typeof DeleteRoleOutput.Type;
+
+// The operation
+/**
+ * Delete role
+ *
+ * Permanently removes a role from the organization.
+ *
+ * @param id - Unique identifier of the role to delete
+ */
+export const deleteRole = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: DeleteRoleInput,
+  outputSchema: DeleteRoleOutput,
+  errors: [NotFound] as const,
+}));

package/src/operations/v2/deleteStarred.ts

@@ -0,0 +1,21 @@
+import * as Schema from "effect/Schema";
+import { API } from "../../client";
+import * as T from "../../traits";
+import { NotFound } from "../../errors";
+
+// Input Schema
+export const DeleteStarredInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  id: Schema.String.pipe(T.PathParam()),
+}).pipe(T.Http({ method: "DELETE", path: "/v2/apl-starred-queries/{id}" }));
+export type DeleteStarredInput = typeof DeleteStarredInput.Type;
+
+// Output Schema
+export const DeleteStarredOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type DeleteStarredOutput = typeof DeleteStarredOutput.Type;
+
+// The operation
+export const deleteStarred = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: DeleteStarredInput,
+  outputSchema: DeleteStarredOutput,
+  errors: [NotFound] as const,
+}));

package/src/operations/v2/deleteView.ts

@@ -0,0 +1,21 @@
+import * as Schema from "effect/Schema";
+import { API } from "../../client";
+import * as T from "../../traits";
+import { NotFound } from "../../errors";
+
+// Input Schema
+export const DeleteViewInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  id: Schema.String.pipe(T.PathParam()),
+}).pipe(T.Http({ method: "DELETE", path: "/v2/views/{id}" }));
+export type DeleteViewInput = typeof DeleteViewInput.Type;
+
+// Output Schema
+export const DeleteViewOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type DeleteViewOutput = typeof DeleteViewOutput.Type;
+
+// The operation
+export const deleteView = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: DeleteViewInput,
+  outputSchema: DeleteViewOutput,
+  errors: [NotFound] as const,
+}));

package/src/operations/v2/deleteVirtualField.ts

@@ -0,0 +1,22 @@
+import * as Schema from "effect/Schema";
+import { API } from "../../client";
+import * as T from "../../traits";
+import { NotFound } from "../../errors";
+
+// Input Schema
+export const DeleteVirtualFieldInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String.pipe(T.PathParam()),
+  }).pipe(T.Http({ method: "DELETE", path: "/v2/vfields/{id}" }));
+export type DeleteVirtualFieldInput = typeof DeleteVirtualFieldInput.Type;
+
+// Output Schema
+export const DeleteVirtualFieldOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type DeleteVirtualFieldOutput = typeof DeleteVirtualFieldOutput.Type;
+
+// The operation
+export const deleteVirtualField = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: DeleteVirtualFieldInput,
+  outputSchema: DeleteVirtualFieldOutput,
+  errors: [NotFound] as const,
+}));

package/src/operations/v2/getAPIToken.ts

@@ -0,0 +1,103 @@
+import * as Schema from "effect/Schema";
+import { API } from "../../client";
+import * as T from "../../traits";
+import { NotFound } from "../../errors";
+
+// Input Schema
+export const GetAPITokenInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  id: Schema.String.pipe(T.PathParam()),
+}).pipe(T.Http({ method: "GET", path: "/v2/tokens/{id}" }));
+export type GetAPITokenInput = typeof GetAPITokenInput.Type;
+
+// Output Schema
+export const GetAPITokenOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  datasetCapabilities: Schema.Record(
+    Schema.String,
+    Schema.Struct({
+      data: Schema.optional(Schema.Array(Schema.Literals(["delete"]))),
+      ingest: Schema.optional(Schema.Array(Schema.Literals(["create"]))),
+      query: Schema.optional(Schema.Array(Schema.Literals(["read"]))),
+      share: Schema.optional(
+        Schema.Array(Schema.Literals(["create", "read", "delete"])),
+      ),
+      starredQueries: Schema.optional(
+        Schema.Array(Schema.Literals(["create", "read", "update", "delete"])),
+      ),
+      trim: Schema.optional(Schema.Array(Schema.Literals(["update"]))),
+      vacuum: Schema.optional(Schema.Array(Schema.Literals(["update"]))),
+      virtualFields: Schema.optional(
+        Schema.Array(Schema.Literals(["create", "read", "update", "delete"])),
+      ),
+    }),
+  ),
+  description: Schema.optional(Schema.String),
+  expiresAt: Schema.optional(Schema.NullOr(Schema.String)),
+  id: Schema.String,
+  name: Schema.String,
+  orgCapabilities: Schema.Struct({
+    annotations: Schema.optional(
+      Schema.Array(Schema.Literals(["create", "read", "update", "delete"])),
+    ),
+    apiTokens: Schema.optional(
+      Schema.Array(Schema.Literals(["create", "read", "update", "delete"])),
+    ),
+    auditLog: Schema.optional(Schema.Array(Schema.Literals(["read"]))),
+    billing: Schema.optional(Schema.Array(Schema.Literals(["read", "update"]))),
+    dashboards: Schema.optional(
+      Schema.Array(Schema.Literals(["create", "read", "update", "delete"])),
+    ),
+    datasets: Schema.optional(
+      Schema.Array(Schema.Literals(["create", "read", "update", "delete"])),
+    ),
+    endpoints: Schema.optional(
+      Schema.Array(Schema.Literals(["create", "read", "update", "delete"])),
+    ),
+    flows: Schema.optional(
+      Schema.Array(Schema.Literals(["create", "read", "update", "delete"])),
+    ),
+    integrations: Schema.optional(
+      Schema.Array(Schema.Literals(["create", "read", "update", "delete"])),
+    ),
+    monitors: Schema.optional(
+      Schema.Array(Schema.Literals(["create", "read", "update", "delete"])),
+    ),
+    notifiers: Schema.optional(
+      Schema.Array(Schema.Literals(["create", "read", "update", "delete"])),
+    ),
+    rbac: Schema.optional(
+      Schema.Array(Schema.Literals(["create", "read", "update", "delete"])),
+    ),
+    sharedAccessKeys: Schema.optional(
+      Schema.Array(Schema.Literals(["read", "update"])),
+    ),
+    users: Schema.optional(
+      Schema.Array(Schema.Literals(["create", "read", "update", "delete"])),
+    ),
+    views: Schema.optional(
+      Schema.Array(Schema.Literals(["create", "read", "update", "delete"])),
+    ),
+  }),
+  samlAuthenticated: Schema.optional(Schema.Boolean),
+  viewCapabilities: Schema.optional(
+    Schema.Record(
+      Schema.String,
+      Schema.Struct({
+        query: Schema.optional(Schema.Array(Schema.Literals(["read"]))),
+        share: Schema.optional(
+          Schema.Array(Schema.Literals(["create", "read", "delete"])),
+        ),
+      }),
+    ),
+  ),
+});
+export type GetAPITokenOutput = typeof GetAPITokenOutput.Type;
+
+// The operation
+/**
+ * Get API token by ID
+ */
+export const getAPIToken = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetAPITokenInput,
+  outputSchema: GetAPITokenOutput,
+  errors: [NotFound] as const,
+}));

package/src/operations/v2/getAPITokens.ts

@@ -0,0 +1,105 @@
+import * as Schema from "effect/Schema";
+import { API } from "../../client";
+import * as T from "../../traits";
+
+// Input Schema
+export const GetAPITokensInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
+  {},
+).pipe(T.Http({ method: "GET", path: "/v2/tokens" }));
+export type GetAPITokensInput = typeof GetAPITokensInput.Type;
+
+// Output Schema
+export const GetAPITokensOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
+  Schema.Struct({
+    datasetCapabilities: Schema.Record(
+      Schema.String,
+      Schema.Struct({
+        data: Schema.optional(Schema.Array(Schema.Literals(["delete"]))),
+        ingest: Schema.optional(Schema.Array(Schema.Literals(["create"]))),
+        query: Schema.optional(Schema.Array(Schema.Literals(["read"]))),
+        share: Schema.optional(
+          Schema.Array(Schema.Literals(["create", "read", "delete"])),
+        ),
+        starredQueries: Schema.optional(
+          Schema.Array(Schema.Literals(["create", "read", "update", "delete"])),
+        ),
+        trim: Schema.optional(Schema.Array(Schema.Literals(["update"]))),
+        vacuum: Schema.optional(Schema.Array(Schema.Literals(["update"]))),
+        virtualFields: Schema.optional(
+          Schema.Array(Schema.Literals(["create", "read", "update", "delete"])),
+        ),
+      }),
+    ),
+    description: Schema.optional(Schema.String),
+    expiresAt: Schema.optional(Schema.NullOr(Schema.String)),
+    id: Schema.String,
+    name: Schema.String,
+    orgCapabilities: Schema.Struct({
+      annotations: Schema.optional(
+        Schema.Array(Schema.Literals(["create", "read", "update", "delete"])),
+      ),
+      apiTokens: Schema.optional(
+        Schema.Array(Schema.Literals(["create", "read", "update", "delete"])),
+      ),
+      auditLog: Schema.optional(Schema.Array(Schema.Literals(["read"]))),
+      billing: Schema.optional(
+        Schema.Array(Schema.Literals(["read", "update"])),
+      ),
+      dashboards: Schema.optional(
+        Schema.Array(Schema.Literals(["create", "read", "update", "delete"])),
+      ),
+      datasets: Schema.optional(
+        Schema.Array(Schema.Literals(["create", "read", "update", "delete"])),
+      ),
+      endpoints: Schema.optional(
+        Schema.Array(Schema.Literals(["create", "read", "update", "delete"])),
+      ),
+      flows: Schema.optional(
+        Schema.Array(Schema.Literals(["create", "read", "update", "delete"])),
+      ),
+      integrations: Schema.optional(
+        Schema.Array(Schema.Literals(["create", "read", "update", "delete"])),
+      ),
+      monitors: Schema.optional(
+        Schema.Array(Schema.Literals(["create", "read", "update", "delete"])),
+      ),
+      notifiers: Schema.optional(
+        Schema.Array(Schema.Literals(["create", "read", "update", "delete"])),
+      ),
+      rbac: Schema.optional(
+        Schema.Array(Schema.Literals(["create", "read", "update", "delete"])),
+      ),
+      sharedAccessKeys: Schema.optional(
+        Schema.Array(Schema.Literals(["read", "update"])),
+      ),
+      users: Schema.optional(
+        Schema.Array(Schema.Literals(["create", "read", "update", "delete"])),
+      ),
+      views: Schema.optional(
+        Schema.Array(Schema.Literals(["create", "read", "update", "delete"])),
+      ),
+    }),
+    samlAuthenticated: Schema.optional(Schema.Boolean),
+    viewCapabilities: Schema.optional(
+      Schema.Record(
+        Schema.String,
+        Schema.Struct({
+          query: Schema.optional(Schema.Array(Schema.Literals(["read"]))),
+          share: Schema.optional(
+            Schema.Array(Schema.Literals(["create", "read", "delete"])),
+          ),
+        }),
+      ),
+    ),
+  }),
+);
+export type GetAPITokensOutput = typeof GetAPITokensOutput.Type;
+
+// The operation
+/**
+ * Get API tokens
+ */
+export const getAPITokens = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetAPITokensInput,
+  outputSchema: GetAPITokensOutput,
+}));

package/src/operations/v2/getAnnotation.ts

@@ -0,0 +1,35 @@
+import * as Schema from "effect/Schema";
+import { API } from "../../client";
+import * as T from "../../traits";
+import { BadRequest, NotFound } from "../../errors";
+
+// Input Schema
+export const GetAnnotationInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  id: Schema.String.pipe(T.PathParam()),
+}).pipe(T.Http({ method: "GET", path: "/v2/annotations/{id}" }));
+export type GetAnnotationInput = typeof GetAnnotationInput.Type;
+
+// Output Schema
+export const GetAnnotationOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  datasets: Schema.Array(Schema.String),
+  description: Schema.optional(Schema.String),
+  endTime: Schema.optional(Schema.NullOr(Schema.String)),
+  id: Schema.String,
+  time: Schema.String,
+  title: Schema.optional(Schema.String),
+  type: Schema.String,
+  url: Schema.optional(Schema.String),
+});
+export type GetAnnotationOutput = typeof GetAnnotationOutput.Type;
+
+// The operation
+/**
+ * Get annotation by ID
+ *
+ * @param id - Unique ID of the annotation
+ */
+export const getAnnotation = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetAnnotationInput,
+  outputSchema: GetAnnotationOutput,
+  errors: [BadRequest, NotFound] as const,
+}));

package/src/operations/v2/getAnnotations.ts

@@ -0,0 +1,39 @@
+import * as Schema from "effect/Schema";
+import { API } from "../../client";
+import * as T from "../../traits";
+
+// Input Schema
+export const GetAnnotationsInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  datasets: Schema.optional(Schema.String),
+  start: Schema.optional(Schema.String),
+  end: Schema.optional(Schema.String),
+}).pipe(T.Http({ method: "GET", path: "/v2/annotations" }));
+export type GetAnnotationsInput = typeof GetAnnotationsInput.Type;
+
+// Output Schema
+export const GetAnnotationsOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
+  Schema.Struct({
+    datasets: Schema.Array(Schema.String),
+    description: Schema.optional(Schema.String),
+    endTime: Schema.optional(Schema.NullOr(Schema.String)),
+    id: Schema.String,
+    time: Schema.String,
+    title: Schema.optional(Schema.String),
+    type: Schema.String,
+    url: Schema.optional(Schema.String),
+  }),
+);
+export type GetAnnotationsOutput = typeof GetAnnotationsOutput.Type;
+
+// The operation
+/**
+ * Get annotations
+ *
+ * @param datasets - Optional: Filter for dataset names.
+ * @param start - Optional: Filter for events after this date. Use RFC3339 time format.
+ * @param end - Optional: Filter for events before this date. Use RFC3339 time format.
+ */
+export const getAnnotations = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetAnnotationsInput,
+  outputSchema: GetAnnotationsOutput,
+}));

package/src/operations/v2/getCurrentUser.ts

@@ -0,0 +1,32 @@
+import * as Schema from "effect/Schema";
+import { API } from "../../client";
+import * as T from "../../traits";
+
+// Input Schema
+export const GetCurrentUserInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
+  {},
+).pipe(T.Http({ method: "GET", path: "/v2/user" }));
+export type GetCurrentUserInput = typeof GetCurrentUserInput.Type;
+
+// Output Schema
+export const GetCurrentUserOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  email: Schema.String,
+  id: Schema.String,
+  name: Schema.String,
+  role: Schema.optional(
+    Schema.Struct({
+      id: Schema.String,
+      name: Schema.String,
+    }),
+  ),
+});
+export type GetCurrentUserOutput = typeof GetCurrentUserOutput.Type;
+
+// The operation
+/**
+ * Get current user
+ */
+export const getCurrentUser = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetCurrentUserInput,
+  outputSchema: GetCurrentUserOutput,
+}));