@flexprice/sdk 2.1.26 → 2.1.33

package/src/sdk/models/aggregated-entitlement-bucket.ts

@@ -23,6 +23,7 @@ export type AggregatedEntitlementBucket = {
   grantDurationValue?: number | undefined;
   grantMeasure?: EntitlementGrantMeasure | undefined;
   grantQuota?: string | undefined;
+  grantUnlimited?: boolean | undefined;
   sourceEntityId?: string | undefined;
   usageLimit?: number | undefined;
 };
@@ -40,6 +41,7 @@ export const AggregatedEntitlementBucket$inboundSchema: z.ZodMiniType<
     grant_duration_value: types.optional(types.number()),
     grant_measure: types.optional(EntitlementGrantMeasure$inboundSchema),
     grant_quota: types.optional(types.string()),
+    grant_unlimited: types.optional(types.boolean()),
     source_entity_id: types.optional(types.string()),
     usage_limit: types.optional(types.number()),
   }),
@@ -50,6 +52,7 @@ export const AggregatedEntitlementBucket$inboundSchema: z.ZodMiniType<
       "grant_duration_value": "grantDurationValue",
       "grant_measure": "grantMeasure",
       "grant_quota": "grantQuota",
+      "grant_unlimited": "grantUnlimited",
       "source_entity_id": "sourceEntityId",
       "usage_limit": "usageLimit",
     });

package/src/sdk/models/aggregated-entitlement.ts

@@ -15,10 +15,19 @@ import {
   EntitlementAggregationMode,
   EntitlementAggregationMode$inboundSchema,
 } from "./entitlement-aggregation-mode.js";
+import {
+  EntitlementGrantDurationUnit,
+  EntitlementGrantDurationUnit$inboundSchema,
+} from "./entitlement-grant-duration-unit.js";
+import {
+  EntitlementGrantMeasure,
+  EntitlementGrantMeasure$inboundSchema,
+} from "./entitlement-grant-measure.js";
 import {
   EntitlementUsageResetPeriod,
   EntitlementUsageResetPeriod$inboundSchema,
 } from "./entitlement-usage-reset-period.js";
+import { GrantState, GrantState$inboundSchema } from "./grant-state.js";
 import { SDKValidationError } from "./sdk-validation-error.js";
 
 export type ConfigValue = {};
@@ -27,6 +36,12 @@ export type AggregatedEntitlement = {
   aggregationMode?: EntitlementAggregationMode | undefined;
   buckets?: Array<AggregatedEntitlementBucket> | undefined;
   configValues?: Array<{ [k: string]: ConfigValue }> | undefined;
+  grantDurationUnit?: EntitlementGrantDurationUnit | undefined;
+  grantDurationValue?: number | undefined;
+  grantMeasure?: EntitlementGrantMeasure | undefined;
+  grantQuota?: string | undefined;
+  grantState?: GrantState | undefined;
+  grantUnlimited?: boolean | undefined;
   isEnabled?: boolean | undefined;
   isSoftLimit?: boolean | undefined;
   staticValues?: Array<string> | undefined;
@@ -59,6 +74,14 @@ export const AggregatedEntitlement$inboundSchema: z.ZodMiniType<
     config_values: types.optional(
       z.array(z.record(z.string(), z.lazy(() => ConfigValue$inboundSchema))),
     ),
+    grant_duration_unit: types.optional(
+      EntitlementGrantDurationUnit$inboundSchema,
+    ),
+    grant_duration_value: types.optional(types.number()),
+    grant_measure: types.optional(EntitlementGrantMeasure$inboundSchema),
+    grant_quota: types.optional(types.string()),
+    grant_state: types.optional(GrantState$inboundSchema),
+    grant_unlimited: types.optional(types.boolean()),
     is_enabled: types.optional(types.boolean()),
     is_soft_limit: types.optional(types.boolean()),
     static_values: types.optional(z.array(types.string())),
@@ -71,6 +94,12 @@ export const AggregatedEntitlement$inboundSchema: z.ZodMiniType<
     return remap$(v, {
       "aggregation_mode": "aggregationMode",
       "config_values": "configValues",
+      "grant_duration_unit": "grantDurationUnit",
+      "grant_duration_value": "grantDurationValue",
+      "grant_measure": "grantMeasure",
+      "grant_quota": "grantQuota",
+      "grant_state": "grantState",
+      "grant_unlimited": "grantUnlimited",
       "is_enabled": "isEnabled",
       "is_soft_limit": "isSoftLimit",
       "static_values": "staticValues",

package/src/sdk/models/alert-settings.ts

@@ -7,6 +7,11 @@ import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import * as types from "../../types/primitives.js";
+import {
+  AlertThresholdType,
+  AlertThresholdType$inboundSchema,
+  AlertThresholdType$outboundSchema,
+} from "./alert-threshold-type.js";
 import {
   AlertThreshold,
   AlertThreshold$inboundSchema,
@@ -17,6 +22,7 @@ import { SDKValidationError } from "./sdk-validation-error.js";
 
 export type AlertSettings = {
   alertEnabled?: boolean | undefined;
+  alertThresholdType?: AlertThresholdType | undefined;
   critical?: AlertThreshold | undefined;
   info?: AlertThreshold | undefined;
   warning?: AlertThreshold | undefined;
@@ -29,6 +35,7 @@ export const AlertSettings$inboundSchema: z.ZodMiniType<
 > = z.pipe(
   z.object({
     alert_enabled: types.optional(types.boolean()),
+    alert_threshold_type: types.optional(AlertThresholdType$inboundSchema),
     critical: types.optional(AlertThreshold$inboundSchema),
     info: types.optional(AlertThreshold$inboundSchema),
     warning: types.optional(AlertThreshold$inboundSchema),
@@ -36,12 +43,14 @@ export const AlertSettings$inboundSchema: z.ZodMiniType<
   z.transform((v) => {
     return remap$(v, {
       "alert_enabled": "alertEnabled",
+      "alert_threshold_type": "alertThresholdType",
     });
   }),
 );
 /** @internal */
 export type AlertSettings$Outbound = {
   alert_enabled?: boolean | undefined;
+  alert_threshold_type?: string | undefined;
   critical?: AlertThreshold$Outbound | undefined;
   info?: AlertThreshold$Outbound | undefined;
   warning?: AlertThreshold$Outbound | undefined;
@@ -54,6 +63,7 @@ export const AlertSettings$outboundSchema: z.ZodMiniType<
 > = z.pipe(
   z.object({
     alertEnabled: z.optional(z.boolean()),
+    alertThresholdType: z.optional(AlertThresholdType$outboundSchema),
     critical: z.optional(AlertThreshold$outboundSchema),
     info: z.optional(AlertThreshold$outboundSchema),
     warning: z.optional(AlertThreshold$outboundSchema),
@@ -61,6 +71,7 @@ export const AlertSettings$outboundSchema: z.ZodMiniType<
   z.transform((v) => {
     return remap$(v, {
       alertEnabled: "alert_enabled",
+      alertThresholdType: "alert_threshold_type",
     });
   }),
 );

package/src/sdk/models/alert-threshold-type.ts

@@ -0,0 +1,24 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
+
+export const AlertThresholdType = {
+  Absolute: "absolute",
+  Percentage: "percentage",
+} as const;
+export type AlertThresholdType = OpenEnum<typeof AlertThresholdType>;
+
+/** @internal */
+export const AlertThresholdType$inboundSchema: z.ZodMiniType<
+  AlertThresholdType,
+  unknown
+> = openEnums.inboundSchema(AlertThresholdType);
+/** @internal */
+export const AlertThresholdType$outboundSchema: z.ZodMiniType<
+  string,
+  AlertThresholdType
+> = openEnums.outboundSchema(AlertThresholdType);

package/src/sdk/models/analytics-column.ts

@@ -0,0 +1,39 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { ColumnRole, ColumnRole$inboundSchema } from "./column-role.js";
+import { ColumnType, ColumnType$inboundSchema } from "./column-type.js";
+import { SDKValidationError } from "./sdk-validation-error.js";
+
+export type AnalyticsColumn = {
+  currency?: string | undefined;
+  name?: string | undefined;
+  role?: ColumnRole | undefined;
+  type?: ColumnType | undefined;
+};
+
+/** @internal */
+export const AnalyticsColumn$inboundSchema: z.ZodMiniType<
+  AnalyticsColumn,
+  unknown
+> = z.object({
+  currency: types.optional(types.string()),
+  name: types.optional(types.string()),
+  role: types.optional(ColumnRole$inboundSchema),
+  type: types.optional(ColumnType$inboundSchema),
+});
+
+export function analyticsColumnFromJSON(
+  jsonString: string,
+): SafeParseResult<AnalyticsColumn, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AnalyticsColumn$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AnalyticsColumn' from JSON`,
+  );
+}

package/src/sdk/models/analytics-filter.ts

@@ -0,0 +1,65 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import {
+  FilterOperatorType,
+  FilterOperatorType$inboundSchema,
+  FilterOperatorType$outboundSchema,
+} from "./filter-operator-type.js";
+import { SDKValidationError } from "./sdk-validation-error.js";
+
+export type AnalyticsFilter = {
+  field?: string | undefined;
+  op?: FilterOperatorType | undefined;
+  optional?: boolean | undefined;
+  value?: Array<string> | undefined;
+};
+
+/** @internal */
+export const AnalyticsFilter$inboundSchema: z.ZodMiniType<
+  AnalyticsFilter,
+  unknown
+> = z.object({
+  field: types.optional(types.string()),
+  op: types.optional(FilterOperatorType$inboundSchema),
+  optional: types.optional(types.boolean()),
+  value: types.optional(z.array(types.string())),
+});
+/** @internal */
+export type AnalyticsFilter$Outbound = {
+  field?: string | undefined;
+  op?: string | undefined;
+  optional?: boolean | undefined;
+  value?: Array<string> | undefined;
+};
+
+/** @internal */
+export const AnalyticsFilter$outboundSchema: z.ZodMiniType<
+  AnalyticsFilter$Outbound,
+  AnalyticsFilter
+> = z.object({
+  field: z.optional(z.string()),
+  op: z.optional(FilterOperatorType$outboundSchema),
+  optional: z.optional(z.boolean()),
+  value: z.optional(z.array(z.string())),
+});
+
+export function analyticsFilterToJSON(
+  analyticsFilter: AnalyticsFilter,
+): string {
+  return JSON.stringify(AnalyticsFilter$outboundSchema.parse(analyticsFilter));
+}
+export function analyticsFilterFromJSON(
+  jsonString: string,
+): SafeParseResult<AnalyticsFilter, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AnalyticsFilter$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AnalyticsFilter' from JSON`,
+  );
+}

package/src/sdk/models/analytics-query-meta.ts

@@ -0,0 +1,39 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { SDKValidationError } from "./sdk-validation-error.js";
+
+export type AnalyticsQueryMeta = {
+  querySource?: string | undefined;
+};
+
+/** @internal */
+export const AnalyticsQueryMeta$inboundSchema: z.ZodMiniType<
+  AnalyticsQueryMeta,
+  unknown
+> = z.pipe(
+  z.object({
+    query_source: types.optional(types.string()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "query_source": "querySource",
+    });
+  }),
+);
+
+export function analyticsQueryMetaFromJSON(
+  jsonString: string,
+): SafeParseResult<AnalyticsQueryMeta, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AnalyticsQueryMeta$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AnalyticsQueryMeta' from JSON`,
+  );
+}

package/src/sdk/models/analytics-query-request.ts

@@ -0,0 +1,38 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import {
+  AnalyticsViewDefinition,
+  AnalyticsViewDefinition$Outbound,
+  AnalyticsViewDefinition$outboundSchema,
+} from "./analytics-view-definition.js";
+
+export type AnalyticsQueryRequest = {
+  definition: AnalyticsViewDefinition;
+  variables?: { [k: string]: Array<string> } | undefined;
+};
+
+/** @internal */
+export type AnalyticsQueryRequest$Outbound = {
+  definition: AnalyticsViewDefinition$Outbound;
+  variables?: { [k: string]: Array<string> } | undefined;
+};
+
+/** @internal */
+export const AnalyticsQueryRequest$outboundSchema: z.ZodMiniType<
+  AnalyticsQueryRequest$Outbound,
+  AnalyticsQueryRequest
+> = z.object({
+  definition: AnalyticsViewDefinition$outboundSchema,
+  variables: z.optional(z.record(z.string(), z.array(z.string()))),
+});
+
+export function analyticsQueryRequestToJSON(
+  analyticsQueryRequest: AnalyticsQueryRequest,
+): string {
+  return JSON.stringify(
+    AnalyticsQueryRequest$outboundSchema.parse(analyticsQueryRequest),
+  );
+}

package/src/sdk/models/analytics-query-result.ts

@@ -0,0 +1,43 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import {
+  AnalyticsColumn,
+  AnalyticsColumn$inboundSchema,
+} from "./analytics-column.js";
+import {
+  AnalyticsQueryMeta,
+  AnalyticsQueryMeta$inboundSchema,
+} from "./analytics-query-meta.js";
+import { SDKValidationError } from "./sdk-validation-error.js";
+
+export type AnalyticsQueryResult = {
+  columns?: Array<AnalyticsColumn> | undefined;
+  meta?: AnalyticsQueryMeta | undefined;
+  rows?: Array<Array<string>> | undefined;
+};
+
+/** @internal */
+export const AnalyticsQueryResult$inboundSchema: z.ZodMiniType<
+  AnalyticsQueryResult,
+  unknown
+> = z.object({
+  columns: types.optional(z.array(AnalyticsColumn$inboundSchema)),
+  meta: types.optional(AnalyticsQueryMeta$inboundSchema),
+  rows: types.optional(z.array(z.array(types.string()))),
+});
+
+export function analyticsQueryResultFromJSON(
+  jsonString: string,
+): SafeParseResult<AnalyticsQueryResult, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AnalyticsQueryResult$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AnalyticsQueryResult' from JSON`,
+  );
+}

package/src/sdk/models/analytics-sort-spec.ts

@@ -0,0 +1,59 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { SDKValidationError } from "./sdk-validation-error.js";
+import {
+  SortDirection,
+  SortDirection$inboundSchema,
+  SortDirection$outboundSchema,
+} from "./sort-direction.js";
+
+export type AnalyticsSortSpec = {
+  dir?: SortDirection | undefined;
+  field?: string | undefined;
+};
+
+/** @internal */
+export const AnalyticsSortSpec$inboundSchema: z.ZodMiniType<
+  AnalyticsSortSpec,
+  unknown
+> = z.object({
+  dir: types.optional(SortDirection$inboundSchema),
+  field: types.optional(types.string()),
+});
+/** @internal */
+export type AnalyticsSortSpec$Outbound = {
+  dir?: string | undefined;
+  field?: string | undefined;
+};
+
+/** @internal */
+export const AnalyticsSortSpec$outboundSchema: z.ZodMiniType<
+  AnalyticsSortSpec$Outbound,
+  AnalyticsSortSpec
+> = z.object({
+  dir: z.optional(SortDirection$outboundSchema),
+  field: z.optional(z.string()),
+});
+
+export function analyticsSortSpecToJSON(
+  analyticsSortSpec: AnalyticsSortSpec,
+): string {
+  return JSON.stringify(
+    AnalyticsSortSpec$outboundSchema.parse(analyticsSortSpec),
+  );
+}
+export function analyticsSortSpecFromJSON(
+  jsonString: string,
+): SafeParseResult<AnalyticsSortSpec, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AnalyticsSortSpec$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AnalyticsSortSpec' from JSON`,
+  );
+}

package/src/sdk/models/analytics-time-spec-raw.ts

@@ -0,0 +1,55 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { Grain, Grain$inboundSchema, Grain$outboundSchema } from "./grain.js";
+import { SDKValidationError } from "./sdk-validation-error.js";
+
+export type AnalyticsTimeSpecRaw = {
+  grain?: Grain | undefined;
+  range?: string | undefined;
+};
+
+/** @internal */
+export const AnalyticsTimeSpecRaw$inboundSchema: z.ZodMiniType<
+  AnalyticsTimeSpecRaw,
+  unknown
+> = z.object({
+  grain: types.optional(Grain$inboundSchema),
+  range: types.optional(types.string()),
+});
+/** @internal */
+export type AnalyticsTimeSpecRaw$Outbound = {
+  grain?: string | undefined;
+  range?: string | undefined;
+};
+
+/** @internal */
+export const AnalyticsTimeSpecRaw$outboundSchema: z.ZodMiniType<
+  AnalyticsTimeSpecRaw$Outbound,
+  AnalyticsTimeSpecRaw
+> = z.object({
+  grain: z.optional(Grain$outboundSchema),
+  range: z.optional(z.string()),
+});
+
+export function analyticsTimeSpecRawToJSON(
+  analyticsTimeSpecRaw: AnalyticsTimeSpecRaw,
+): string {
+  return JSON.stringify(
+    AnalyticsTimeSpecRaw$outboundSchema.parse(analyticsTimeSpecRaw),
+  );
+}
+export function analyticsTimeSpecRawFromJSON(
+  jsonString: string,
+): SafeParseResult<AnalyticsTimeSpecRaw, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AnalyticsTimeSpecRaw$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AnalyticsTimeSpecRaw' from JSON`,
+  );
+}

package/src/sdk/models/analytics-variable.ts

@@ -0,0 +1,67 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { SDKValidationError } from "./sdk-validation-error.js";
+import {
+  VariableType,
+  VariableType$inboundSchema,
+  VariableType$outboundSchema,
+} from "./variable-type.js";
+
+export type AnalyticsVariable = {
+  default?: Array<string> | undefined;
+  name?: string | undefined;
+  required?: boolean | undefined;
+  type: VariableType;
+};
+
+/** @internal */
+export const AnalyticsVariable$inboundSchema: z.ZodMiniType<
+  AnalyticsVariable,
+  unknown
+> = z.object({
+  default: types.optional(z.array(types.string())),
+  name: types.optional(types.string()),
+  required: types.optional(types.boolean()),
+  type: VariableType$inboundSchema,
+});
+/** @internal */
+export type AnalyticsVariable$Outbound = {
+  default?: Array<string> | undefined;
+  name?: string | undefined;
+  required?: boolean | undefined;
+  type: string;
+};
+
+/** @internal */
+export const AnalyticsVariable$outboundSchema: z.ZodMiniType<
+  AnalyticsVariable$Outbound,
+  AnalyticsVariable
+> = z.object({
+  default: z.optional(z.array(z.string())),
+  name: z.optional(z.string()),
+  required: z.optional(z.boolean()),
+  type: VariableType$outboundSchema,
+});
+
+export function analyticsVariableToJSON(
+  analyticsVariable: AnalyticsVariable,
+): string {
+  return JSON.stringify(
+    AnalyticsVariable$outboundSchema.parse(analyticsVariable),
+  );
+}
+export function analyticsVariableFromJSON(
+  jsonString: string,
+): SafeParseResult<AnalyticsVariable, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AnalyticsVariable$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AnalyticsVariable' from JSON`,
+  );
+}

package/src/sdk/models/analytics-view-definition.ts

@@ -0,0 +1,108 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import {
+  AnalyticsFilter,
+  AnalyticsFilter$inboundSchema,
+  AnalyticsFilter$Outbound,
+  AnalyticsFilter$outboundSchema,
+} from "./analytics-filter.js";
+import {
+  AnalyticsSortSpec,
+  AnalyticsSortSpec$inboundSchema,
+  AnalyticsSortSpec$Outbound,
+  AnalyticsSortSpec$outboundSchema,
+} from "./analytics-sort-spec.js";
+import {
+  AnalyticsTimeSpecRaw,
+  AnalyticsTimeSpecRaw$inboundSchema,
+  AnalyticsTimeSpecRaw$Outbound,
+  AnalyticsTimeSpecRaw$outboundSchema,
+} from "./analytics-time-spec-raw.js";
+import {
+  AnalyticsVariable,
+  AnalyticsVariable$inboundSchema,
+  AnalyticsVariable$Outbound,
+  AnalyticsVariable$outboundSchema,
+} from "./analytics-variable.js";
+import {
+  Metric,
+  Metric$inboundSchema,
+  Metric$outboundSchema,
+} from "./metric.js";
+import { SDKValidationError } from "./sdk-validation-error.js";
+import { Shape, Shape$inboundSchema, Shape$outboundSchema } from "./shape.js";
+
+export type AnalyticsViewDefinition = {
+  dimensions?: Array<string> | undefined;
+  filters?: Array<AnalyticsFilter> | undefined;
+  limit?: number | undefined;
+  metrics: Array<Metric>;
+  shape: Shape;
+  sort?: Array<AnalyticsSortSpec> | undefined;
+  time?: AnalyticsTimeSpecRaw | undefined;
+  variables?: Array<AnalyticsVariable> | undefined;
+};
+
+/** @internal */
+export const AnalyticsViewDefinition$inboundSchema: z.ZodMiniType<
+  AnalyticsViewDefinition,
+  unknown
+> = z.object({
+  dimensions: types.optional(z.array(types.string())),
+  filters: types.optional(z.array(AnalyticsFilter$inboundSchema)),
+  limit: types.optional(types.number()),
+  metrics: z.array(Metric$inboundSchema),
+  shape: Shape$inboundSchema,
+  sort: types.optional(z.array(AnalyticsSortSpec$inboundSchema)),
+  time: types.optional(AnalyticsTimeSpecRaw$inboundSchema),
+  variables: types.optional(z.array(AnalyticsVariable$inboundSchema)),
+});
+/** @internal */
+export type AnalyticsViewDefinition$Outbound = {
+  dimensions?: Array<string> | undefined;
+  filters?: Array<AnalyticsFilter$Outbound> | undefined;
+  limit?: number | undefined;
+  metrics: Array<string>;
+  shape: string;
+  sort?: Array<AnalyticsSortSpec$Outbound> | undefined;
+  time?: AnalyticsTimeSpecRaw$Outbound | undefined;
+  variables?: Array<AnalyticsVariable$Outbound> | undefined;
+};
+
+/** @internal */
+export const AnalyticsViewDefinition$outboundSchema: z.ZodMiniType<
+  AnalyticsViewDefinition$Outbound,
+  AnalyticsViewDefinition
+> = z.object({
+  dimensions: z.optional(z.array(z.string())),
+  filters: z.optional(z.array(AnalyticsFilter$outboundSchema)),
+  limit: z.optional(z.int()),
+  metrics: z.array(Metric$outboundSchema),
+  shape: Shape$outboundSchema,
+  sort: z.optional(z.array(AnalyticsSortSpec$outboundSchema)),
+  time: z.optional(AnalyticsTimeSpecRaw$outboundSchema),
+  variables: z.optional(z.array(AnalyticsVariable$outboundSchema)),
+});
+
+export function analyticsViewDefinitionToJSON(
+  analyticsViewDefinition: AnalyticsViewDefinition,
+): string {
+  return JSON.stringify(
+    AnalyticsViewDefinition$outboundSchema.parse(analyticsViewDefinition),
+  );
+}
+export function analyticsViewDefinitionFromJSON(
+  jsonString: string,
+): SafeParseResult<AnalyticsViewDefinition, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AnalyticsViewDefinition$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AnalyticsViewDefinition' from JSON`,
+  );
+}