@alienplatform/platform-api 3.3.14 → 3.3.17

package/src/models/operations/getprojectaiusage.ts

@@ -8,12 +8,14 @@ import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
-export const QueryParamRange = {
+export const GetProjectAiUsageQueryParamRange = {
   TwentyFourh: "24h",
   Sevend: "7d",
   Thirtyd: "30d",
 } as const;
-export type QueryParamRange = ClosedEnum<typeof QueryParamRange>;
+export type GetProjectAiUsageQueryParamRange = ClosedEnum<
+  typeof GetProjectAiUsageQueryParamRange
+>;
 
 export type GetProjectAiUsageRequest = {
   /**
@@ -24,15 +26,17 @@ export type GetProjectAiUsageRequest = {
    * Workspace name. Required for user/session/OAuth requests. Optional for API keys because API keys are workspace-scoped; if provided with an API key, it must match the key's workspace.
    */
   workspace?: string | undefined;
-  range?: QueryParamRange | undefined;
+  range?: GetProjectAiUsageQueryParamRange | undefined;
 };
 
-export const RangeResponse = {
+export const GetProjectAiUsageRangeResponse = {
   TwentyFourh: "24h",
   Sevend: "7d",
   Thirtyd: "30d",
 } as const;
-export type RangeResponse = ClosedEnum<typeof RangeResponse>;
+export type GetProjectAiUsageRangeResponse = ClosedEnum<
+  typeof GetProjectAiUsageRangeResponse
+>;
 
 export const Label = {
   EstimatedProviderCost: "Estimated provider cost",
@@ -45,7 +49,7 @@ export type Pricing = {
   revision: string | null;
 };
 
-export type Totals = {
+export type GetProjectAiUsageTotals = {
   requests: number;
   successfulRequests: number;
   errorRequests: number;
@@ -57,7 +61,7 @@ export type Totals = {
   pricedRequests: number;
 };
 
-export type TimeSery = {
+export type GetProjectAiUsageTimeSery = {
   requests: number;
   successfulRequests: number;
   errorRequests: number;
@@ -99,14 +103,16 @@ export type GetProjectAiUsageModel = {
   provider: string;
 };
 
-export type Available = {
+export type GetProjectAiUsageAvailable = {
   status: "available";
-  range: RangeResponse;
+  range: GetProjectAiUsageRangeResponse;
   pricing: Pricing;
-  totals: Totals;
-  timeSeries: Array<TimeSery>;
+  totals: GetProjectAiUsageTotals;
+  timeSeries: Array<GetProjectAiUsageTimeSery>;
   customers: Array<Customer>;
   models: Array<GetProjectAiUsageModel>;
+  customersTruncated: boolean;
+  modelsTruncated: boolean;
 };
 
 export const GetProjectAiUsageReason = {
@@ -117,7 +123,7 @@ export type GetProjectAiUsageReason = ClosedEnum<
   typeof GetProjectAiUsageReason
 >;
 
-export type Unavailable = {
+export type GetProjectAiUsageUnavailable = {
   status: "unavailable";
   reason: GetProjectAiUsageReason;
 };
@@ -125,11 +131,14 @@ export type Unavailable = {
 /**
  * Privacy-safe AI Gateway usage aggregates.
  */
-export type GetProjectAiUsageResponse = Unavailable | Available;
+export type GetProjectAiUsageResponse =
+  | GetProjectAiUsageUnavailable
+  | GetProjectAiUsageAvailable;
 
 /** @internal */
-export const QueryParamRange$outboundSchema: z.ZodEnum<typeof QueryParamRange> =
-  z.enum(QueryParamRange);
+export const GetProjectAiUsageQueryParamRange$outboundSchema: z.ZodEnum<
+  typeof GetProjectAiUsageQueryParamRange
+> = z.enum(GetProjectAiUsageQueryParamRange);
 
 /** @internal */
 export type GetProjectAiUsageRequest$Outbound = {
@@ -145,7 +154,7 @@ export const GetProjectAiUsageRequest$outboundSchema: z.ZodType<
 > = z.object({
   idOrName: z.string(),
   workspace: z.string().optional(),
-  range: QueryParamRange$outboundSchema.default("24h"),
+  range: GetProjectAiUsageQueryParamRange$outboundSchema.default("24h"),
 });
 
 export function getProjectAiUsageRequestToJSON(
@@ -157,8 +166,9 @@ export function getProjectAiUsageRequestToJSON(
 }
 
 /** @internal */
-export const RangeResponse$inboundSchema: z.ZodEnum<typeof RangeResponse> = z
-  .enum(RangeResponse);
+export const GetProjectAiUsageRangeResponse$inboundSchema: z.ZodEnum<
+  typeof GetProjectAiUsageRangeResponse
+> = z.enum(GetProjectAiUsageRangeResponse);
 
 /** @internal */
 export const Label$inboundSchema: z.ZodEnum<typeof Label> = z.enum(Label);
@@ -181,7 +191,10 @@ export function pricingFromJSON(
 }
 
 /** @internal */
-export const Totals$inboundSchema: z.ZodType<Totals, unknown> = z.object({
+export const GetProjectAiUsageTotals$inboundSchema: z.ZodType<
+  GetProjectAiUsageTotals,
+  unknown
+> = z.object({
   requests: z.int(),
   successfulRequests: z.int(),
   errorRequests: z.int(),
@@ -193,18 +206,21 @@ export const Totals$inboundSchema: z.ZodType<Totals, unknown> = z.object({
   pricedRequests: z.int(),
 });
 
-export function totalsFromJSON(
+export function getProjectAiUsageTotalsFromJSON(
   jsonString: string,
-): SafeParseResult<Totals, SDKValidationError> {
+): SafeParseResult<GetProjectAiUsageTotals, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => Totals$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Totals' from JSON`,
+    (x) => GetProjectAiUsageTotals$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetProjectAiUsageTotals' from JSON`,
   );
 }
 
 /** @internal */
-export const TimeSery$inboundSchema: z.ZodType<TimeSery, unknown> = z.object({
+export const GetProjectAiUsageTimeSery$inboundSchema: z.ZodType<
+  GetProjectAiUsageTimeSery,
+  unknown
+> = z.object({
   requests: z.int(),
   successfulRequests: z.int(),
   errorRequests: z.int(),
@@ -217,13 +233,13 @@ export const TimeSery$inboundSchema: z.ZodType<TimeSery, unknown> = z.object({
   bucket: z.iso.datetime({ offset: true }).transform(v => new Date(v)),
 });
 
-export function timeSeryFromJSON(
+export function getProjectAiUsageTimeSeryFromJSON(
   jsonString: string,
-): SafeParseResult<TimeSery, SDKValidationError> {
+): SafeParseResult<GetProjectAiUsageTimeSery, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => TimeSery$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'TimeSery' from JSON`,
+    (x) => GetProjectAiUsageTimeSery$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetProjectAiUsageTimeSery' from JSON`,
   );
 }
 
@@ -282,23 +298,28 @@ export function getProjectAiUsageModelFromJSON(
 }
 
 /** @internal */
-export const Available$inboundSchema: z.ZodType<Available, unknown> = z.object({
+export const GetProjectAiUsageAvailable$inboundSchema: z.ZodType<
+  GetProjectAiUsageAvailable,
+  unknown
+> = z.object({
   status: z.literal("available"),
-  range: RangeResponse$inboundSchema,
+  range: GetProjectAiUsageRangeResponse$inboundSchema,
   pricing: z.lazy(() => Pricing$inboundSchema),
-  totals: z.lazy(() => Totals$inboundSchema),
-  timeSeries: z.array(z.lazy(() => TimeSery$inboundSchema)),
+  totals: z.lazy(() => GetProjectAiUsageTotals$inboundSchema),
+  timeSeries: z.array(z.lazy(() => GetProjectAiUsageTimeSery$inboundSchema)),
   customers: z.array(z.lazy(() => Customer$inboundSchema)),
   models: z.array(z.lazy(() => GetProjectAiUsageModel$inboundSchema)),
+  customersTruncated: z.boolean(),
+  modelsTruncated: z.boolean(),
 });
 
-export function availableFromJSON(
+export function getProjectAiUsageAvailableFromJSON(
   jsonString: string,
-): SafeParseResult<Available, SDKValidationError> {
+): SafeParseResult<GetProjectAiUsageAvailable, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => Available$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Available' from JSON`,
+    (x) => GetProjectAiUsageAvailable$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetProjectAiUsageAvailable' from JSON`,
   );
 }
 
@@ -308,19 +329,21 @@ export const GetProjectAiUsageReason$inboundSchema: z.ZodEnum<
 > = z.enum(GetProjectAiUsageReason);
 
 /** @internal */
-export const Unavailable$inboundSchema: z.ZodType<Unavailable, unknown> = z
-  .object({
-    status: z.literal("unavailable"),
-    reason: GetProjectAiUsageReason$inboundSchema,
-  });
+export const GetProjectAiUsageUnavailable$inboundSchema: z.ZodType<
+  GetProjectAiUsageUnavailable,
+  unknown
+> = z.object({
+  status: z.literal("unavailable"),
+  reason: GetProjectAiUsageReason$inboundSchema,
+});
 
-export function unavailableFromJSON(
+export function getProjectAiUsageUnavailableFromJSON(
   jsonString: string,
-): SafeParseResult<Unavailable, SDKValidationError> {
+): SafeParseResult<GetProjectAiUsageUnavailable, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => Unavailable$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Unavailable' from JSON`,
+    (x) => GetProjectAiUsageUnavailable$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetProjectAiUsageUnavailable' from JSON`,
   );
 }
 
@@ -329,8 +352,8 @@ export const GetProjectAiUsageResponse$inboundSchema: z.ZodType<
   GetProjectAiUsageResponse,
   unknown
 > = z.union([
-  z.lazy(() => Unavailable$inboundSchema),
-  z.lazy(() => Available$inboundSchema),
+  z.lazy(() => GetProjectAiUsageUnavailable$inboundSchema),
+  z.lazy(() => GetProjectAiUsageAvailable$inboundSchema),
 ]);
 
 export function getProjectAiUsageResponseFromJSON(

package/src/models/operations/getprojectencryptionusage.ts

@@ -0,0 +1,274 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+import { safeParse } from "../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export const GetProjectEncryptionUsageQueryParamRange = {
+  TwentyFourh: "24h",
+  Sevend: "7d",
+  Thirtyd: "30d",
+} as const;
+export type GetProjectEncryptionUsageQueryParamRange = ClosedEnum<
+  typeof GetProjectEncryptionUsageQueryParamRange
+>;
+
+export type GetProjectEncryptionUsageRequest = {
+  /**
+   * Project ID or name.
+   */
+  idOrName: string;
+  /**
+   * Workspace name. Required for user/session/OAuth requests. Optional for API keys because API keys are workspace-scoped; if provided with an API key, it must match the key's workspace.
+   */
+  workspace?: string | undefined;
+  range?: GetProjectEncryptionUsageQueryParamRange | undefined;
+};
+
+export const GetProjectEncryptionUsageRangeResponse = {
+  TwentyFourh: "24h",
+  Sevend: "7d",
+  Thirtyd: "30d",
+} as const;
+export type GetProjectEncryptionUsageRangeResponse = ClosedEnum<
+  typeof GetProjectEncryptionUsageRangeResponse
+>;
+
+export type GetProjectEncryptionUsageTotals = {
+  requests: number;
+  successfulRequests: number;
+  errorRequests: number;
+  averageLatencyMs: number | null;
+  p95LatencyMs: number | null;
+};
+
+export type GetProjectEncryptionUsageTimeSery = {
+  requests: number;
+  successfulRequests: number;
+  errorRequests: number;
+  averageLatencyMs: number | null;
+  p95LatencyMs: number | null;
+  bucket: Date;
+};
+
+export const OperationEnum = {
+  Encrypt: "encrypt",
+  Decrypt: "decrypt",
+} as const;
+export type OperationEnum = ClosedEnum<typeof OperationEnum>;
+
+export type Operation = {
+  requests: number;
+  successfulRequests: number;
+  errorRequests: number;
+  averageLatencyMs: number | null;
+  p95LatencyMs: number | null;
+  operation: OperationEnum;
+};
+
+export type GetProjectEncryptionUsageAvailable = {
+  status: "available";
+  range: GetProjectEncryptionUsageRangeResponse;
+  totals: GetProjectEncryptionUsageTotals;
+  timeSeries: Array<GetProjectEncryptionUsageTimeSery>;
+  operations: Array<Operation>;
+};
+
+export const GetProjectEncryptionUsageReason = {
+  NotConfigured: "not-configured",
+  TemporarilyUnavailable: "temporarily-unavailable",
+} as const;
+export type GetProjectEncryptionUsageReason = ClosedEnum<
+  typeof GetProjectEncryptionUsageReason
+>;
+
+export type GetProjectEncryptionUsageUnavailable = {
+  status: "unavailable";
+  reason: GetProjectEncryptionUsageReason;
+};
+
+/**
+ * Privacy-safe Encryption Gateway usage aggregates.
+ */
+export type GetProjectEncryptionUsageResponse =
+  | GetProjectEncryptionUsageUnavailable
+  | GetProjectEncryptionUsageAvailable;
+
+/** @internal */
+export const GetProjectEncryptionUsageQueryParamRange$outboundSchema: z.ZodEnum<
+  typeof GetProjectEncryptionUsageQueryParamRange
+> = z.enum(GetProjectEncryptionUsageQueryParamRange);
+
+/** @internal */
+export type GetProjectEncryptionUsageRequest$Outbound = {
+  idOrName: string;
+  workspace?: string | undefined;
+  range: string;
+};
+
+/** @internal */
+export const GetProjectEncryptionUsageRequest$outboundSchema: z.ZodType<
+  GetProjectEncryptionUsageRequest$Outbound,
+  GetProjectEncryptionUsageRequest
+> = z.object({
+  idOrName: z.string(),
+  workspace: z.string().optional(),
+  range: GetProjectEncryptionUsageQueryParamRange$outboundSchema.default("24h"),
+});
+
+export function getProjectEncryptionUsageRequestToJSON(
+  getProjectEncryptionUsageRequest: GetProjectEncryptionUsageRequest,
+): string {
+  return JSON.stringify(
+    GetProjectEncryptionUsageRequest$outboundSchema.parse(
+      getProjectEncryptionUsageRequest,
+    ),
+  );
+}
+
+/** @internal */
+export const GetProjectEncryptionUsageRangeResponse$inboundSchema: z.ZodEnum<
+  typeof GetProjectEncryptionUsageRangeResponse
+> = z.enum(GetProjectEncryptionUsageRangeResponse);
+
+/** @internal */
+export const GetProjectEncryptionUsageTotals$inboundSchema: z.ZodType<
+  GetProjectEncryptionUsageTotals,
+  unknown
+> = z.object({
+  requests: z.int(),
+  successfulRequests: z.int(),
+  errorRequests: z.int(),
+  averageLatencyMs: z.nullable(z.number()),
+  p95LatencyMs: z.nullable(z.number()),
+});
+
+export function getProjectEncryptionUsageTotalsFromJSON(
+  jsonString: string,
+): SafeParseResult<GetProjectEncryptionUsageTotals, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetProjectEncryptionUsageTotals$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetProjectEncryptionUsageTotals' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetProjectEncryptionUsageTimeSery$inboundSchema: z.ZodType<
+  GetProjectEncryptionUsageTimeSery,
+  unknown
+> = z.object({
+  requests: z.int(),
+  successfulRequests: z.int(),
+  errorRequests: z.int(),
+  averageLatencyMs: z.nullable(z.number()),
+  p95LatencyMs: z.nullable(z.number()),
+  bucket: z.iso.datetime({ offset: true }).transform(v => new Date(v)),
+});
+
+export function getProjectEncryptionUsageTimeSeryFromJSON(
+  jsonString: string,
+): SafeParseResult<GetProjectEncryptionUsageTimeSery, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetProjectEncryptionUsageTimeSery$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetProjectEncryptionUsageTimeSery' from JSON`,
+  );
+}
+
+/** @internal */
+export const OperationEnum$inboundSchema: z.ZodEnum<typeof OperationEnum> = z
+  .enum(OperationEnum);
+
+/** @internal */
+export const Operation$inboundSchema: z.ZodType<Operation, unknown> = z.object({
+  requests: z.int(),
+  successfulRequests: z.int(),
+  errorRequests: z.int(),
+  averageLatencyMs: z.nullable(z.number()),
+  p95LatencyMs: z.nullable(z.number()),
+  operation: OperationEnum$inboundSchema,
+});
+
+export function operationFromJSON(
+  jsonString: string,
+): SafeParseResult<Operation, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Operation$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Operation' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetProjectEncryptionUsageAvailable$inboundSchema: z.ZodType<
+  GetProjectEncryptionUsageAvailable,
+  unknown
+> = z.object({
+  status: z.literal("available"),
+  range: GetProjectEncryptionUsageRangeResponse$inboundSchema,
+  totals: z.lazy(() => GetProjectEncryptionUsageTotals$inboundSchema),
+  timeSeries: z.array(
+    z.lazy(() => GetProjectEncryptionUsageTimeSery$inboundSchema),
+  ),
+  operations: z.array(z.lazy(() => Operation$inboundSchema)),
+});
+
+export function getProjectEncryptionUsageAvailableFromJSON(
+  jsonString: string,
+): SafeParseResult<GetProjectEncryptionUsageAvailable, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetProjectEncryptionUsageAvailable$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetProjectEncryptionUsageAvailable' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetProjectEncryptionUsageReason$inboundSchema: z.ZodEnum<
+  typeof GetProjectEncryptionUsageReason
+> = z.enum(GetProjectEncryptionUsageReason);
+
+/** @internal */
+export const GetProjectEncryptionUsageUnavailable$inboundSchema: z.ZodType<
+  GetProjectEncryptionUsageUnavailable,
+  unknown
+> = z.object({
+  status: z.literal("unavailable"),
+  reason: GetProjectEncryptionUsageReason$inboundSchema,
+});
+
+export function getProjectEncryptionUsageUnavailableFromJSON(
+  jsonString: string,
+): SafeParseResult<GetProjectEncryptionUsageUnavailable, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetProjectEncryptionUsageUnavailable$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetProjectEncryptionUsageUnavailable' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetProjectEncryptionUsageResponse$inboundSchema: z.ZodType<
+  GetProjectEncryptionUsageResponse,
+  unknown
+> = z.union([
+  z.lazy(() => GetProjectEncryptionUsageUnavailable$inboundSchema),
+  z.lazy(() => GetProjectEncryptionUsageAvailable$inboundSchema),
+]);
+
+export function getProjectEncryptionUsageResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<GetProjectEncryptionUsageResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetProjectEncryptionUsageResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetProjectEncryptionUsageResponse' from JSON`,
+  );
+}