@distilled.cloud/axiom 0.0.0 → 0.12.7

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,
+}));

package/src/operations/v2/getDashboard.ts

@@ -0,0 +1,77 @@
+import * as Schema from "effect/Schema";
+import { API } from "../../client";
+import * as T from "../../traits";
+import { NotFound } from "../../errors";
+
+// Input Schema
+export const GetDashboardInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  uid: Schema.String.pipe(T.PathParam()),
+}).pipe(T.Http({ method: "GET", path: "/v2/dashboards/uid/{uid}" }));
+export type GetDashboardInput = typeof GetDashboardInput.Type;
+
+// Output Schema
+export const GetDashboardOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  createdAt: Schema.String,
+  createdBy: Schema.String,
+  dashboard: Schema.Struct({
+    name: Schema.String,
+    owner: Schema.String,
+    description: Schema.optional(Schema.String),
+    charts: Schema.Array(Schema.Unknown),
+    layout: Schema.Array(
+      Schema.Struct({
+        i: Schema.String,
+        x: Schema.Number,
+        y: Schema.NullOr(Schema.Number),
+        w: Schema.Number,
+        h: Schema.Number,
+        minW: Schema.optional(Schema.Number),
+        minH: Schema.optional(Schema.Number),
+        maxW: Schema.optional(Schema.Number),
+        maxH: Schema.optional(Schema.Number),
+        static: Schema.optional(Schema.Boolean),
+      }),
+    ),
+    refreshTime: Schema.Literals([15, 60, 300]),
+    schemaVersion: Schema.Literals([2]),
+    against: Schema.optional(
+      Schema.Literals([
+        "-1h",
+        "-3h",
+        "-6h",
+        "-12h",
+        "-1d",
+        "-3d",
+        "-7d",
+        "-1w",
+        "-2w",
+        "-3w",
+        "-30d",
+        "-60d",
+        "-90d",
+      ]),
+    ),
+    againstTimestamp: Schema.optional(Schema.String),
+    timeWindowStart: Schema.String,
+    timeWindowEnd: Schema.String,
+    uid: Schema.optional(Schema.String),
+  }),
+  id: Schema.String,
+  uid: Schema.String,
+  updatedAt: Schema.String,
+  updatedBy: Schema.String,
+  version: Schema.Unknown,
+});
+export type GetDashboardOutput = typeof GetDashboardOutput.Type;
+
+// The operation
+/**
+ * Get dashboard
+ *
+ * Get a dashboard by UID.
+ */
+export const getDashboard = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetDashboardInput,
+  outputSchema: GetDashboardOutput,
+  errors: [NotFound] as const,
+}));

package/src/operations/v2/getDataset.ts

@@ -0,0 +1,42 @@
+import * as Schema from "effect/Schema";
+import { API } from "../../client";
+import * as T from "../../traits";
+import { Forbidden, NotFound } from "../../errors";
+
+// Input Schema
+export const GetDatasetInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  dataset_id: Schema.String.pipe(T.PathParam()),
+}).pipe(T.Http({ method: "GET", path: "/v2/datasets/{dataset_id}" }));
+export type GetDatasetInput = typeof GetDatasetInput.Type;
+
+// Output Schema
+export const GetDatasetOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  canWrite: Schema.optional(Schema.Boolean),
+  created: Schema.String,
+  description: Schema.String,
+  edgeDeployment: Schema.optional(Schema.String),
+  id: Schema.String,
+  kind: Schema.Literals([
+    "otel:metrics:v1",
+    "otel:traces:v1",
+    "otel:logs:v1",
+    "axiom:events:v1",
+  ]),
+  mapFields: Schema.optional(Schema.Array(Schema.String)),
+  name: Schema.String,
+  retentionDays: Schema.optional(Schema.Number),
+  sharedByOrg: Schema.optional(Schema.String),
+  useRetentionPeriod: Schema.optional(Schema.Boolean),
+  who: Schema.String,
+});
+export type GetDatasetOutput = typeof GetDatasetOutput.Type;
+
+// The operation
+/**
+ * Get dataset by ID
+ */
+export const getDataset = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetDatasetInput,
+  outputSchema: GetDatasetOutput,
+  errors: [Forbidden, NotFound] as const,
+}));

package/src/operations/v2/getDatasets.ts

@@ -0,0 +1,44 @@
+import * as Schema from "effect/Schema";
+import { API } from "../../client";
+import * as T from "../../traits";
+import { Forbidden } from "../../errors";
+
+// Input Schema
+export const GetDatasetsInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
+  {},
+).pipe(T.Http({ method: "GET", path: "/v2/datasets" }));
+export type GetDatasetsInput = typeof GetDatasetsInput.Type;
+
+// Output Schema
+export const GetDatasetsOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
+  Schema.Struct({
+    canWrite: Schema.optional(Schema.Boolean),
+    created: Schema.String,
+    description: Schema.String,
+    edgeDeployment: Schema.optional(Schema.String),
+    id: Schema.String,
+    kind: Schema.Literals([
+      "otel:metrics:v1",
+      "otel:traces:v1",
+      "otel:logs:v1",
+      "axiom:events:v1",
+    ]),
+    mapFields: Schema.optional(Schema.Array(Schema.String)),
+    name: Schema.String,
+    retentionDays: Schema.optional(Schema.Number),
+    sharedByOrg: Schema.optional(Schema.String),
+    useRetentionPeriod: Schema.optional(Schema.Boolean),
+    who: Schema.String,
+  }),
+);
+export type GetDatasetsOutput = typeof GetDatasetsOutput.Type;
+
+// The operation
+/**
+ * Get list of datasets
+ */
+export const getDatasets = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetDatasetsInput,
+  outputSchema: GetDatasetsOutput,
+  errors: [Forbidden] as const,
+}));

package/src/operations/v2/getFieldForDataset.ts

@@ -0,0 +1,35 @@
+import * as Schema from "effect/Schema";
+import { API } from "../../client";
+import * as T from "../../traits";
+import { NotFound } from "../../errors";
+
+// Input Schema
+export const GetFieldForDatasetInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    dataset_id: Schema.String.pipe(T.PathParam()),
+    field_id: Schema.String.pipe(T.PathParam()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      path: "/v2/datasets/{dataset_id}/fields/{field_id}",
+    }),
+  );
+export type GetFieldForDatasetInput = typeof GetFieldForDatasetInput.Type;
+
+// Output Schema
+export const GetFieldForDatasetOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    description: Schema.optional(Schema.String),
+    hidden: Schema.optional(Schema.Boolean),
+    name: Schema.String,
+    type: Schema.String,
+    unit: Schema.optional(Schema.String),
+  });
+export type GetFieldForDatasetOutput = typeof GetFieldForDatasetOutput.Type;
+
+// The operation
+export const getFieldForDataset = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetFieldForDatasetInput,
+  outputSchema: GetFieldForDatasetOutput,
+  errors: [NotFound] as const,
+}));

package/src/operations/v2/getFieldsForDataset.ts

@@ -0,0 +1,31 @@
+import * as Schema from "effect/Schema";
+import { API } from "../../client";
+import * as T from "../../traits";
+import { Forbidden, NotFound } from "../../errors";
+
+// Input Schema
+export const GetFieldsForDatasetInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    dataset_id: Schema.String.pipe(T.PathParam()),
+  }).pipe(T.Http({ method: "GET", path: "/v2/datasets/{dataset_id}/fields" }));
+export type GetFieldsForDatasetInput = typeof GetFieldsForDatasetInput.Type;
+
+// Output Schema
+export const GetFieldsForDatasetOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
+    Schema.Struct({
+      description: Schema.optional(Schema.String),
+      hidden: Schema.optional(Schema.Boolean),
+      name: Schema.String,
+      type: Schema.String,
+      unit: Schema.optional(Schema.String),
+    }),
+  );
+export type GetFieldsForDatasetOutput = typeof GetFieldsForDatasetOutput.Type;
+
+// The operation
+export const getFieldsForDataset = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetFieldsForDatasetInput,
+  outputSchema: GetFieldsForDatasetOutput,
+  errors: [Forbidden, NotFound] as const,
+}));

package/src/operations/v2/getGroupById.ts

@@ -0,0 +1,35 @@
+import * as Schema from "effect/Schema";
+import { API } from "../../client";
+import * as T from "../../traits";
+import { NotFound } from "../../errors";
+
+// Input Schema
+export const GetGroupByIdInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  id: Schema.String.pipe(T.PathParam()),
+}).pipe(T.Http({ method: "GET", path: "/v2/rbac/groups/{id}" }));
+export type GetGroupByIdInput = typeof GetGroupByIdInput.Type;
+
+// Output Schema
+export const GetGroupByIdOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  description: Schema.optional(Schema.String),
+  isManaged: Schema.optional(Schema.Boolean),
+  members: Schema.optional(Schema.Array(Schema.String)),
+  name: Schema.String,
+  roles: Schema.optional(Schema.Array(Schema.String)),
+  id: Schema.String,
+});
+export type GetGroupByIdOutput = typeof GetGroupByIdOutput.Type;
+
+// The operation
+/**
+ * Get group by ID
+ *
+ * Retrieves detailed information about a specific group by its unique identifier.
+ *
+ * @param id - Unique identifier of the group to retrieve
+ */
+export const getGroupById = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetGroupByIdInput,
+  outputSchema: GetGroupByIdOutput,
+  errors: [NotFound] as const,
+}));

package/src/operations/v2/getMapFields.ts

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