@distilled.cloud/axiom 0.30.3 → 1.0.0-rc.1

package/src/operations/v2/getAnnotations.ts

@@ -1,54 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../../client.ts";
-import * as T from "../../traits.ts";
-
-// Input Schema
-export interface GetAnnotationsInput {
-  datasets?: string;
-  start?: string;
-  end?: string;
-}
-export const GetAnnotationsInput = /*@__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" }),
-) as unknown as Schema.Codec<GetAnnotationsInput>;
-
-// Output Schema
-export type GetAnnotationsOutput = ReadonlyArray<{
-  datasets: ReadonlyArray<string>;
-  description?: string;
-  endTime?: string | null;
-  id: string;
-  time: string;
-  title?: string;
-  type: string;
-  url?: string;
-}>;
-export const GetAnnotationsOutput = /*@__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),
-  }),
-) as unknown as Schema.Codec<GetAnnotationsOutput>;
-
-// 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__*/ API.make(() => ({
-  inputSchema: GetAnnotationsInput,
-  outputSchema: GetAnnotationsOutput,
-}));

package/src/operations/v2/getCurrentUser.ts

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

package/src/operations/v2/getDashboard.ts

@@ -1,252 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../../client.ts";
-import * as T from "../../traits.ts";
-import { NotFound } from "../../errors.ts";
-
-// Input Schema
-export interface GetDashboardInput {
-  uid: string;
-}
-export const GetDashboardInput = /*@__PURE__*/ Schema.Struct({
-  uid: Schema.String.pipe(T.PathParam()),
-}).pipe(
-  T.Http({ method: "GET", path: "/v2/dashboards/uid/{uid}" }),
-) as unknown as Schema.Codec<GetDashboardInput>;
-
-// Output Schema
-export interface GetDashboardOutput {
-  createdAt: string;
-  createdBy: string;
-  dashboard: {
-    name: string;
-    owner: string;
-    description?: string;
-    charts: ReadonlyArray<
-      | { id: string; type: "TimeSeries"; name?: string; query: unknown }
-      | { id: string; type: "Heatmap"; name?: string; query: unknown }
-      | {
-          id: string;
-          type: "LogStream";
-          name?: string;
-          query: unknown;
-          tableSettings?: {
-            columns?: ReadonlyArray<unknown>;
-            settings?: {
-              fontSize?: string;
-              highlightSeverity?: boolean;
-              showRaw?: boolean;
-              showEvent?: boolean;
-              showTimestamp?: boolean;
-              wrapLines?: boolean;
-              hideNulls?: boolean;
-              fitColumns?: boolean;
-            };
-          };
-        }
-      | { id: string; type: "Pie"; name?: string; query: unknown }
-      | { id: string; type: "Scatter"; name?: string; query: unknown }
-      | {
-          id: string;
-          type: "Table";
-          name?: string;
-          query: unknown;
-          tableSettings?: {
-            columns?: ReadonlyArray<unknown>;
-            settings?: {
-              fontSize?: string;
-              highlightSeverity?: boolean;
-              showRaw?: boolean;
-              showEvent?: boolean;
-              showTimestamp?: boolean;
-              wrapLines?: boolean;
-              hideNulls?: boolean;
-              fitColumns?: boolean;
-            };
-          };
-        }
-      | { id: string; type: "TopK"; name?: string; query: unknown }
-      | {
-          id: string;
-          type: "Statistic";
-          name?: string;
-          query: unknown;
-          colorScheme?:
-            | "Blue"
-            | "Orange"
-            | "Red"
-            | "Purple"
-            | "Teal"
-            | "Yellow"
-            | "Green"
-            | "Pink"
-            | "Grey"
-            | "Brown";
-          customUnits?: string;
-          showChart?: boolean | string;
-          hideValue?: boolean;
-          chartHeight?: string | number;
-          errorThreshold?:
-            | "Above"
-            | "AboveOrEqual"
-            | "Below"
-            | "BelowOrEqual"
-            | "AboveOrBelow";
-          errorThresholdValue?: string;
-          warningThreshold?:
-            | "Above"
-            | "AboveOrEqual"
-            | "Below"
-            | "BelowOrEqual"
-            | "AboveOrBelow";
-          warningThresholdValue?: string;
-          invertTheme?: boolean;
-          background?: string;
-          textColor?: string;
-          labelColor?: string;
-          chartFillColor?: string;
-          okColorProps?: {
-            background?: string;
-            chartFillColor?: string;
-            labelColor?: string;
-            textColor?: string;
-          };
-          warningColorProps?: {
-            background?: string;
-            chartFillColor?: string;
-            labelColor?: string;
-            textColor?: string;
-          };
-          errorColorProps?: {
-            background?: string;
-            chartFillColor?: string;
-            labelColor?: string;
-            textColor?: string;
-          };
-        }
-      | { id: string; type: "Note"; text: string; variant?: "default" }
-      | {
-          id: string;
-          type: "MonitorList";
-          name?: string;
-          selectedMonitors: ReadonlyArray<string>;
-          columns: {
-            status: boolean;
-            history: boolean;
-            dataset: boolean;
-            type: boolean;
-            notifiers: boolean;
-          };
-        }
-      | {
-          id: string;
-          type: "SmartFilter";
-          name?: string;
-          filters: ReadonlyArray<unknown>;
-          logo?: string;
-          logoDark?: string;
-        }
-      | { id: string; type: "Spacer"; name?: string }
-    >;
-    layout: ReadonlyArray<{
-      i: string;
-      x: number;
-      y: number | null;
-      w: number;
-      h: number;
-      minW?: number;
-      minH?: number;
-      maxW?: number;
-      maxH?: number;
-      static?: boolean;
-    }>;
-    refreshTime: 15 | 60 | 300;
-    schemaVersion: 2;
-    against?:
-      | "-1h"
-      | "-3h"
-      | "-6h"
-      | "-12h"
-      | "-1d"
-      | "-3d"
-      | "-7d"
-      | "-1w"
-      | "-2w"
-      | "-3w"
-      | "-30d"
-      | "-60d"
-      | "-90d";
-    againstTimestamp?: string;
-    timeWindowStart: string;
-    timeWindowEnd: string;
-    uid?: string;
-  };
-  id: string;
-  uid: string;
-  updatedAt: string;
-  updatedBy: string;
-  version: string | number;
-}
-export const GetDashboardOutput = /*@__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.Union([Schema.String, Schema.Number]),
-}) as unknown as Schema.Codec<GetDashboardOutput>;
-
-// The operation
-/**
- * Get dashboard
- *
- * Get a dashboard by UID.
- */
-export const getDashboard = /*@__PURE__*/ API.make(() => ({
-  inputSchema: GetDashboardInput,
-  outputSchema: GetDashboardOutput,
-  errors: [NotFound] as const,
-}));

package/src/operations/v2/getDataset.ts

@@ -1,67 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../../client.ts";
-import * as T from "../../traits.ts";
-import { Forbidden, NotFound } from "../../errors.ts";
-
-// Input Schema
-export interface GetDatasetInput {
-  dataset_id: string;
-}
-export const GetDatasetInput = /*@__PURE__*/ Schema.Struct({
-  dataset_id: Schema.String.pipe(T.PathParam()),
-}).pipe(
-  T.Http({ method: "GET", path: "/v2/datasets/{dataset_id}" }),
-) as unknown as Schema.Codec<GetDatasetInput>;
-
-// Output Schema
-export interface GetDatasetOutput {
-  canWrite?: boolean;
-  created: string;
-  description: string;
-  edgeDeployment?: string;
-  edgeDeploymentUrl?: string;
-  id: string;
-  kind:
-    | "otel:metrics:v1"
-    | "otel:traces:v1"
-    | "otel:logs:v1"
-    | "axiom:events:v1";
-  mapFields?: ReadonlyArray<string>;
-  name: string;
-  retentionDays?: number;
-  sharedByOrg?: string;
-  updatedAt: string;
-  useRetentionPeriod?: boolean;
-  who: string;
-}
-export const GetDatasetOutput = /*@__PURE__*/ Schema.Struct({
-  canWrite: Schema.optional(Schema.Boolean),
-  created: Schema.String,
-  description: Schema.String,
-  edgeDeployment: Schema.optional(Schema.String),
-  edgeDeploymentUrl: 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),
-  updatedAt: Schema.String,
-  useRetentionPeriod: Schema.optional(Schema.Boolean),
-  who: Schema.String,
-}) as unknown as Schema.Codec<GetDatasetOutput>;
-
-// The operation
-/**
- * Get dataset by ID
- */
-export const getDataset = /*@__PURE__*/ API.make(() => ({
-  inputSchema: GetDatasetInput,
-  outputSchema: GetDatasetOutput,
-  errors: [Forbidden, NotFound] as const,
-}));

package/src/operations/v2/getDatasets.ts

@@ -1,65 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../../client.ts";
-import * as T from "../../traits.ts";
-import { Forbidden } from "../../errors.ts";
-
-// Input Schema
-export interface GetDatasetsInput {}
-export const GetDatasetsInput = /*@__PURE__*/ Schema.Struct({}).pipe(
-  T.Http({ method: "GET", path: "/v2/datasets" }),
-) as unknown as Schema.Codec<GetDatasetsInput>;
-
-// Output Schema
-export type GetDatasetsOutput = ReadonlyArray<{
-  canWrite?: boolean;
-  created: string;
-  description: string;
-  edgeDeployment?: string;
-  edgeDeploymentUrl?: string;
-  id: string;
-  kind:
-    | "otel:metrics:v1"
-    | "otel:traces:v1"
-    | "otel:logs:v1"
-    | "axiom:events:v1";
-  mapFields?: ReadonlyArray<string>;
-  name: string;
-  retentionDays?: number;
-  sharedByOrg?: string;
-  updatedAt: string;
-  useRetentionPeriod?: boolean;
-  who: string;
-}>;
-export const GetDatasetsOutput = /*@__PURE__*/ Schema.Array(
-  Schema.Struct({
-    canWrite: Schema.optional(Schema.Boolean),
-    created: Schema.String,
-    description: Schema.String,
-    edgeDeployment: Schema.optional(Schema.String),
-    edgeDeploymentUrl: 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),
-    updatedAt: Schema.String,
-    useRetentionPeriod: Schema.optional(Schema.Boolean),
-    who: Schema.String,
-  }),
-) as unknown as Schema.Codec<GetDatasetsOutput>;
-
-// The operation
-/**
- * Get list of datasets
- */
-export const getDatasets = /*@__PURE__*/ API.make(() => ({
-  inputSchema: GetDatasetsInput,
-  outputSchema: GetDatasetsOutput,
-  errors: [Forbidden] as const,
-}));

package/src/operations/v2/getFieldForDataset.ts

@@ -1,44 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../../client.ts";
-import * as T from "../../traits.ts";
-import { NotFound } from "../../errors.ts";
-
-// Input Schema
-export interface GetFieldForDatasetInput {
-  dataset_id: string;
-  field_id: string;
-}
-export const GetFieldForDatasetInput =
-  /*@__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}",
-    }),
-  ) as unknown as Schema.Codec<GetFieldForDatasetInput>;
-
-// Output Schema
-export interface GetFieldForDatasetOutput {
-  description?: string;
-  hidden?: boolean;
-  name: string;
-  type: string;
-  unit?: string;
-}
-export const GetFieldForDatasetOutput =
-  /*@__PURE__*/ Schema.Struct({
-    description: Schema.optional(Schema.String),
-    hidden: Schema.optional(Schema.Boolean),
-    name: Schema.String,
-    type: Schema.String,
-    unit: Schema.optional(Schema.String),
-  }) as unknown as Schema.Codec<GetFieldForDatasetOutput>;
-
-// The operation
-export const getFieldForDataset = /*@__PURE__*/ API.make(() => ({
-  inputSchema: GetFieldForDatasetInput,
-  outputSchema: GetFieldForDatasetOutput,
-  errors: [NotFound] as const,
-}));

package/src/operations/v2/getFieldsForDataset.ts

@@ -1,41 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../../client.ts";
-import * as T from "../../traits.ts";
-import { Forbidden, NotFound } from "../../errors.ts";
-
-// Input Schema
-export interface GetFieldsForDatasetInput {
-  dataset_id: string;
-}
-export const GetFieldsForDatasetInput =
-  /*@__PURE__*/ Schema.Struct({
-    dataset_id: Schema.String.pipe(T.PathParam()),
-  }).pipe(
-    T.Http({ method: "GET", path: "/v2/datasets/{dataset_id}/fields" }),
-  ) as unknown as Schema.Codec<GetFieldsForDatasetInput>;
-
-// Output Schema
-export type GetFieldsForDatasetOutput = ReadonlyArray<{
-  description?: string;
-  hidden?: boolean;
-  name: string;
-  type: string;
-  unit?: string;
-}>;
-export const GetFieldsForDatasetOutput =
-  /*@__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),
-    }),
-  ) as unknown as Schema.Codec<GetFieldsForDatasetOutput>;
-
-// The operation
-export const getFieldsForDataset = /*@__PURE__*/ API.make(() => ({
-  inputSchema: GetFieldsForDatasetInput,
-  outputSchema: GetFieldsForDatasetOutput,
-  errors: [Forbidden, NotFound] as const,
-}));

package/src/operations/v2/getGroupById.ts

@@ -1,46 +0,0 @@
-import * as Schema from "effect/Schema";
-import { API } from "../../client.ts";
-import * as T from "../../traits.ts";
-import { NotFound } from "../../errors.ts";
-
-// Input Schema
-export interface GetGroupByIdInput {
-  id: string;
-}
-export const GetGroupByIdInput = /*@__PURE__*/ Schema.Struct({
-  id: Schema.String.pipe(T.PathParam()),
-}).pipe(
-  T.Http({ method: "GET", path: "/v2/rbac/groups/{id}" }),
-) as unknown as Schema.Codec<GetGroupByIdInput>;
-
-// Output Schema
-export interface GetGroupByIdOutput {
-  description?: string;
-  isManaged?: boolean;
-  members?: ReadonlyArray<string>;
-  name: string;
-  roles?: ReadonlyArray<string>;
-  id: string;
-}
-export const GetGroupByIdOutput = /*@__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,
-}) as unknown as Schema.Codec<GetGroupByIdOutput>;
-
-// 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__*/ API.make(() => ({
-  inputSchema: GetGroupByIdInput,
-  outputSchema: GetGroupByIdOutput,
-  errors: [NotFound] as const,
-}));

package/src/operations/v2/getMapFields.ts

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