@distilled.cloud/axiom 0.27.0 → 0.28.1

package/src/operations/v2/updateDashboard.ts

@@ -4,6 +4,175 @@ import * as T from "../../traits.ts";
 import { BadRequest, Conflict } from "../../errors.ts";
 
 // Input Schema
+export interface UpdateDashboardInput {
+  uid: 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;
+  };
+  message?: string;
+  overwrite?: boolean;
+  version?: string | number;
+}
 export const UpdateDashboardInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   uid: Schema.String.pipe(T.PathParam()),
   dashboard: Schema.Struct({
@@ -51,11 +220,188 @@ export const UpdateDashboardInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   }),
   message: Schema.optional(Schema.String),
   overwrite: Schema.optional(Schema.Boolean),
-  version: Schema.optional(Schema.Unknown),
-}).pipe(T.Http({ method: "PUT", path: "/v2/dashboards/uid/{uid}" }));
-export type UpdateDashboardInput = typeof UpdateDashboardInput.Type;
+  version: Schema.optional(Schema.Union([Schema.String, Schema.Number])),
+}).pipe(
+  T.Http({ method: "PUT", path: "/v2/dashboards/uid/{uid}" }),
+) as unknown as Schema.Codec<UpdateDashboardInput>;
 
 // Output Schema
+export interface UpdateDashboardOutput {
+  dashboard: {
+    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;
+  };
+  overwritten?: boolean;
+  status: "created" | "updated";
+}
 export const UpdateDashboardOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   dashboard: Schema.Struct({
     createdAt: Schema.String,
@@ -107,12 +453,11 @@ export const UpdateDashboardOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     uid: Schema.String,
     updatedAt: Schema.String,
     updatedBy: Schema.String,
-    version: Schema.Unknown,
+    version: Schema.Union([Schema.String, Schema.Number]),
   }),
   overwritten: Schema.optional(Schema.Boolean),
   status: Schema.Literals(["created", "updated"]),
-});
-export type UpdateDashboardOutput = typeof UpdateDashboardOutput.Type;
+}) as unknown as Schema.Codec<UpdateDashboardOutput>;
 
 // The operation
 /**

package/src/operations/v2/updateDataset.ts

@@ -4,20 +4,48 @@ import * as T from "../../traits.ts";
 import { Forbidden, NotFound, UnprocessableEntity } from "../../errors.ts";
 
 // Input Schema
+export interface UpdateDatasetInput {
+  dataset_id: string;
+  description?: string;
+  retentionDays?: number;
+  useRetentionPeriod?: boolean;
+}
 export const UpdateDatasetInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   dataset_id: Schema.String.pipe(T.PathParam()),
   description: Schema.optional(Schema.String),
   retentionDays: Schema.optional(Schema.Number),
   useRetentionPeriod: Schema.optional(Schema.Boolean),
-}).pipe(T.Http({ method: "PUT", path: "/v2/datasets/{dataset_id}" }));
-export type UpdateDatasetInput = typeof UpdateDatasetInput.Type;
+}).pipe(
+  T.Http({ method: "PUT", path: "/v2/datasets/{dataset_id}" }),
+) as unknown as Schema.Codec<UpdateDatasetInput>;
 
 // Output Schema
+export interface UpdateDatasetOutput {
+  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 UpdateDatasetOutput = /*@__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",
@@ -29,10 +57,10 @@ export const UpdateDatasetOutput = /*@__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 UpdateDatasetOutput = typeof UpdateDatasetOutput.Type;
+}) as unknown as Schema.Codec<UpdateDatasetOutput>;
 
 // The operation
 /**

package/src/operations/v2/updateFieldForDataset.ts

@@ -4,6 +4,15 @@ import * as T from "../../traits.ts";
 import { NotFound, UnprocessableEntity } from "../../errors.ts";
 
 // Input Schema
+export interface UpdateFieldForDatasetInput {
+  dataset_id: string;
+  field_id: string;
+  description?: string;
+  hidden?: boolean;
+  name: string;
+  type: string;
+  unit?: string;
+}
 export const UpdateFieldForDatasetInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     dataset_id: Schema.String.pipe(T.PathParam()),
@@ -18,10 +27,16 @@ export const UpdateFieldForDatasetInput =
       method: "PUT",
       path: "/v2/datasets/{dataset_id}/fields/{field_id}",
     }),
-  );
-export type UpdateFieldForDatasetInput = typeof UpdateFieldForDatasetInput.Type;
+  ) as unknown as Schema.Codec<UpdateFieldForDatasetInput>;
 
 // Output Schema
+export interface UpdateFieldForDatasetOutput {
+  description?: string;
+  hidden?: boolean;
+  name: string;
+  type: string;
+  unit?: string;
+}
 export const UpdateFieldForDatasetOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     description: Schema.optional(Schema.String),
@@ -29,9 +44,7 @@ export const UpdateFieldForDatasetOutput =
     name: Schema.String,
     type: Schema.String,
     unit: Schema.optional(Schema.String),
-  });
-export type UpdateFieldForDatasetOutput =
-  typeof UpdateFieldForDatasetOutput.Type;
+  }) as unknown as Schema.Codec<UpdateFieldForDatasetOutput>;
 
 // The operation
 export const updateFieldForDataset = /*@__PURE__*/ /*#__PURE__*/ API.make(

package/src/operations/v2/updateGroup.ts

@@ -4,6 +4,14 @@ import * as T from "../../traits.ts";
 import { NotFound, UnprocessableEntity } from "../../errors.ts";
 
 // Input Schema
+export interface UpdateGroupInput {
+  id: string;
+  description?: string;
+  isManaged?: boolean;
+  members?: ReadonlyArray<string>;
+  name: string;
+  roles?: ReadonlyArray<string>;
+}
 export const UpdateGroupInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   id: Schema.String.pipe(T.PathParam()),
   description: Schema.optional(Schema.String),
@@ -11,10 +19,19 @@ export const UpdateGroupInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   members: Schema.optional(Schema.Array(Schema.String)),
   name: Schema.String,
   roles: Schema.optional(Schema.Array(Schema.String)),
-}).pipe(T.Http({ method: "PUT", path: "/v2/rbac/groups/{id}" }));
-export type UpdateGroupInput = typeof UpdateGroupInput.Type;
+}).pipe(
+  T.Http({ method: "PUT", path: "/v2/rbac/groups/{id}" }),
+) as unknown as Schema.Codec<UpdateGroupInput>;
 
 // Output Schema
+export interface UpdateGroupOutput {
+  description?: string;
+  isManaged?: boolean;
+  members?: ReadonlyArray<string>;
+  name: string;
+  roles?: ReadonlyArray<string>;
+  id: string;
+}
 export const UpdateGroupOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   description: Schema.optional(Schema.String),
   isManaged: Schema.optional(Schema.Boolean),
@@ -22,8 +39,7 @@ export const UpdateGroupOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   name: Schema.String,
   roles: Schema.optional(Schema.Array(Schema.String)),
   id: Schema.String,
-});
-export type UpdateGroupOutput = typeof UpdateGroupOutput.Type;
+}) as unknown as Schema.Codec<UpdateGroupOutput>;
 
 // The operation
 /**

package/src/operations/v2/updateMapFields.ts

@@ -4,16 +4,20 @@ import * as T from "../../traits.ts";
 import { NotFound } from "../../errors.ts";
 
 // Input Schema
+export interface UpdateMapFieldsInput {
+  dataset_id: string;
+}
 export const UpdateMapFieldsInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   dataset_id: Schema.String.pipe(T.PathParam()),
-}).pipe(T.Http({ method: "PUT", path: "/v2/datasets/{dataset_id}/mapfields" }));
-export type UpdateMapFieldsInput = typeof UpdateMapFieldsInput.Type;
+}).pipe(
+  T.Http({ method: "PUT", path: "/v2/datasets/{dataset_id}/mapfields" }),
+) as unknown as Schema.Codec<UpdateMapFieldsInput>;
 
 // Output Schema
+export type UpdateMapFieldsOutput = ReadonlyArray<string>;
 export const UpdateMapFieldsOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
   Schema.String,
-);
-export type UpdateMapFieldsOutput = typeof UpdateMapFieldsOutput.Type;
+) as unknown as Schema.Codec<UpdateMapFieldsOutput>;
 
 // The operation
 export const updateMapFields = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({

package/src/operations/v2/updateMonitor.ts

@@ -4,6 +4,40 @@ import * as T from "../../traits.ts";
 import { NotFound, UnprocessableEntity } from "../../errors.ts";
 
 // Input Schema
+export interface UpdateMonitorInput {
+  id: string;
+  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;
+}
 export const UpdateMonitorInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   id: Schema.String.pipe(T.PathParam()),
   alertOnNoData: Schema.optional(Schema.Boolean),
@@ -39,10 +73,46 @@ export const UpdateMonitorInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   triggerAfterNPositiveResults: Schema.optional(Schema.Number),
   triggerFromNRuns: Schema.optional(Schema.Number),
   type: Schema.Literals(["Threshold", "MatchEvent", "AnomalyDetection"]),
-}).pipe(T.Http({ method: "PUT", path: "/v2/monitors/{id}" }));
-export type UpdateMonitorInput = typeof UpdateMonitorInput.Type;
+  updatedAt: Schema.optional(Schema.String),
+}).pipe(
+  T.Http({ method: "PUT", path: "/v2/monitors/{id}" }),
+) as unknown as Schema.Codec<UpdateMonitorInput>;
 
 // Output Schema
+export interface UpdateMonitorOutput {
+  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 UpdateMonitorOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   alertOnNoData: Schema.optional(Schema.Boolean),
   aplQuery: Schema.optional(Schema.String),
@@ -77,9 +147,9 @@ export const UpdateMonitorOutput = /*@__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 UpdateMonitorOutput = typeof UpdateMonitorOutput.Type;
+}) as unknown as Schema.Codec<UpdateMonitorOutput>;
 
 // The operation
 /**