@distilled.cloud/axiom 0.27.0 → 0.28.1

package/src/operations/v2/getDashboard.ts

@@ -4,12 +4,188 @@ import * as T from "../../traits.ts";
 import { NotFound } from "../../errors.ts";
 
 // Input Schema
+export interface GetDashboardInput {
+  uid: string;
+}
 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;
+}).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__*/ /*#__PURE__*/ Schema.Struct({
   createdAt: Schema.String,
   createdBy: Schema.String,
@@ -60,9 +236,8 @@ export const GetDashboardOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   uid: Schema.String,
   updatedAt: Schema.String,
   updatedBy: Schema.String,
-  version: Schema.Unknown,
-});
-export type GetDashboardOutput = typeof GetDashboardOutput.Type;
+  version: Schema.Union([Schema.String, Schema.Number]),
+}) as unknown as Schema.Codec<GetDashboardOutput>;
 
 // The operation
 /**

package/src/operations/v2/getDataset.ts

@@ -4,17 +4,42 @@ import * as T from "../../traits.ts";
 import { Forbidden, NotFound } from "../../errors.ts";
 
 // Input Schema
+export interface GetDatasetInput {
+  dataset_id: string;
+}
 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;
+}).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__*/ /*#__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",
@@ -26,10 +51,10 @@ export const GetDatasetOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   name: Schema.String,
   retentionDays: Schema.optional(Schema.Number),
   sharedByOrg: Schema.optional(Schema.String),
+  updatedAt: Schema.String,
   useRetentionPeriod: Schema.optional(Schema.Boolean),
   who: Schema.String,
-});
-export type GetDatasetOutput = typeof GetDatasetOutput.Type;
+}) as unknown as Schema.Codec<GetDatasetOutput>;
 
 // The operation
 /**

package/src/operations/v2/getDatasets.ts

@@ -4,18 +4,41 @@ import * as T from "../../traits.ts";
 import { Forbidden } from "../../errors.ts";
 
 // Input Schema
+export interface GetDatasetsInput {}
 export const GetDatasetsInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
   {},
-).pipe(T.Http({ method: "GET", path: "/v2/datasets" }));
-export type GetDatasetsInput = typeof GetDatasetsInput.Type;
+).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__*/ /*#__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",
@@ -27,11 +50,11 @@ export const GetDatasetsOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
     name: Schema.String,
     retentionDays: Schema.optional(Schema.Number),
     sharedByOrg: Schema.optional(Schema.String),
+    updatedAt: Schema.String,
     useRetentionPeriod: Schema.optional(Schema.Boolean),
     who: Schema.String,
   }),
-);
-export type GetDatasetsOutput = typeof GetDatasetsOutput.Type;
+) as unknown as Schema.Codec<GetDatasetsOutput>;
 
 // The operation
 /**

package/src/operations/v2/getFieldForDataset.ts

@@ -4,6 +4,10 @@ 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__*/ /*#__PURE__*/ Schema.Struct({
     dataset_id: Schema.String.pipe(T.PathParam()),
@@ -13,10 +17,16 @@ export const GetFieldForDatasetInput =
       method: "GET",
       path: "/v2/datasets/{dataset_id}/fields/{field_id}",
     }),
-  );
-export type GetFieldForDatasetInput = typeof GetFieldForDatasetInput.Type;
+  ) 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__*/ /*#__PURE__*/ Schema.Struct({
     description: Schema.optional(Schema.String),
@@ -24,8 +34,7 @@ export const GetFieldForDatasetOutput =
     name: Schema.String,
     type: Schema.String,
     unit: Schema.optional(Schema.String),
-  });
-export type GetFieldForDatasetOutput = typeof GetFieldForDatasetOutput.Type;
+  }) as unknown as Schema.Codec<GetFieldForDatasetOutput>;
 
 // The operation
 export const getFieldForDataset = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({

package/src/operations/v2/getFieldsForDataset.ts

@@ -4,13 +4,24 @@ import * as T from "../../traits.ts";
 import { Forbidden, NotFound } from "../../errors.ts";
 
 // Input Schema
+export interface GetFieldsForDatasetInput {
+  dataset_id: string;
+}
 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;
+  }).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__*/ /*#__PURE__*/ Schema.Array(
     Schema.Struct({
@@ -20,8 +31,7 @@ export const GetFieldsForDatasetOutput =
       type: Schema.String,
       unit: Schema.optional(Schema.String),
     }),
-  );
-export type GetFieldsForDatasetOutput = typeof GetFieldsForDatasetOutput.Type;
+  ) as unknown as Schema.Codec<GetFieldsForDatasetOutput>;
 
 // The operation
 export const getFieldsForDataset = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({

package/src/operations/v2/getGroupById.ts

@@ -4,12 +4,24 @@ import * as T from "../../traits.ts";
 import { NotFound } from "../../errors.ts";
 
 // Input Schema
+export interface GetGroupByIdInput {
+  id: string;
+}
 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;
+}).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__*/ /*#__PURE__*/ Schema.Struct({
   description: Schema.optional(Schema.String),
   isManaged: Schema.optional(Schema.Boolean),
@@ -17,8 +29,7 @@ export const GetGroupByIdOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   name: Schema.String,
   roles: Schema.optional(Schema.Array(Schema.String)),
   id: Schema.String,
-});
-export type GetGroupByIdOutput = typeof GetGroupByIdOutput.Type;
+}) as unknown as Schema.Codec<GetGroupByIdOutput>;
 
 // The operation
 /**

package/src/operations/v2/getMapFields.ts

@@ -4,16 +4,20 @@ import * as T from "../../traits.ts";
 import { NotFound } from "../../errors.ts";
 
 // Input Schema
+export interface GetMapFieldsInput {
+  dataset_id: string;
+}
 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;
+}).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__*/ /*#__PURE__*/ Schema.Array(
   Schema.String,
-);
-export type GetMapFieldsOutput = typeof GetMapFieldsOutput.Type;
+) as unknown as Schema.Codec<GetMapFieldsOutput>;
 
 // The operation
 export const getMapFields = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({

package/src/operations/v2/getMonitor.ts

@@ -4,12 +4,50 @@ import * as T from "../../traits.ts";
 import { NotFound } from "../../errors.ts";
 
 // Input Schema
+export interface GetMonitorInput {
+  id: string;
+}
 export const GetMonitorInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   id: Schema.String.pipe(T.PathParam()),
-}).pipe(T.Http({ method: "GET", path: "/v2/monitors/{id}" }));
-export type GetMonitorInput = typeof GetMonitorInput.Type;
+}).pipe(
+  T.Http({ method: "GET", path: "/v2/monitors/{id}" }),
+) as unknown as Schema.Codec<GetMonitorInput>;
 
 // Output Schema
+export interface GetMonitorOutput {
+  alertOnNoData?: boolean;
+  aplQuery?: string;
+  columnName?: string;
+  compareDays?: number;
+  createdAt?: string;
+  createdBy?: string;
+  description?: string;
+  disabled?: boolean;
+  disabledUntil?: string | null;
+  intervalMinutes?: number;
+  mplQuery?: string;
+  name: string;
+  notifierIds?: ReadonlyArray<string>;
+  notifyByGroup?: boolean;
+  notifyEveryRun?: boolean;
+  operator?:
+    | "Below"
+    | "BelowOrEqual"
+    | "Above"
+    | "AboveOrEqual"
+    | "AboveOrBelow";
+  rangeMinutes?: number;
+  resolvable?: boolean;
+  secondDelay?: number;
+  skipResolved?: boolean;
+  threshold?: number;
+  tolerance?: number;
+  triggerAfterNPositiveResults?: number;
+  triggerFromNRuns?: number;
+  type: "Threshold" | "MatchEvent" | "AnomalyDetection";
+  updatedAt?: string;
+  id: string;
+}
 export const GetMonitorOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   alertOnNoData: Schema.optional(Schema.Boolean),
   aplQuery: Schema.optional(Schema.String),
@@ -44,9 +82,9 @@ export const GetMonitorOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   triggerAfterNPositiveResults: Schema.optional(Schema.Number),
   triggerFromNRuns: Schema.optional(Schema.Number),
   type: Schema.Literals(["Threshold", "MatchEvent", "AnomalyDetection"]),
+  updatedAt: Schema.optional(Schema.String),
   id: Schema.String,
-});
-export type GetMonitorOutput = typeof GetMonitorOutput.Type;
+}) as unknown as Schema.Codec<GetMonitorOutput>;
 
 // The operation
 /**

package/src/operations/v2/getMonitorHistory.ts

@@ -4,16 +4,28 @@ import * as T from "../../traits.ts";
 import { NotFound, UnprocessableEntity } from "../../errors.ts";
 
 // Input Schema
+export interface GetMonitorHistoryInput {
+  id: string;
+  startTime: string;
+  endTime: string;
+}
 export const GetMonitorHistoryInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
   {
     id: Schema.String.pipe(T.PathParam()),
     startTime: Schema.String,
     endTime: Schema.String,
   },
-).pipe(T.Http({ method: "GET", path: "/v2/monitors/{id}/history" }));
-export type GetMonitorHistoryInput = typeof GetMonitorHistoryInput.Type;
+).pipe(
+  T.Http({ method: "GET", path: "/v2/monitors/{id}/history" }),
+) as unknown as Schema.Codec<GetMonitorHistoryInput>;
 
 // Output Schema
+export type GetMonitorHistoryOutput = ReadonlyArray<{
+  checkId: string;
+  name: string;
+  state: "open" | "closed";
+  timestamp: string;
+}>;
 export const GetMonitorHistoryOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
   Schema.Struct({
     checkId: Schema.String,
@@ -21,8 +33,7 @@ export const GetMonitorHistoryOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
     state: Schema.Literals(["open", "closed"]),
     timestamp: Schema.String,
   }),
-);
-export type GetMonitorHistoryOutput = typeof GetMonitorHistoryOutput.Type;
+) as unknown as Schema.Codec<GetMonitorHistoryOutput>;
 
 // The operation
 /**

package/src/operations/v2/getMonitors.ts

@@ -3,12 +3,48 @@ import { API } from "../../client.ts";
 import * as T from "../../traits.ts";
 
 // Input Schema
+export interface GetMonitorsInput {}
 export const GetMonitorsInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
   {},
-).pipe(T.Http({ method: "GET", path: "/v2/monitors" }));
-export type GetMonitorsInput = typeof GetMonitorsInput.Type;
+).pipe(
+  T.Http({ method: "GET", path: "/v2/monitors" }),
+) as unknown as Schema.Codec<GetMonitorsInput>;
 
 // Output Schema
+export type GetMonitorsOutput = ReadonlyArray<{
+  alertOnNoData?: boolean;
+  aplQuery?: string;
+  columnName?: string;
+  compareDays?: number;
+  createdAt?: string;
+  createdBy?: string;
+  description?: string;
+  disabled?: boolean;
+  disabledUntil?: string | null;
+  intervalMinutes?: number;
+  mplQuery?: string;
+  name: string;
+  notifierIds?: ReadonlyArray<string>;
+  notifyByGroup?: boolean;
+  notifyEveryRun?: boolean;
+  operator?:
+    | "Below"
+    | "BelowOrEqual"
+    | "Above"
+    | "AboveOrEqual"
+    | "AboveOrBelow";
+  rangeMinutes?: number;
+  resolvable?: boolean;
+  secondDelay?: number;
+  skipResolved?: boolean;
+  threshold?: number;
+  tolerance?: number;
+  triggerAfterNPositiveResults?: number;
+  triggerFromNRuns?: number;
+  type: "Threshold" | "MatchEvent" | "AnomalyDetection";
+  updatedAt?: string;
+  id: string;
+}>;
 export const GetMonitorsOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
   Schema.Struct({
     alertOnNoData: Schema.optional(Schema.Boolean),
@@ -44,10 +80,10 @@ export const GetMonitorsOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
     triggerAfterNPositiveResults: Schema.optional(Schema.Number),
     triggerFromNRuns: Schema.optional(Schema.Number),
     type: Schema.Literals(["Threshold", "MatchEvent", "AnomalyDetection"]),
+    updatedAt: Schema.optional(Schema.String),
     id: Schema.String,
   }),
-);
-export type GetMonitorsOutput = typeof GetMonitorsOutput.Type;
+) as unknown as Schema.Codec<GetMonitorsOutput>;
 
 // The operation
 /**