@distilled.cloud/daytona 0.0.0-placeholder → 1.0.0-rc.13

package/src/services/telemetry.ts

@@ -0,0 +1,385 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (specs/spec-mirror-daytona/specs/{openapi,toolbox-openapi,analytics-openapi}.json). Do not edit.
+import * as S from "@distilled.cloud/core/schema";
+import * as API from "@distilled.cloud/core/api";
+import * as T from "../traits.ts";
+import {
+  DaytonaProtocol,
+  type DaytonaOpError,
+  type DaytonaOpContext,
+} from "../protocol.ts";
+import { UnknownDaytonaError } from "../errors.ts";
+import * as Retry from "../retry.ts";
+
+export type { DaytonaOpError, DaytonaOpContext };
+
+export interface GetOrganizationSandboxTelemetryTraceRequest {
+  /** Organization ID */
+  organizationId: string;
+  /** Sandbox ID */
+  sandboxId: string;
+  /** Trace ID */
+  traceId: string;
+}
+export const GetOrganizationSandboxTelemetryTraceRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      organizationId: S.String.pipe(T.Label()),
+      sandboxId: S.String.pipe(T.Label()),
+      traceId: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/organization/{organizationId}/sandbox/{sandboxId}/telemetry/traces/{traceId}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "GetOrganizationSandboxTelemetryTraceRequest",
+  }) as any as S.Schema<GetOrganizationSandboxTelemetryTraceRequest>;
+
+export type ModelsSpanSpanAttributesMap = { [key: string]: string | undefined };
+export const ModelsSpanSpanAttributesMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<ModelsSpanSpanAttributesMap>;
+
+export interface ModelsSpan {
+  durationMs?: number;
+  parentSpanId?: string;
+  spanAttributes?: ModelsSpanSpanAttributesMap;
+  spanId?: string;
+  spanName?: string;
+  statusCode?: string;
+  statusMessage?: string;
+  timestamp?: string;
+  traceId?: string;
+}
+export const ModelsSpan = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    durationMs: S.optional(S.Number),
+    parentSpanId: S.optional(S.String),
+    spanAttributes: S.optional(ModelsSpanSpanAttributesMap),
+    spanId: S.optional(S.String),
+    spanName: S.optional(S.String),
+    statusCode: S.optional(S.String),
+    statusMessage: S.optional(S.String),
+    timestamp: S.optional(S.String),
+    traceId: S.optional(S.String),
+  }),
+).annotate({ identifier: "ModelsSpan" }) as any as S.Schema<ModelsSpan>;
+
+export type GetOrganizationSandboxTelemetryTraceResponseBodyList =
+  Array<ModelsSpan>;
+export const GetOrganizationSandboxTelemetryTraceResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    ModelsSpan,
+  ) as any as S.Schema<GetOrganizationSandboxTelemetryTraceResponseBodyList>;
+
+export type GetOrganizationSandboxTelemetryTraceResponse =
+  GetOrganizationSandboxTelemetryTraceResponseBodyList;
+export const GetOrganizationSandboxTelemetryTraceResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    GetOrganizationSandboxTelemetryTraceResponseBodyList.pipe(
+      T.RawResponseRoot(),
+    ),
+  ).annotate({
+    identifier: "GetOrganizationSandboxTelemetryTraceResponse",
+  }) as any as S.Schema<GetOrganizationSandboxTelemetryTraceResponse>;
+
+export interface ListOrganizationSandboxTelemetryLogsRequest {
+  /** Organization ID */
+  organizationId: string;
+  /** Sandbox ID */
+  sandboxId: string;
+  /** Start time (RFC3339) */
+  from: string;
+  /** End time (RFC3339) */
+  to: string;
+  /** Comma-separated severity levels */
+  severity?: string;
+  /** Search text (ILIKE) */
+  search?: string;
+  /** Page size */
+  limit?: number;
+  /** Offset */
+  offset?: number;
+}
+export const ListOrganizationSandboxTelemetryLogsRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      organizationId: S.String.pipe(T.Label()),
+      sandboxId: S.String.pipe(T.Label()),
+      from: S.String.pipe(T.Query()),
+      to: S.String.pipe(T.Query()),
+      severity: S.optional(S.String.pipe(T.Query())),
+      search: S.optional(S.String.pipe(T.Query())),
+      limit: S.optional(S.Number.pipe(T.Query())),
+      offset: S.optional(S.Number.pipe(T.Query())),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/organization/{organizationId}/sandbox/{sandboxId}/telemetry/logs",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "ListOrganizationSandboxTelemetryLogsRequest",
+  }) as any as S.Schema<ListOrganizationSandboxTelemetryLogsRequest>;
+
+export type ModelsLogEntryLogAttributesMap = {
+  [key: string]: string | undefined;
+};
+export const ModelsLogEntryLogAttributesMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<ModelsLogEntryLogAttributesMap>;
+
+export type ModelsLogEntryResourceAttributesMap = {
+  [key: string]: string | undefined;
+};
+export const ModelsLogEntryResourceAttributesMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<ModelsLogEntryResourceAttributesMap>;
+
+export interface ModelsLogEntry {
+  body?: string;
+  logAttributes?: ModelsLogEntryLogAttributesMap;
+  resourceAttributes?: ModelsLogEntryResourceAttributesMap;
+  serviceName?: string;
+  severityNumber?: number;
+  severityText?: string;
+  spanId?: string;
+  timestamp?: string;
+  traceId?: string;
+}
+export const ModelsLogEntry = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    body: S.optional(S.String),
+    logAttributes: S.optional(ModelsLogEntryLogAttributesMap),
+    resourceAttributes: S.optional(ModelsLogEntryResourceAttributesMap),
+    serviceName: S.optional(S.String),
+    severityNumber: S.optional(S.Number),
+    severityText: S.optional(S.String),
+    spanId: S.optional(S.String),
+    timestamp: S.optional(S.String),
+    traceId: S.optional(S.String),
+  }),
+).annotate({ identifier: "ModelsLogEntry" }) as any as S.Schema<ModelsLogEntry>;
+
+export type ListOrganizationSandboxTelemetryLogsResponseBodyList =
+  Array<ModelsLogEntry>;
+export const ListOrganizationSandboxTelemetryLogsResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    ModelsLogEntry,
+  ) as any as S.Schema<ListOrganizationSandboxTelemetryLogsResponseBodyList>;
+
+export type ListOrganizationSandboxTelemetryLogsResponse =
+  ListOrganizationSandboxTelemetryLogsResponseBodyList;
+export const ListOrganizationSandboxTelemetryLogsResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    ListOrganizationSandboxTelemetryLogsResponseBodyList.pipe(
+      T.RawResponseRoot(),
+    ),
+  ).annotate({
+    identifier: "ListOrganizationSandboxTelemetryLogsResponse",
+  }) as any as S.Schema<ListOrganizationSandboxTelemetryLogsResponse>;
+
+export interface ListOrganizationSandboxTelemetryMetricsRequest {
+  /** Organization ID */
+  organizationId: string;
+  /** Sandbox ID */
+  sandboxId: string;
+  /** Start time (RFC3339) */
+  from: string;
+  /** End time (RFC3339) */
+  to: string;
+  /** Comma-separated metric names */
+  metricNames?: string;
+}
+export const ListOrganizationSandboxTelemetryMetricsRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      organizationId: S.String.pipe(T.Label()),
+      sandboxId: S.String.pipe(T.Label()),
+      from: S.String.pipe(T.Query()),
+      to: S.String.pipe(T.Query()),
+      metricNames: S.optional(S.String.pipe(T.Query())),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/organization/{organizationId}/sandbox/{sandboxId}/telemetry/metrics",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "ListOrganizationSandboxTelemetryMetricsRequest",
+  }) as any as S.Schema<ListOrganizationSandboxTelemetryMetricsRequest>;
+
+export interface ModelsMetricPoint {
+  metricName?: string;
+  timestamp?: string;
+  value?: number;
+}
+export const ModelsMetricPoint = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    metricName: S.optional(S.String),
+    timestamp: S.optional(S.String),
+    value: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "ModelsMetricPoint",
+}) as any as S.Schema<ModelsMetricPoint>;
+
+export type ListOrganizationSandboxTelemetryMetricsResponseBodyList =
+  Array<ModelsMetricPoint>;
+export const ListOrganizationSandboxTelemetryMetricsResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    ModelsMetricPoint,
+  ) as any as S.Schema<ListOrganizationSandboxTelemetryMetricsResponseBodyList>;
+
+export type ListOrganizationSandboxTelemetryMetricsResponse =
+  ListOrganizationSandboxTelemetryMetricsResponseBodyList;
+export const ListOrganizationSandboxTelemetryMetricsResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    ListOrganizationSandboxTelemetryMetricsResponseBodyList.pipe(
+      T.RawResponseRoot(),
+    ),
+  ).annotate({
+    identifier: "ListOrganizationSandboxTelemetryMetricsResponse",
+  }) as any as S.Schema<ListOrganizationSandboxTelemetryMetricsResponse>;
+
+export interface ListOrganizationSandboxTelemetryTracesRequest {
+  /** Organization ID */
+  organizationId: string;
+  /** Sandbox ID */
+  sandboxId: string;
+  /** Start time (RFC3339) */
+  from: string;
+  /** End time (RFC3339) */
+  to: string;
+  /** Page size */
+  limit?: number;
+  /** Offset */
+  offset?: number;
+}
+export const ListOrganizationSandboxTelemetryTracesRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      organizationId: S.String.pipe(T.Label()),
+      sandboxId: S.String.pipe(T.Label()),
+      from: S.String.pipe(T.Query()),
+      to: S.String.pipe(T.Query()),
+      limit: S.optional(S.Number.pipe(T.Query())),
+      offset: S.optional(S.Number.pipe(T.Query())),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/organization/{organizationId}/sandbox/{sandboxId}/telemetry/traces",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "ListOrganizationSandboxTelemetryTracesRequest",
+  }) as any as S.Schema<ListOrganizationSandboxTelemetryTracesRequest>;
+
+export interface ModelsTraceSummary {
+  endTime?: string;
+  rootSpanName?: string;
+  spanCount?: number;
+  startTime?: string;
+  statusCode?: string;
+  totalDurationMs?: number;
+  traceId?: string;
+}
+export const ModelsTraceSummary = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    endTime: S.optional(S.String),
+    rootSpanName: S.optional(S.String),
+    spanCount: S.optional(S.Number),
+    startTime: S.optional(S.String),
+    statusCode: S.optional(S.String),
+    totalDurationMs: S.optional(S.Number),
+    traceId: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "ModelsTraceSummary",
+}) as any as S.Schema<ModelsTraceSummary>;
+
+export type ListOrganizationSandboxTelemetryTracesResponseBodyList =
+  Array<ModelsTraceSummary>;
+export const ListOrganizationSandboxTelemetryTracesResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    ModelsTraceSummary,
+  ) as any as S.Schema<ListOrganizationSandboxTelemetryTracesResponseBodyList>;
+
+export type ListOrganizationSandboxTelemetryTracesResponse =
+  ListOrganizationSandboxTelemetryTracesResponseBodyList;
+export const ListOrganizationSandboxTelemetryTracesResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    ListOrganizationSandboxTelemetryTracesResponseBodyList.pipe(
+      T.RawResponseRoot(),
+    ),
+  ).annotate({
+    identifier: "ListOrganizationSandboxTelemetryTracesResponse",
+  }) as any as S.Schema<ListOrganizationSandboxTelemetryTracesResponse>;
+
+export type GetOrganizationSandboxTelemetryTraceError = DaytonaOpError;
+/** Get trace spans Returns all spans belonging to a specific trace ID */
+export const getOrganizationSandboxTelemetryTrace: API.OperationMethod<
+  GetOrganizationSandboxTelemetryTraceRequest,
+  GetOrganizationSandboxTelemetryTraceResponse,
+  GetOrganizationSandboxTelemetryTraceError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetOrganizationSandboxTelemetryTraceRequest,
+  output: GetOrganizationSandboxTelemetryTraceResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListOrganizationSandboxTelemetryLogsError = DaytonaOpError;
+/** Get sandbox logs Returns paginated log entries with optional severity and search filters */
+export const listOrganizationSandboxTelemetryLogs: API.OperationMethod<
+  ListOrganizationSandboxTelemetryLogsRequest,
+  ListOrganizationSandboxTelemetryLogsResponse,
+  ListOrganizationSandboxTelemetryLogsError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListOrganizationSandboxTelemetryLogsRequest,
+  output: ListOrganizationSandboxTelemetryLogsResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListOrganizationSandboxTelemetryMetricsError = DaytonaOpError;
+/** Get sandbox metrics Returns gauge metrics aggregated in 1-minute intervals */
+export const listOrganizationSandboxTelemetryMetrics: API.OperationMethod<
+  ListOrganizationSandboxTelemetryMetricsRequest,
+  ListOrganizationSandboxTelemetryMetricsResponse,
+  ListOrganizationSandboxTelemetryMetricsError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListOrganizationSandboxTelemetryMetricsRequest,
+  output: ListOrganizationSandboxTelemetryMetricsResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListOrganizationSandboxTelemetryTracesError = DaytonaOpError;
+/** Get sandbox traces Returns paginated trace summaries with span counts and root span info */
+export const listOrganizationSandboxTelemetryTraces: API.OperationMethod<
+  ListOrganizationSandboxTelemetryTracesRequest,
+  ListOrganizationSandboxTelemetryTracesResponse,
+  ListOrganizationSandboxTelemetryTracesError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListOrganizationSandboxTelemetryTracesRequest,
+  output: ListOrganizationSandboxTelemetryTracesResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));

package/src/services/usage.ts

@@ -0,0 +1,316 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (specs/spec-mirror-daytona/specs/{openapi,toolbox-openapi,analytics-openapi}.json). Do not edit.
+import * as S from "@distilled.cloud/core/schema";
+import * as API from "@distilled.cloud/core/api";
+import * as T from "../traits.ts";
+import {
+  DaytonaProtocol,
+  type DaytonaOpError,
+  type DaytonaOpContext,
+} from "../protocol.ts";
+import { UnknownDaytonaError } from "../errors.ts";
+import * as Retry from "../retry.ts";
+
+export type { DaytonaOpError, DaytonaOpContext };
+
+export interface GetOrganizationUsageAggregatedRequest {
+  /** Organization ID */
+  organizationId: string;
+  /** Start time (RFC3339) */
+  from: string;
+  /** End time (RFC3339) */
+  to: string;
+}
+export const GetOrganizationUsageAggregatedRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      organizationId: S.String.pipe(T.Label()),
+      from: S.String.pipe(T.Query()),
+      to: S.String.pipe(T.Query()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/organization/{organizationId}/usage/aggregated",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "GetOrganizationUsageAggregatedRequest",
+}) as any as S.Schema<GetOrganizationUsageAggregatedRequest>;
+
+export interface ModelsAggregatedUsage {
+  firstStart?: string;
+  lastEnd?: string;
+  sandboxCount?: number;
+  totalCPUSeconds?: number;
+  totalDiskGBSeconds?: number;
+  totalGPUSeconds?: number;
+  totalPrice?: number;
+  totalRAMGBSeconds?: number;
+}
+export const ModelsAggregatedUsage = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    firstStart: S.optional(S.String),
+    lastEnd: S.optional(S.String),
+    sandboxCount: S.optional(S.Number),
+    totalCPUSeconds: S.optional(S.Number),
+    totalDiskGBSeconds: S.optional(S.Number),
+    totalGPUSeconds: S.optional(S.Number),
+    totalPrice: S.optional(S.Number),
+    totalRAMGBSeconds: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "ModelsAggregatedUsage",
+}) as any as S.Schema<ModelsAggregatedUsage>;
+
+export interface ListOrganizationSandboxUsageRequest {
+  /** Organization ID */
+  organizationId: string;
+  /** Sandbox ID */
+  sandboxId: string;
+  /** Start time (RFC3339) */
+  from: string;
+  /** End time (RFC3339) */
+  to: string;
+}
+export const ListOrganizationSandboxUsageRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    organizationId: S.String.pipe(T.Label()),
+    sandboxId: S.String.pipe(T.Label()),
+    from: S.String.pipe(T.Query()),
+    to: S.String.pipe(T.Query()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/organization/{organizationId}/sandbox/{sandboxId}/usage",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListOrganizationSandboxUsageRequest",
+}) as any as S.Schema<ListOrganizationSandboxUsageRequest>;
+
+export interface ModelsUsagePeriod {
+  cpu?: number;
+  diskGB?: number;
+  endAt?: string;
+  gpu?: number;
+  price?: number;
+  ramGB?: number;
+  startAt?: string;
+}
+export const ModelsUsagePeriod = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    cpu: S.optional(S.Number),
+    diskGB: S.optional(S.Number),
+    endAt: S.optional(S.String),
+    gpu: S.optional(S.Number),
+    price: S.optional(S.Number),
+    ramGB: S.optional(S.Number),
+    startAt: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "ModelsUsagePeriod",
+}) as any as S.Schema<ModelsUsagePeriod>;
+
+export type ListOrganizationSandboxUsageResponseBodyList =
+  Array<ModelsUsagePeriod>;
+export const ListOrganizationSandboxUsageResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    ModelsUsagePeriod,
+  ) as any as S.Schema<ListOrganizationSandboxUsageResponseBodyList>;
+
+export type ListOrganizationSandboxUsageResponse =
+  ListOrganizationSandboxUsageResponseBodyList;
+export const ListOrganizationSandboxUsageResponse = /*@__PURE__*/ S.suspend(
+  () => ListOrganizationSandboxUsageResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListOrganizationSandboxUsageResponse",
+}) as any as S.Schema<ListOrganizationSandboxUsageResponse>;
+
+export interface ListOrganizationUsageChartRequest {
+  /** Organization ID */
+  organizationId: string;
+  /** Start time (RFC3339) */
+  from: string;
+  /** End time (RFC3339) */
+  to: string;
+  /** Region filter */
+  region?: string;
+}
+export const ListOrganizationUsageChartRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    organizationId: S.String.pipe(T.Label()),
+    from: S.String.pipe(T.Query()),
+    to: S.String.pipe(T.Query()),
+    region: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/organization/{organizationId}/usage/chart",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListOrganizationUsageChartRequest",
+}) as any as S.Schema<ListOrganizationUsageChartRequest>;
+
+export interface ModelsUsageChartPoint {
+  cpu?: number;
+  cpuPrice?: number;
+  diskGB?: number;
+  diskPrice?: number;
+  ramGB?: number;
+  ramPrice?: number;
+  time?: string;
+}
+export const ModelsUsageChartPoint = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    cpu: S.optional(S.Number),
+    cpuPrice: S.optional(S.Number),
+    diskGB: S.optional(S.Number),
+    diskPrice: S.optional(S.Number),
+    ramGB: S.optional(S.Number),
+    ramPrice: S.optional(S.Number),
+    time: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "ModelsUsageChartPoint",
+}) as any as S.Schema<ModelsUsageChartPoint>;
+
+export type ListOrganizationUsageChartResponseBodyList =
+  Array<ModelsUsageChartPoint>;
+export const ListOrganizationUsageChartResponseBodyList = /*@__PURE__*/ S.Array(
+  ModelsUsageChartPoint,
+) as any as S.Schema<ListOrganizationUsageChartResponseBodyList>;
+
+export type ListOrganizationUsageChartResponse =
+  ListOrganizationUsageChartResponseBodyList;
+export const ListOrganizationUsageChartResponse = /*@__PURE__*/ S.suspend(() =>
+  ListOrganizationUsageChartResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListOrganizationUsageChartResponse",
+}) as any as S.Schema<ListOrganizationUsageChartResponse>;
+
+export interface ListOrganizationUsageSandboxRequest {
+  /** Organization ID */
+  organizationId: string;
+  /** Start time (RFC3339) */
+  from: string;
+  /** End time (RFC3339) */
+  to: string;
+}
+export const ListOrganizationUsageSandboxRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    organizationId: S.String.pipe(T.Label()),
+    from: S.String.pipe(T.Query()),
+    to: S.String.pipe(T.Query()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/organization/{organizationId}/usage/sandbox",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListOrganizationUsageSandboxRequest",
+}) as any as S.Schema<ListOrganizationUsageSandboxRequest>;
+
+export interface ModelsSandboxUsage {
+  firstStart?: string;
+  lastEnd?: string;
+  sandboxId?: string;
+  totalCPUSeconds?: number;
+  totalDiskGBSeconds?: number;
+  totalGPUSeconds?: number;
+  totalPrice?: number;
+  totalRAMGBSeconds?: number;
+}
+export const ModelsSandboxUsage = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    firstStart: S.optional(S.String),
+    lastEnd: S.optional(S.String),
+    sandboxId: S.optional(S.String),
+    totalCPUSeconds: S.optional(S.Number),
+    totalDiskGBSeconds: S.optional(S.Number),
+    totalGPUSeconds: S.optional(S.Number),
+    totalPrice: S.optional(S.Number),
+    totalRAMGBSeconds: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "ModelsSandboxUsage",
+}) as any as S.Schema<ModelsSandboxUsage>;
+
+export type ListOrganizationUsageSandboxResponseBodyList =
+  Array<ModelsSandboxUsage>;
+export const ListOrganizationUsageSandboxResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    ModelsSandboxUsage,
+  ) as any as S.Schema<ListOrganizationUsageSandboxResponseBodyList>;
+
+export type ListOrganizationUsageSandboxResponse =
+  ListOrganizationUsageSandboxResponseBodyList;
+export const ListOrganizationUsageSandboxResponse = /*@__PURE__*/ S.suspend(
+  () => ListOrganizationUsageSandboxResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListOrganizationUsageSandboxResponse",
+}) as any as S.Schema<ListOrganizationUsageSandboxResponse>;
+
+export type GetOrganizationUsageAggregatedError = DaytonaOpError;
+/** Get aggregated usage Returns organization-level resource usage totals for a given time period */
+export const getOrganizationUsageAggregated: API.OperationMethod<
+  GetOrganizationUsageAggregatedRequest,
+  ModelsAggregatedUsage,
+  GetOrganizationUsageAggregatedError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetOrganizationUsageAggregatedRequest,
+  output: ModelsAggregatedUsage,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListOrganizationSandboxUsageError = DaytonaOpError;
+/** Get sandbox usage periods Returns individual usage records for a specific sandbox within a time range */
+export const listOrganizationSandboxUsage: API.OperationMethod<
+  ListOrganizationSandboxUsageRequest,
+  ListOrganizationSandboxUsageResponse,
+  ListOrganizationSandboxUsageError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListOrganizationSandboxUsageRequest,
+  output: ListOrganizationSandboxUsageResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListOrganizationUsageChartError = DaytonaOpError;
+/** Get usage chart data Returns resource usage data points for a given time period with auto-scaled resolution */
+export const listOrganizationUsageChart: API.OperationMethod<
+  ListOrganizationUsageChartRequest,
+  ListOrganizationUsageChartResponse,
+  ListOrganizationUsageChartError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListOrganizationUsageChartRequest,
+  output: ListOrganizationUsageChartResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListOrganizationUsageSandboxError = DaytonaOpError;
+/** Get per-sandbox usage Returns resource usage aggregated per sandbox for a given time period */
+export const listOrganizationUsageSandbox: API.OperationMethod<
+  ListOrganizationUsageSandboxRequest,
+  ListOrganizationUsageSandboxResponse,
+  ListOrganizationUsageSandboxError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListOrganizationUsageSandboxRequest,
+  output: ListOrganizationUsageSandboxResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));