@gr4vy/sdk 1.6.2 → 1.6.4

package/src/models/components/refund.ts

@@ -7,21 +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 { SDKValidationError } from "../errors/sdkvalidationerror.js";
-import {
-  Creator,
-  Creator$inboundSchema,
-  Creator$Outbound,
-  Creator$outboundSchema,
-} from "./creator.js";
-import {
-  RefundStatus,
-  RefundStatus$inboundSchema,
-  RefundStatus$outboundSchema,
-} from "./refundstatus.js";
+import { Creator, Creator$inboundSchema } from "./creator.js";
+import { RefundStatus, RefundStatus$inboundSchema } from "./refundstatus.js";
 import {
   RefundTargetType,
   RefundTargetType$inboundSchema,
-  RefundTargetType$outboundSchema,
 } from "./refundtargettype.js";
 
 export type Refund = {
@@ -146,91 +136,6 @@ export const Refund$inboundSchema: z.ZodType<Refund, z.ZodTypeDef, unknown> = z
     });
   });
 
-/** @internal */
-export type Refund$Outbound = {
-  type: "refund";
-  id: string;
-  transaction_id: string;
-  payment_service_refund_id?: string | null | undefined;
-  status: string;
-  currency: string;
-  amount: number;
-  reason?: string | null | undefined;
-  target_type: string;
-  target_id?: string | null | undefined;
-  reconciliation_id: string;
-  external_identifier?: string | null | undefined;
-  transaction_reconciliation_id: string;
-  transaction_external_identifier?: string | null | undefined;
-  created_at: string;
-  updated_at: string;
-  creator?: Creator$Outbound | null | undefined;
-  error_code?: string | null | undefined;
-  raw_response_code?: string | null | undefined;
-  raw_response_description?: string | null | undefined;
-};
-
-/** @internal */
-export const Refund$outboundSchema: z.ZodType<
-  Refund$Outbound,
-  z.ZodTypeDef,
-  Refund
-> = z.object({
-  type: z.literal("refund").default("refund" as const),
-  id: z.string(),
-  transactionId: z.string(),
-  paymentServiceRefundId: z.nullable(z.string()).optional(),
-  status: RefundStatus$outboundSchema,
-  currency: z.string(),
-  amount: z.number().int(),
-  reason: z.nullable(z.string()).optional(),
-  targetType: RefundTargetType$outboundSchema,
-  targetId: z.nullable(z.string()).optional(),
-  reconciliationId: z.string(),
-  externalIdentifier: z.nullable(z.string()).optional(),
-  transactionReconciliationId: z.string(),
-  transactionExternalIdentifier: z.nullable(z.string()).optional(),
-  createdAt: z.date().transform(v => v.toISOString()),
-  updatedAt: z.date().transform(v => v.toISOString()),
-  creator: z.nullable(Creator$outboundSchema).optional(),
-  errorCode: z.nullable(z.string()).optional(),
-  rawResponseCode: z.nullable(z.string()).optional(),
-  rawResponseDescription: z.nullable(z.string()).optional(),
-}).transform((v) => {
-  return remap$(v, {
-    transactionId: "transaction_id",
-    paymentServiceRefundId: "payment_service_refund_id",
-    targetType: "target_type",
-    targetId: "target_id",
-    reconciliationId: "reconciliation_id",
-    externalIdentifier: "external_identifier",
-    transactionReconciliationId: "transaction_reconciliation_id",
-    transactionExternalIdentifier: "transaction_external_identifier",
-    createdAt: "created_at",
-    updatedAt: "updated_at",
-    errorCode: "error_code",
-    rawResponseCode: "raw_response_code",
-    rawResponseDescription: "raw_response_description",
-  });
-});
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace Refund$ {
-  /** @deprecated use `Refund$inboundSchema` instead. */
-  export const inboundSchema = Refund$inboundSchema;
-  /** @deprecated use `Refund$outboundSchema` instead. */
-  export const outboundSchema = Refund$outboundSchema;
-  /** @deprecated use `Refund$Outbound` instead. */
-  export type Outbound = Refund$Outbound;
-}
-
-export function refundToJSON(refund: Refund): string {
-  return JSON.stringify(Refund$outboundSchema.parse(refund));
-}
-
 export function refundFromJSON(
   jsonString: string,
 ): SafeParseResult<Refund, SDKValidationError> {

package/src/models/components/refunds.ts

@@ -7,12 +7,7 @@ import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
-import {
-  Refund,
-  Refund$inboundSchema,
-  Refund$Outbound,
-  Refund$outboundSchema,
-} from "./refund.js";
+import { Refund, Refund$inboundSchema } from "./refund.js";
 
 export type Refunds = {
   /**
@@ -47,48 +42,6 @@ export const Refunds$inboundSchema: z.ZodType<Refunds, z.ZodTypeDef, unknown> =
     });
   });
 
-/** @internal */
-export type Refunds$Outbound = {
-  items: Array<Refund$Outbound>;
-  limit: number;
-  next_cursor?: string | null | undefined;
-  previous_cursor?: string | null | undefined;
-};
-
-/** @internal */
-export const Refunds$outboundSchema: z.ZodType<
-  Refunds$Outbound,
-  z.ZodTypeDef,
-  Refunds
-> = z.object({
-  items: z.array(Refund$outboundSchema),
-  limit: z.number().int().default(20),
-  nextCursor: z.nullable(z.string()).optional(),
-  previousCursor: z.nullable(z.string()).optional(),
-}).transform((v) => {
-  return remap$(v, {
-    nextCursor: "next_cursor",
-    previousCursor: "previous_cursor",
-  });
-});
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace Refunds$ {
-  /** @deprecated use `Refunds$inboundSchema` instead. */
-  export const inboundSchema = Refunds$inboundSchema;
-  /** @deprecated use `Refunds$outboundSchema` instead. */
-  export const outboundSchema = Refunds$outboundSchema;
-  /** @deprecated use `Refunds$Outbound` instead. */
-  export type Outbound = Refunds$Outbound;
-}
-
-export function refundsToJSON(refunds: Refunds): string {
-  return JSON.stringify(Refunds$outboundSchema.parse(refunds));
-}
-
 export function refundsFromJSON(
   jsonString: string,
 ): SafeParseResult<Refunds, SDKValidationError> {

package/src/models/components/refundstatus.ts

@@ -3,11 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import {
-  catchUnrecognizedEnum,
-  OpenEnum,
-  Unrecognized,
-} from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 export const RefundStatus = {
   Processing: "processing",
@@ -23,29 +20,4 @@ export const RefundStatus$inboundSchema: z.ZodType<
   RefundStatus,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(RefundStatus),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
-
-/** @internal */
-export const RefundStatus$outboundSchema: z.ZodType<
-  RefundStatus,
-  z.ZodTypeDef,
-  RefundStatus
-> = z.union([
-  z.nativeEnum(RefundStatus),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace RefundStatus$ {
-  /** @deprecated use `RefundStatus$inboundSchema` instead. */
-  export const inboundSchema = RefundStatus$inboundSchema;
-  /** @deprecated use `RefundStatus$outboundSchema` instead. */
-  export const outboundSchema = RefundStatus$outboundSchema;
-}
+> = openEnums.inboundSchema(RefundStatus);

package/src/models/components/refundtargettype.ts

@@ -3,11 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import {
-  catchUnrecognizedEnum,
-  OpenEnum,
-  Unrecognized,
-} from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 export const RefundTargetType = {
   PaymentMethod: "payment-method",
@@ -20,29 +17,10 @@ export const RefundTargetType$inboundSchema: z.ZodType<
   RefundTargetType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(RefundTargetType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
-
+> = openEnums.inboundSchema(RefundTargetType);
 /** @internal */
 export const RefundTargetType$outboundSchema: z.ZodType<
-  RefundTargetType,
+  string,
   z.ZodTypeDef,
   RefundTargetType
-> = z.union([
-  z.nativeEnum(RefundTargetType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace RefundTargetType$ {
-  /** @deprecated use `RefundTargetType$inboundSchema` instead. */
-  export const inboundSchema = RefundTargetType$inboundSchema;
-  /** @deprecated use `RefundTargetType$outboundSchema` instead. */
-  export const outboundSchema = RefundTargetType$outboundSchema;
-}
+> = openEnums.outboundSchema(RefundTargetType);

package/src/models/components/report.ts

@@ -10,25 +10,16 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
   ReportCreatorType,
   ReportCreatorType$inboundSchema,
-  ReportCreatorType$outboundSchema,
 } from "./reportcreatortype.js";
 import {
   ReportExecutionSummary,
   ReportExecutionSummary$inboundSchema,
-  ReportExecutionSummary$Outbound,
-  ReportExecutionSummary$outboundSchema,
 } from "./reportexecutionsummary.js";
 import {
   ReportSchedule,
   ReportSchedule$inboundSchema,
-  ReportSchedule$outboundSchema,
 } from "./reportschedule.js";
-import {
-  ReportSpec,
-  ReportSpec$inboundSchema,
-  ReportSpec$Outbound,
-  ReportSpec$outboundSchema,
-} from "./reportspec.js";
+import { ReportSpec, ReportSpec$inboundSchema } from "./reportspec.js";
 
 export type Report = {
   /**
@@ -132,81 +123,6 @@ export const Report$inboundSchema: z.ZodType<Report, z.ZodTypeDef, unknown> = z
     });
   });
 
-/** @internal */
-export type Report$Outbound = {
-  type: "report";
-  id: string;
-  merchant_account_id: string;
-  name: string;
-  creator_id?: string | null | undefined;
-  creator_display_name?: string | null | undefined;
-  creator_type?: string | null | undefined;
-  created_at: string;
-  updated_at: string;
-  next_execution_at?: string | null | undefined;
-  description?: string | null | undefined;
-  schedule: string;
-  schedule_enabled: boolean;
-  schedule_timezone: string;
-  spec: ReportSpec$Outbound;
-  latest_execution?: ReportExecutionSummary$Outbound | null | undefined;
-};
-
-/** @internal */
-export const Report$outboundSchema: z.ZodType<
-  Report$Outbound,
-  z.ZodTypeDef,
-  Report
-> = z.object({
-  type: z.literal("report").default("report" as const),
-  id: z.string(),
-  merchantAccountId: z.string(),
-  name: z.string(),
-  creatorId: z.nullable(z.string()).optional(),
-  creatorDisplayName: z.nullable(z.string()).optional(),
-  creatorType: z.nullable(ReportCreatorType$outboundSchema).optional(),
-  createdAt: z.date().transform(v => v.toISOString()),
-  updatedAt: z.date().transform(v => v.toISOString()),
-  nextExecutionAt: z.nullable(z.date().transform(v => v.toISOString()))
-    .optional(),
-  description: z.nullable(z.string()).optional(),
-  schedule: ReportSchedule$outboundSchema,
-  scheduleEnabled: z.boolean(),
-  scheduleTimezone: z.string(),
-  spec: ReportSpec$outboundSchema,
-  latestExecution: z.nullable(ReportExecutionSummary$outboundSchema).optional(),
-}).transform((v) => {
-  return remap$(v, {
-    merchantAccountId: "merchant_account_id",
-    creatorId: "creator_id",
-    creatorDisplayName: "creator_display_name",
-    creatorType: "creator_type",
-    createdAt: "created_at",
-    updatedAt: "updated_at",
-    nextExecutionAt: "next_execution_at",
-    scheduleEnabled: "schedule_enabled",
-    scheduleTimezone: "schedule_timezone",
-    latestExecution: "latest_execution",
-  });
-});
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace Report$ {
-  /** @deprecated use `Report$inboundSchema` instead. */
-  export const inboundSchema = Report$inboundSchema;
-  /** @deprecated use `Report$outboundSchema` instead. */
-  export const outboundSchema = Report$outboundSchema;
-  /** @deprecated use `Report$Outbound` instead. */
-  export type Outbound = Report$Outbound;
-}
-
-export function reportToJSON(report: Report): string {
-  return JSON.stringify(Report$outboundSchema.parse(report));
-}
-
 export function reportFromJSON(
   jsonString: string,
 ): SafeParseResult<Report, SDKValidationError> {

package/src/models/components/reportcreate.ts

@@ -4,35 +4,27 @@
 
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
-import { safeParse } from "../../lib/schemas.js";
-import { Result as SafeParseResult } from "../../types/fp.js";
-import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
   AccountsReceivablesReportSpec,
-  AccountsReceivablesReportSpec$inboundSchema,
   AccountsReceivablesReportSpec$Outbound,
   AccountsReceivablesReportSpec$outboundSchema,
 } from "./accountsreceivablesreportspec.js";
 import {
   DetailedSettlementReportSpec,
-  DetailedSettlementReportSpec$inboundSchema,
   DetailedSettlementReportSpec$Outbound,
   DetailedSettlementReportSpec$outboundSchema,
 } from "./detailedsettlementreportspec.js";
 import {
   ReportSchedule,
-  ReportSchedule$inboundSchema,
   ReportSchedule$outboundSchema,
 } from "./reportschedule.js";
 import {
   TransactionRetriesReportSpec,
-  TransactionRetriesReportSpec$inboundSchema,
   TransactionRetriesReportSpec$Outbound,
   TransactionRetriesReportSpec$outboundSchema,
 } from "./transactionretriesreportspec.js";
 import {
   TransactionsReportSpec,
-  TransactionsReportSpec$inboundSchema,
   TransactionsReportSpec$Outbound,
   TransactionsReportSpec$outboundSchema,
 } from "./transactionsreportspec.js";
@@ -74,31 +66,6 @@ export type ReportCreate = {
     | (TransactionsReportSpec & { model: "transactions" });
 };
 
-/** @internal */
-export const Spec$inboundSchema: z.ZodType<Spec, z.ZodTypeDef, unknown> = z
-  .union([
-    AccountsReceivablesReportSpec$inboundSchema.and(
-      z.object({ model: z.literal("accounts_receivables") }).transform((v) => ({
-        model: v.model,
-      })),
-    ),
-    DetailedSettlementReportSpec$inboundSchema.and(
-      z.object({ model: z.literal("detailed_settlement") }).transform((v) => ({
-        model: v.model,
-      })),
-    ),
-    TransactionRetriesReportSpec$inboundSchema.and(
-      z.object({ model: z.literal("transaction_retries") }).transform((v) => ({
-        model: v.model,
-      })),
-    ),
-    TransactionsReportSpec$inboundSchema.and(
-      z.object({ model: z.literal("transactions") }).transform((v) => ({
-        model: v.model,
-      })),
-    ),
-  ]);
-
 /** @internal */
 export type Spec$Outbound =
   | (AccountsReceivablesReportSpec$Outbound & { model: "accounts_receivables" })
@@ -131,73 +98,10 @@ export const Spec$outboundSchema: z.ZodType<Spec$Outbound, z.ZodTypeDef, Spec> =
     ),
   ]);
 
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace Spec$ {
-  /** @deprecated use `Spec$inboundSchema` instead. */
-  export const inboundSchema = Spec$inboundSchema;
-  /** @deprecated use `Spec$outboundSchema` instead. */
-  export const outboundSchema = Spec$outboundSchema;
-  /** @deprecated use `Spec$Outbound` instead. */
-  export type Outbound = Spec$Outbound;
-}
-
 export function specToJSON(spec: Spec): string {
   return JSON.stringify(Spec$outboundSchema.parse(spec));
 }
 
-export function specFromJSON(
-  jsonString: string,
-): SafeParseResult<Spec, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => Spec$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Spec' from JSON`,
-  );
-}
-
-/** @internal */
-export const ReportCreate$inboundSchema: z.ZodType<
-  ReportCreate,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  name: z.string(),
-  description: z.nullable(z.string()).optional(),
-  schedule: ReportSchedule$inboundSchema,
-  schedule_enabled: z.boolean(),
-  schedule_timezone: z.string().default("Etc/UTC"),
-  spec: z.union([
-    AccountsReceivablesReportSpec$inboundSchema.and(
-      z.object({ model: z.literal("accounts_receivables") }).transform((v) => ({
-        model: v.model,
-      })),
-    ),
-    DetailedSettlementReportSpec$inboundSchema.and(
-      z.object({ model: z.literal("detailed_settlement") }).transform((v) => ({
-        model: v.model,
-      })),
-    ),
-    TransactionRetriesReportSpec$inboundSchema.and(
-      z.object({ model: z.literal("transaction_retries") }).transform((v) => ({
-        model: v.model,
-      })),
-    ),
-    TransactionsReportSpec$inboundSchema.and(
-      z.object({ model: z.literal("transactions") }).transform((v) => ({
-        model: v.model,
-      })),
-    ),
-  ]),
-}).transform((v) => {
-  return remap$(v, {
-    "schedule_enabled": "scheduleEnabled",
-    "schedule_timezone": "scheduleTimezone",
-  });
-});
-
 /** @internal */
 export type ReportCreate$Outbound = {
   name: string;
@@ -254,29 +158,6 @@ export const ReportCreate$outboundSchema: z.ZodType<
   });
 });
 
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace ReportCreate$ {
-  /** @deprecated use `ReportCreate$inboundSchema` instead. */
-  export const inboundSchema = ReportCreate$inboundSchema;
-  /** @deprecated use `ReportCreate$outboundSchema` instead. */
-  export const outboundSchema = ReportCreate$outboundSchema;
-  /** @deprecated use `ReportCreate$Outbound` instead. */
-  export type Outbound = ReportCreate$Outbound;
-}
-
 export function reportCreateToJSON(reportCreate: ReportCreate): string {
   return JSON.stringify(ReportCreate$outboundSchema.parse(reportCreate));
 }
-
-export function reportCreateFromJSON(
-  jsonString: string,
-): SafeParseResult<ReportCreate, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => ReportCreate$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ReportCreate' from JSON`,
-  );
-}

package/src/models/components/reportcreatortype.ts

@@ -3,11 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import {
-  catchUnrecognizedEnum,
-  OpenEnum,
-  Unrecognized,
-} from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 export const ReportCreatorType = {
   User: "user",
@@ -20,29 +17,4 @@ export const ReportCreatorType$inboundSchema: z.ZodType<
   ReportCreatorType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(ReportCreatorType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
-
-/** @internal */
-export const ReportCreatorType$outboundSchema: z.ZodType<
-  ReportCreatorType,
-  z.ZodTypeDef,
-  ReportCreatorType
-> = z.union([
-  z.nativeEnum(ReportCreatorType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace ReportCreatorType$ {
-  /** @deprecated use `ReportCreatorType$inboundSchema` instead. */
-  export const inboundSchema = ReportCreatorType$inboundSchema;
-  /** @deprecated use `ReportCreatorType$outboundSchema` instead. */
-  export const outboundSchema = ReportCreatorType$outboundSchema;
-}
+> = openEnums.inboundSchema(ReportCreatorType);

package/src/models/components/reportexecution.ts

@@ -10,20 +10,12 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
   ReportExecutionContext,
   ReportExecutionContext$inboundSchema,
-  ReportExecutionContext$Outbound,
-  ReportExecutionContext$outboundSchema,
 } from "./reportexecutioncontext.js";
 import {
   ReportExecutionStatus,
   ReportExecutionStatus$inboundSchema,
-  ReportExecutionStatus$outboundSchema,
 } from "./reportexecutionstatus.js";
-import {
-  ReportSummary,
-  ReportSummary$inboundSchema,
-  ReportSummary$Outbound,
-  ReportSummary$outboundSchema,
-} from "./reportsummary.js";
+import { ReportSummary, ReportSummary$inboundSchema } from "./reportsummary.js";
 
 export type ReportExecution = {
   /**
@@ -67,56 +59,6 @@ export const ReportExecution$inboundSchema: z.ZodType<
   });
 });
 
-/** @internal */
-export type ReportExecution$Outbound = {
-  type: "report-execution";
-  id: string;
-  created_at: string;
-  updated_at: string;
-  status: string;
-  context: ReportExecutionContext$Outbound;
-  report: ReportSummary$Outbound;
-};
-
-/** @internal */
-export const ReportExecution$outboundSchema: z.ZodType<
-  ReportExecution$Outbound,
-  z.ZodTypeDef,
-  ReportExecution
-> = z.object({
-  type: z.literal("report-execution").default("report-execution" as const),
-  id: z.string(),
-  createdAt: z.date().transform(v => v.toISOString()),
-  updatedAt: z.date().transform(v => v.toISOString()),
-  status: ReportExecutionStatus$outboundSchema,
-  context: ReportExecutionContext$outboundSchema,
-  report: ReportSummary$outboundSchema,
-}).transform((v) => {
-  return remap$(v, {
-    createdAt: "created_at",
-    updatedAt: "updated_at",
-  });
-});
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace ReportExecution$ {
-  /** @deprecated use `ReportExecution$inboundSchema` instead. */
-  export const inboundSchema = ReportExecution$inboundSchema;
-  /** @deprecated use `ReportExecution$outboundSchema` instead. */
-  export const outboundSchema = ReportExecution$outboundSchema;
-  /** @deprecated use `ReportExecution$Outbound` instead. */
-  export type Outbound = ReportExecution$Outbound;
-}
-
-export function reportExecutionToJSON(
-  reportExecution: ReportExecution,
-): string {
-  return JSON.stringify(ReportExecution$outboundSchema.parse(reportExecution));
-}
-
 export function reportExecutionFromJSON(
   jsonString: string,
 ): SafeParseResult<ReportExecution, SDKValidationError> {