@distilled.cloud/axiom 0.27.0 → 0.28.1

package/src/operations/v2/patchDashboardChart.ts

@@ -0,0 +1,275 @@
+import * as Schema from "effect/Schema";
+import { API } from "../../client.ts";
+import * as T from "../../traits.ts";
+import { BadRequest, NotFound } from "../../errors.ts";
+
+// Input Schema
+export interface PatchDashboardChartInput {
+  uid: string;
+  chartId: string;
+  chart: Record<string, unknown>;
+  message?: string;
+  overwrite?: boolean;
+  version?: number;
+}
+export const PatchDashboardChartInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    uid: Schema.String.pipe(T.PathParam()),
+    chartId: Schema.String.pipe(T.PathParam()),
+    chart: Schema.Record(Schema.String, Schema.Unknown),
+    message: Schema.optional(Schema.String),
+    overwrite: Schema.optional(Schema.Boolean),
+    version: Schema.optional(Schema.Number),
+  }).pipe(
+    T.Http({
+      method: "PATCH",
+      path: "/v2/dashboards/uid/{uid}/charts/{chartId}",
+    }),
+  ) as unknown as Schema.Codec<PatchDashboardChartInput>;
+
+// Output Schema
+export interface PatchDashboardChartOutput {
+  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 PatchDashboardChartOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    dashboard: 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]),
+    }),
+    overwritten: Schema.optional(Schema.Boolean),
+    status: Schema.Literals(["created", "updated"]),
+  }) as unknown as Schema.Codec<PatchDashboardChartOutput>;
+
+// The operation
+/**
+ * Patch dashboard chart
+ *
+ * Patch a single chart in a dashboard by chart ID.
+ */
+export const patchDashboardChart = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: PatchDashboardChartInput,
+  outputSchema: PatchDashboardChartOutput,
+  errors: [BadRequest, NotFound] as const,
+}));

package/src/operations/v2/regenerateAPIToken.ts

@@ -4,6 +4,53 @@ import * as T from "../../traits.ts";
 import { NotFound, UnprocessableEntity } from "../../errors.ts";
 
 // Input Schema
+export interface RegenerateAPITokenInput {
+  id: string;
+  existingTokenExpiresAt: string;
+  newToken?: {
+    datasetCapabilities?: Record<
+      string,
+      {
+        data?: ReadonlyArray<"delete">;
+        ingest?: ReadonlyArray<"create">;
+        query?: ReadonlyArray<"read">;
+        share?: ReadonlyArray<"create" | "read" | "delete">;
+        starredQueries?: ReadonlyArray<"create" | "read" | "update" | "delete">;
+        trim?: ReadonlyArray<"update">;
+        vacuum?: ReadonlyArray<"update">;
+        virtualFields?: ReadonlyArray<"create" | "read" | "update" | "delete">;
+      }
+    >;
+    description?: string;
+    expiresAt?: string | null;
+    name: string;
+    orgCapabilities?: {
+      annotations?: ReadonlyArray<"create" | "read" | "update" | "delete">;
+      apiTokens?: ReadonlyArray<"create" | "read" | "update" | "delete">;
+      auditLog?: ReadonlyArray<"read">;
+      billing?: ReadonlyArray<"read" | "update">;
+      dashboards?: ReadonlyArray<"create" | "read" | "update" | "delete">;
+      datasets?: ReadonlyArray<"create" | "read" | "update" | "delete">;
+      endpoints?: ReadonlyArray<"create" | "read" | "update" | "delete">;
+      flows?: ReadonlyArray<"create" | "read" | "update" | "delete">;
+      integrations?: ReadonlyArray<"create" | "read" | "update" | "delete">;
+      monitors?: ReadonlyArray<"create" | "read" | "update" | "delete">;
+      notifiers?: ReadonlyArray<"create" | "read" | "update" | "delete">;
+      rbac?: ReadonlyArray<"create" | "read" | "update" | "delete">;
+      sharedAccessKeys?: ReadonlyArray<"read" | "update">;
+      users?: ReadonlyArray<"create" | "read" | "update" | "delete">;
+      views?: ReadonlyArray<"create" | "read" | "update" | "delete">;
+    };
+    viewCapabilities?: Record<
+      string,
+      {
+        query?: ReadonlyArray<"read">;
+        share?: ReadonlyArray<"create" | "read" | "delete">;
+      }
+    >;
+  };
+  newTokenExpiresAt?: string | null;
+}
 export const RegenerateAPITokenInput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     id: Schema.String.pipe(T.PathParam()),
@@ -127,10 +174,56 @@ export const RegenerateAPITokenInput =
       }),
     ),
     newTokenExpiresAt: Schema.optional(Schema.NullOr(Schema.String)),
-  }).pipe(T.Http({ method: "POST", path: "/v2/tokens/{id}/regenerate" }));
-export type RegenerateAPITokenInput = typeof RegenerateAPITokenInput.Type;
+  }).pipe(
+    T.Http({ method: "POST", path: "/v2/tokens/{id}/regenerate" }),
+  ) as unknown as Schema.Codec<RegenerateAPITokenInput>;
 
 // Output Schema
+export interface RegenerateAPITokenOutput {
+  datasetCapabilities: Record<
+    string,
+    {
+      data?: ReadonlyArray<"delete">;
+      ingest?: ReadonlyArray<"create">;
+      query?: ReadonlyArray<"read">;
+      share?: ReadonlyArray<"create" | "read" | "delete">;
+      starredQueries?: ReadonlyArray<"create" | "read" | "update" | "delete">;
+      trim?: ReadonlyArray<"update">;
+      vacuum?: ReadonlyArray<"update">;
+      virtualFields?: ReadonlyArray<"create" | "read" | "update" | "delete">;
+    }
+  >;
+  description?: string;
+  expiresAt?: string | null;
+  id: string;
+  name: string;
+  orgCapabilities: {
+    annotations?: ReadonlyArray<"create" | "read" | "update" | "delete">;
+    apiTokens?: ReadonlyArray<"create" | "read" | "update" | "delete">;
+    auditLog?: ReadonlyArray<"read">;
+    billing?: ReadonlyArray<"read" | "update">;
+    dashboards?: ReadonlyArray<"create" | "read" | "update" | "delete">;
+    datasets?: ReadonlyArray<"create" | "read" | "update" | "delete">;
+    endpoints?: ReadonlyArray<"create" | "read" | "update" | "delete">;
+    flows?: ReadonlyArray<"create" | "read" | "update" | "delete">;
+    integrations?: ReadonlyArray<"create" | "read" | "update" | "delete">;
+    monitors?: ReadonlyArray<"create" | "read" | "update" | "delete">;
+    notifiers?: ReadonlyArray<"create" | "read" | "update" | "delete">;
+    rbac?: ReadonlyArray<"create" | "read" | "update" | "delete">;
+    sharedAccessKeys?: ReadonlyArray<"read" | "update">;
+    users?: ReadonlyArray<"create" | "read" | "update" | "delete">;
+    views?: ReadonlyArray<"create" | "read" | "update" | "delete">;
+  };
+  samlAuthenticated?: boolean;
+  viewCapabilities?: Record<
+    string,
+    {
+      query?: ReadonlyArray<"read">;
+      share?: ReadonlyArray<"create" | "read" | "delete">;
+    }
+  >;
+  token?: string;
+}
 export const RegenerateAPITokenOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     datasetCapabilities: Schema.Record(
@@ -214,8 +307,7 @@ export const RegenerateAPITokenOutput =
       ),
     ),
     token: Schema.optional(Schema.String),
-  });
-export type RegenerateAPITokenOutput = typeof RegenerateAPITokenOutput.Type;
+  }) as unknown as Schema.Codec<RegenerateAPITokenOutput>;
 
 // The operation
 /**

package/src/operations/v2/removeUserFromOrg.ts

@@ -4,16 +4,21 @@ import * as T from "../../traits.ts";
 import { NotFound } from "../../errors.ts";
 
 // Input Schema
+export interface RemoveUserFromOrgInput {
+  id: string;
+}
 export const RemoveUserFromOrgInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
   {
     id: Schema.String.pipe(T.PathParam()),
   },
-).pipe(T.Http({ method: "DELETE", path: "/v2/users/{id}" }));
-export type RemoveUserFromOrgInput = typeof RemoveUserFromOrgInput.Type;
+).pipe(
+  T.Http({ method: "DELETE", path: "/v2/users/{id}" }),
+) as unknown as Schema.Codec<RemoveUserFromOrgInput>;
 
 // Output Schema
-export const RemoveUserFromOrgOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
-export type RemoveUserFromOrgOutput = typeof RemoveUserFromOrgOutput.Type;
+export type RemoveUserFromOrgOutput = void;
+export const RemoveUserFromOrgOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void as unknown as Schema.Codec<RemoveUserFromOrgOutput>;
 
 // The operation
 /**

package/src/operations/v2/trimDataset.ts

@@ -4,15 +4,21 @@ import * as T from "../../traits.ts";
 import { Forbidden, NotFound } from "../../errors.ts";
 
 // Input Schema
+export interface TrimDatasetInput {
+  dataset_id: string;
+  maxDuration: string;
+}
 export const TrimDatasetInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   dataset_id: Schema.String.pipe(T.PathParam()),
   maxDuration: Schema.String,
-}).pipe(T.Http({ method: "POST", path: "/v2/datasets/{dataset_id}/trim" }));
-export type TrimDatasetInput = typeof TrimDatasetInput.Type;
+}).pipe(
+  T.Http({ method: "POST", path: "/v2/datasets/{dataset_id}/trim" }),
+) as unknown as Schema.Codec<TrimDatasetInput>;
 
 // Output Schema
-export const TrimDatasetOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
-export type TrimDatasetOutput = typeof TrimDatasetOutput.Type;
+export type TrimDatasetOutput = void;
+export const TrimDatasetOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void as unknown as Schema.Codec<TrimDatasetOutput>;
 
 // The operation
 /**

package/src/operations/v2/updateAnnotation.ts

@@ -4,6 +4,16 @@ import * as T from "../../traits.ts";
 import { BadRequest, NotFound, UnprocessableEntity } from "../../errors.ts";
 
 // Input Schema
+export interface UpdateAnnotationInput {
+  id: string;
+  datasets?: ReadonlyArray<string>;
+  description?: string;
+  endTime?: string;
+  time?: string;
+  title?: string;
+  type?: string;
+  url?: string;
+}
 export const UpdateAnnotationInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   id: Schema.String.pipe(T.PathParam()),
   datasets: Schema.optional(Schema.Array(Schema.String)),
@@ -13,10 +23,21 @@ export const UpdateAnnotationInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   title: Schema.optional(Schema.String),
   type: Schema.optional(Schema.String),
   url: Schema.optional(Schema.String),
-}).pipe(T.Http({ method: "PUT", path: "/v2/annotations/{id}" }));
-export type UpdateAnnotationInput = typeof UpdateAnnotationInput.Type;
+}).pipe(
+  T.Http({ method: "PUT", path: "/v2/annotations/{id}" }),
+) as unknown as Schema.Codec<UpdateAnnotationInput>;
 
 // Output Schema
+export interface UpdateAnnotationOutput {
+  datasets: ReadonlyArray<string>;
+  description?: string;
+  endTime?: string | null;
+  id: string;
+  time: string;
+  title?: string;
+  type: string;
+  url?: string;
+}
 export const UpdateAnnotationOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
   {
     datasets: Schema.Array(Schema.String),
@@ -28,8 +49,7 @@ export const UpdateAnnotationOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
     type: Schema.String,
     url: Schema.optional(Schema.String),
   },
-);
-export type UpdateAnnotationOutput = typeof UpdateAnnotationOutput.Type;
+) as unknown as Schema.Codec<UpdateAnnotationOutput>;
 
 // The operation
 /**

package/src/operations/v2/updateCurrentUser.ts

@@ -3,14 +3,24 @@ import { API } from "../../client.ts";
 import * as T from "../../traits.ts";
 
 // Input Schema
+export interface UpdateCurrentUserInput {
+  name: string;
+}
 export const UpdateCurrentUserInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
   {
     name: Schema.String,
   },
-).pipe(T.Http({ method: "PUT", path: "/v2/user" }));
-export type UpdateCurrentUserInput = typeof UpdateCurrentUserInput.Type;
+).pipe(
+  T.Http({ method: "PUT", path: "/v2/user" }),
+) as unknown as Schema.Codec<UpdateCurrentUserInput>;
 
 // Output Schema
+export interface UpdateCurrentUserOutput {
+  email: string;
+  id: string;
+  name: string;
+  role?: { id: string; name: string };
+}
 export const UpdateCurrentUserOutput =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     email: Schema.String,
@@ -22,8 +32,7 @@ export const UpdateCurrentUserOutput =
         name: Schema.String,
       }),
     ),
-  });
-export type UpdateCurrentUserOutput = typeof UpdateCurrentUserOutput.Type;
+  }) as unknown as Schema.Codec<UpdateCurrentUserOutput>;
 
 // The operation
 /**