@greensecurity/javascript-sdk 0.44.0-beta.6 → 0.44.0-beta.61

package/src/models/components/invoiceitem.ts

@@ -9,10 +9,17 @@ import { Result as SafeParseResult } from "../../types/fp.js";
 import * as types from "../../types/primitives.js";
 import { smartUnion } from "../../types/smartUnion.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
-import { Product, Product$inboundSchema } from "./product.js";
+import {
+  Product,
+  Product$inboundSchema,
+  Product$Outbound,
+  Product$outboundSchema,
+} from "./product.js";
 import {
   ProductVariant,
   ProductVariant$inboundSchema,
+  ProductVariant$Outbound,
+  ProductVariant$outboundSchema,
 } from "./productvariant.js";
 
 export type Variant = ProductVariant | number;
@@ -48,7 +55,19 @@ export type InvoiceItem = {
 /** @internal */
 export const Variant$inboundSchema: z.ZodType<Variant, z.ZodTypeDef, unknown> =
   smartUnion([ProductVariant$inboundSchema, types.number()]);
+/** @internal */
+export type Variant$Outbound = ProductVariant$Outbound | number;
+
+/** @internal */
+export const Variant$outboundSchema: z.ZodType<
+  Variant$Outbound,
+  z.ZodTypeDef,
+  Variant
+> = smartUnion([ProductVariant$outboundSchema, z.number().int()]);
 
+export function variantToJSON(variant: Variant): string {
+  return JSON.stringify(Variant$outboundSchema.parse(variant));
+}
 export function variantFromJSON(
   jsonString: string,
 ): SafeParseResult<Variant, SDKValidationError> {
@@ -65,7 +84,23 @@ export const InvoiceItemProduct$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = smartUnion([Product$inboundSchema, types.number()]);
+/** @internal */
+export type InvoiceItemProduct$Outbound = Product$Outbound | number;
 
+/** @internal */
+export const InvoiceItemProduct$outboundSchema: z.ZodType<
+  InvoiceItemProduct$Outbound,
+  z.ZodTypeDef,
+  InvoiceItemProduct
+> = smartUnion([Product$outboundSchema, z.number().int()]);
+
+export function invoiceItemProductToJSON(
+  invoiceItemProduct: InvoiceItemProduct,
+): string {
+  return JSON.stringify(
+    InvoiceItemProduct$outboundSchema.parse(invoiceItemProduct),
+  );
+}
 export function invoiceItemProductFromJSON(
   jsonString: string,
 ): SafeParseResult<InvoiceItemProduct, SDKValidationError> {
@@ -90,7 +125,35 @@ export const Details$inboundSchema: z.ZodType<Details, z.ZodTypeDef, unknown> =
       "used_days": "usedDays",
     });
   });
+/** @internal */
+export type Details$Outbound = {
+  total_days?: number | null | undefined;
+  unused_days?: number | null | undefined;
+  used_days?: number | null | undefined;
+  prorate?: number | null | undefined;
+};
 
+/** @internal */
+export const Details$outboundSchema: z.ZodType<
+  Details$Outbound,
+  z.ZodTypeDef,
+  Details
+> = z.object({
+  totalDays: z.nullable(z.number().int()).optional(),
+  unusedDays: z.nullable(z.number().int()).optional(),
+  usedDays: z.nullable(z.number().int()).optional(),
+  prorate: z.nullable(z.number()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    totalDays: "total_days",
+    unusedDays: "unused_days",
+    usedDays: "used_days",
+  });
+});
+
+export function detailsToJSON(details: Details): string {
+  return JSON.stringify(Details$outboundSchema.parse(details));
+}
 export function detailsFromJSON(
   jsonString: string,
 ): SafeParseResult<Details, SDKValidationError> {
@@ -132,7 +195,58 @@ export const InvoiceItem$inboundSchema: z.ZodType<
     "unit_price": "unitPrice",
   });
 });
+/** @internal */
+export type InvoiceItem$Outbound = {
+  id?: number | undefined;
+  date_starts?: string | null | undefined;
+  date_ends?: string | null | undefined;
+  is_subscription?: boolean | null | undefined;
+  product_title?: string | null | undefined;
+  title?: string | null | undefined;
+  quantity?: number | null | undefined;
+  unit_price?: number | null | undefined;
+  discount?: number | undefined;
+  subtotal?: number | null | undefined;
+  variant?: ProductVariant$Outbound | number | null | undefined;
+  product?: Product$Outbound | number | null | undefined;
+  details?: Details$Outbound | null | undefined;
+};
 
+/** @internal */
+export const InvoiceItem$outboundSchema: z.ZodType<
+  InvoiceItem$Outbound,
+  z.ZodTypeDef,
+  InvoiceItem
+> = z.object({
+  id: z.number().int().optional(),
+  dateStarts: z.nullable(z.string()).optional(),
+  dateEnds: z.nullable(z.string()).optional(),
+  isSubscription: z.nullable(z.boolean()).optional(),
+  productTitle: z.nullable(z.string()).optional(),
+  title: z.nullable(z.string()).optional(),
+  quantity: z.nullable(z.number()).optional(),
+  unitPrice: z.nullable(z.number().int()).optional(),
+  discount: z.number().int().optional(),
+  subtotal: z.nullable(z.number().int()).optional(),
+  variant: z.nullable(
+    smartUnion([ProductVariant$outboundSchema, z.number().int()]),
+  ).optional(),
+  product: z.nullable(smartUnion([Product$outboundSchema, z.number().int()]))
+    .optional(),
+  details: z.nullable(z.lazy(() => Details$outboundSchema)).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    dateStarts: "date_starts",
+    dateEnds: "date_ends",
+    isSubscription: "is_subscription",
+    productTitle: "product_title",
+    unitPrice: "unit_price",
+  });
+});
+
+export function invoiceItemToJSON(invoiceItem: InvoiceItem): string {
+  return JSON.stringify(InvoiceItem$outboundSchema.parse(invoiceItem));
+}
 export function invoiceItemFromJSON(
   jsonString: string,
 ): SafeParseResult<InvoiceItem, SDKValidationError> {

package/src/models/components/invoicetransaction.ts

@@ -12,6 +12,8 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
   PaymentProfile,
   PaymentProfile$inboundSchema,
+  PaymentProfile$Outbound,
+  PaymentProfile$outboundSchema,
 } from "./paymentprofile.js";
 
 export type InvoiceTransactionPaymentProfile = PaymentProfile | number;
@@ -34,7 +36,27 @@ export const InvoiceTransactionPaymentProfile$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = smartUnion([PaymentProfile$inboundSchema, types.number()]);
+/** @internal */
+export type InvoiceTransactionPaymentProfile$Outbound =
+  | PaymentProfile$Outbound
+  | number;
+
+/** @internal */
+export const InvoiceTransactionPaymentProfile$outboundSchema: z.ZodType<
+  InvoiceTransactionPaymentProfile$Outbound,
+  z.ZodTypeDef,
+  InvoiceTransactionPaymentProfile
+> = smartUnion([PaymentProfile$outboundSchema, z.number().int()]);
 
+export function invoiceTransactionPaymentProfileToJSON(
+  invoiceTransactionPaymentProfile: InvoiceTransactionPaymentProfile,
+): string {
+  return JSON.stringify(
+    InvoiceTransactionPaymentProfile$outboundSchema.parse(
+      invoiceTransactionPaymentProfile,
+    ),
+  );
+}
 export function invoiceTransactionPaymentProfileFromJSON(
   jsonString: string,
 ): SafeParseResult<InvoiceTransactionPaymentProfile, SDKValidationError> {
@@ -67,7 +89,46 @@ export const InvoiceTransaction$inboundSchema: z.ZodType<
     "transaction_id": "transactionId",
   });
 });
+/** @internal */
+export type InvoiceTransaction$Outbound = {
+  date_processed?: string | null | undefined;
+  payment_profile?: PaymentProfile$Outbound | number | null | undefined;
+  amount?: number | null | undefined;
+  credit_id?: number | null | undefined;
+  transaction_id?: string | null | undefined;
+  success?: boolean | null | undefined;
+};
 
+/** @internal */
+export const InvoiceTransaction$outboundSchema: z.ZodType<
+  InvoiceTransaction$Outbound,
+  z.ZodTypeDef,
+  InvoiceTransaction
+> = z.object({
+  dateProcessed: z.nullable(z.string()).optional(),
+  paymentProfile: z.nullable(
+    smartUnion([PaymentProfile$outboundSchema, z.number().int()]),
+  ).optional(),
+  amount: z.nullable(z.number().int()).optional(),
+  creditId: z.nullable(z.number().int()).optional(),
+  transactionId: z.nullable(z.string()).optional(),
+  success: z.nullable(z.boolean()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    dateProcessed: "date_processed",
+    paymentProfile: "payment_profile",
+    creditId: "credit_id",
+    transactionId: "transaction_id",
+  });
+});
+
+export function invoiceTransactionToJSON(
+  invoiceTransaction: InvoiceTransaction,
+): string {
+  return JSON.stringify(
+    InvoiceTransaction$outboundSchema.parse(invoiceTransaction),
+  );
+}
 export function invoiceTransactionFromJSON(
   jsonString: string,
 ): SafeParseResult<InvoiceTransaction, SDKValidationError> {

package/src/models/components/paymentprofile.ts

@@ -34,7 +34,23 @@ export const PaymentProfile22$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({});
+/** @internal */
+export type PaymentProfile22$Outbound = {};
+
+/** @internal */
+export const PaymentProfile22$outboundSchema: z.ZodType<
+  PaymentProfile22$Outbound,
+  z.ZodTypeDef,
+  PaymentProfile22
+> = z.object({});
 
+export function paymentProfile22ToJSON(
+  paymentProfile22: PaymentProfile22,
+): string {
+  return JSON.stringify(
+    PaymentProfile22$outboundSchema.parse(paymentProfile22),
+  );
+}
 export function paymentProfile22FromJSON(
   jsonString: string,
 ): SafeParseResult<PaymentProfile22, SDKValidationError> {
@@ -51,7 +67,24 @@ export const PaymentProfile2$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = smartUnion([types.number(), z.lazy(() => PaymentProfile22$inboundSchema)]);
+/** @internal */
+export type PaymentProfile2$Outbound = number | PaymentProfile22$Outbound;
 
+/** @internal */
+export const PaymentProfile2$outboundSchema: z.ZodType<
+  PaymentProfile2$Outbound,
+  z.ZodTypeDef,
+  PaymentProfile2
+> = smartUnion([
+  z.number().int(),
+  z.lazy(() => PaymentProfile22$outboundSchema),
+]);
+
+export function paymentProfile2ToJSON(
+  paymentProfile2: PaymentProfile2,
+): string {
+  return JSON.stringify(PaymentProfile2$outboundSchema.parse(paymentProfile2));
+}
 export function paymentProfile2FromJSON(
   jsonString: string,
 ): SafeParseResult<PaymentProfile2, SDKValidationError> {
@@ -83,7 +116,43 @@ export const PaymentProfile3$inboundSchema: z.ZodType<
     "profile_type": "profileType",
   });
 });
+/** @internal */
+export type PaymentProfile3$Outbound = {
+  id?: number | undefined;
+  is_valid?: boolean | null | undefined;
+  card_type?: string | null | undefined;
+  card_last4?: string | null | undefined;
+  is_dummy?: boolean | null | undefined;
+  profile_type?: string | null | undefined;
+};
 
+/** @internal */
+export const PaymentProfile3$outboundSchema: z.ZodType<
+  PaymentProfile3$Outbound,
+  z.ZodTypeDef,
+  PaymentProfile3
+> = z.object({
+  id: z.number().int().optional(),
+  isValid: z.nullable(z.boolean()).optional(),
+  cardType: z.nullable(z.string()).optional(),
+  cardLast4: z.nullable(z.string()).optional(),
+  isDummy: z.nullable(z.boolean()).optional(),
+  profileType: z.nullable(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    isValid: "is_valid",
+    cardType: "card_type",
+    cardLast4: "card_last4",
+    isDummy: "is_dummy",
+    profileType: "profile_type",
+  });
+});
+
+export function paymentProfile3ToJSON(
+  paymentProfile3: PaymentProfile3,
+): string {
+  return JSON.stringify(PaymentProfile3$outboundSchema.parse(paymentProfile3));
+}
 export function paymentProfile3FromJSON(
   jsonString: string,
 ): SafeParseResult<PaymentProfile3, SDKValidationError> {
@@ -103,7 +172,25 @@ export const PaymentProfile$inboundSchema: z.ZodType<
   z.lazy(() => PaymentProfile3$inboundSchema),
   smartUnion([types.number(), z.lazy(() => PaymentProfile22$inboundSchema)]),
 ]);
+/** @internal */
+export type PaymentProfile$Outbound =
+  | PaymentProfile3$Outbound
+  | number
+  | PaymentProfile22$Outbound;
+
+/** @internal */
+export const PaymentProfile$outboundSchema: z.ZodType<
+  PaymentProfile$Outbound,
+  z.ZodTypeDef,
+  PaymentProfile
+> = smartUnion([
+  z.lazy(() => PaymentProfile3$outboundSchema),
+  smartUnion([z.number().int(), z.lazy(() => PaymentProfile22$outboundSchema)]),
+]);
 
+export function paymentProfileToJSON(paymentProfile: PaymentProfile): string {
+  return JSON.stringify(PaymentProfile$outboundSchema.parse(paymentProfile));
+}
 export function paymentProfileFromJSON(
   jsonString: string,
 ): SafeParseResult<PaymentProfile, SDKValidationError> {

package/src/models/components/product.ts

@@ -24,7 +24,27 @@ export const Product$inboundSchema: z.ZodType<Product, z.ZodTypeDef, unknown> =
     title: z.nullable(types.string()).optional(),
     description: z.nullable(types.string()).optional(),
   });
+/** @internal */
+export type Product$Outbound = {
+  id?: number | undefined;
+  title?: string | null | undefined;
+  description?: string | null | undefined;
+};
+
+/** @internal */
+export const Product$outboundSchema: z.ZodType<
+  Product$Outbound,
+  z.ZodTypeDef,
+  Product
+> = z.object({
+  id: z.number().int().optional(),
+  title: z.nullable(z.string()).optional(),
+  description: z.nullable(z.string()).optional(),
+});
 
+export function productToJSON(product: Product): string {
+  return JSON.stringify(Product$outboundSchema.parse(product));
+}
 export function productFromJSON(
   jsonString: string,
 ): SafeParseResult<Product, SDKValidationError> {

package/src/models/components/productvariant.ts

@@ -10,11 +10,18 @@ import { Result as SafeParseResult } from "../../types/fp.js";
 import * as types from "../../types/primitives.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
+/**
+ * Subscription interval of variant, if any.
+ */
 export const Recurrence = {
   Monthly: "monthly",
   Yearly: "yearly",
+  NinetyDays: "90_days",
   Once: "once",
 } as const;
+/**
+ * Subscription interval of variant, if any.
+ */
 export type Recurrence = OpenEnum<typeof Recurrence>;
 
 /**
@@ -24,6 +31,9 @@ export type ProductVariant = {
   id?: number | undefined;
   price?: number | undefined;
   title?: string | null | undefined;
+  /**
+   * Subscription interval of variant, if any.
+   */
   recurrence?: Recurrence | null | undefined;
 };
 
@@ -33,6 +43,12 @@ export const Recurrence$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = openEnums.inboundSchema(Recurrence);
+/** @internal */
+export const Recurrence$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  Recurrence
+> = openEnums.outboundSchema(Recurrence);
 
 /** @internal */
 export const ProductVariant$inboundSchema: z.ZodType<
@@ -45,7 +61,29 @@ export const ProductVariant$inboundSchema: z.ZodType<
   title: z.nullable(types.string()).optional(),
   recurrence: z.nullable(Recurrence$inboundSchema).optional(),
 });
+/** @internal */
+export type ProductVariant$Outbound = {
+  id?: number | undefined;
+  price?: number | undefined;
+  title?: string | null | undefined;
+  recurrence?: string | null | undefined;
+};
+
+/** @internal */
+export const ProductVariant$outboundSchema: z.ZodType<
+  ProductVariant$Outbound,
+  z.ZodTypeDef,
+  ProductVariant
+> = z.object({
+  id: z.number().int().optional(),
+  price: z.number().int().optional(),
+  title: z.nullable(z.string()).optional(),
+  recurrence: z.nullable(Recurrence$outboundSchema).optional(),
+});
 
+export function productVariantToJSON(productVariant: ProductVariant): string {
+  return JSON.stringify(ProductVariant$outboundSchema.parse(productVariant));
+}
 export function productVariantFromJSON(
   jsonString: string,
 ): SafeParseResult<ProductVariant, SDKValidationError> {

package/src/models/components/subscription.ts

@@ -11,11 +11,19 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
   FinancialStatus,
   FinancialStatus$inboundSchema,
+  FinancialStatus$outboundSchema,
 } from "./financialstatus.js";
-import { InvoiceItem, InvoiceItem$inboundSchema } from "./invoiceitem.js";
+import {
+  InvoiceItem,
+  InvoiceItem$inboundSchema,
+  InvoiceItem$Outbound,
+  InvoiceItem$outboundSchema,
+} from "./invoiceitem.js";
 import {
   ProductVariant,
   ProductVariant$inboundSchema,
+  ProductVariant$Outbound,
+  ProductVariant$outboundSchema,
 } from "./productvariant.js";
 
 /**
@@ -71,7 +79,54 @@ export const Subscription$inboundSchema: z.ZodType<
     "expedited_offer": "expeditedOffer",
   });
 });
+/** @internal */
+export type Subscription$Outbound = {
+  id?: number | null | undefined;
+  date_started?: string | null | undefined;
+  date_ends?: string | null | undefined;
+  status?: string | null | undefined;
+  locked?: boolean | null | undefined;
+  variant_title?: string | undefined;
+  current_line_item?: InvoiceItem$Outbound | null | undefined;
+  next_line_item?: InvoiceItem$Outbound | null | undefined;
+  current_financial_status?: string | null | undefined;
+  next_financial_status?: string | null | undefined;
+  expedited_offer?: ProductVariant$Outbound | null | undefined;
+};
 
+/** @internal */
+export const Subscription$outboundSchema: z.ZodType<
+  Subscription$Outbound,
+  z.ZodTypeDef,
+  Subscription
+> = z.object({
+  id: z.nullable(z.number().int()).optional(),
+  dateStarted: z.nullable(z.string()).optional(),
+  dateEnds: z.nullable(z.string()).optional(),
+  status: z.nullable(z.string()).optional(),
+  locked: z.nullable(z.boolean()).optional(),
+  variantTitle: z.string().optional(),
+  currentLineItem: z.nullable(InvoiceItem$outboundSchema).optional(),
+  nextLineItem: z.nullable(InvoiceItem$outboundSchema).optional(),
+  currentFinancialStatus: z.nullable(FinancialStatus$outboundSchema).optional(),
+  nextFinancialStatus: z.nullable(FinancialStatus$outboundSchema).optional(),
+  expeditedOffer: z.nullable(ProductVariant$outboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    dateStarted: "date_started",
+    dateEnds: "date_ends",
+    variantTitle: "variant_title",
+    currentLineItem: "current_line_item",
+    nextLineItem: "next_line_item",
+    currentFinancialStatus: "current_financial_status",
+    nextFinancialStatus: "next_financial_status",
+    expeditedOffer: "expedited_offer",
+  });
+});
+
+export function subscriptionToJSON(subscription: Subscription): string {
+  return JSON.stringify(Subscription$outboundSchema.parse(subscription));
+}
 export function subscriptionFromJSON(
   jsonString: string,
 ): SafeParseResult<Subscription, SDKValidationError> {

package/src/models/components/systemsummary.ts

@@ -11,6 +11,8 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
   FacilitySummary,
   FacilitySummary$inboundSchema,
+  FacilitySummary$Outbound,
+  FacilitySummary$outboundSchema,
 } from "./facilitysummary.js";
 
 export type Location = {
@@ -38,7 +40,25 @@ export const Location$inboundSchema: z.ZodType<
   city: z.nullable(types.string()).optional(),
   state: z.nullable(types.string()).optional(),
 });
+/** @internal */
+export type Location$Outbound = {
+  city?: string | null | undefined;
+  state?: string | null | undefined;
+};
+
+/** @internal */
+export const Location$outboundSchema: z.ZodType<
+  Location$Outbound,
+  z.ZodTypeDef,
+  Location
+> = z.object({
+  city: z.nullable(z.string()).optional(),
+  state: z.nullable(z.string()).optional(),
+});
 
+export function locationToJSON(location: Location): string {
+  return JSON.stringify(Location$outboundSchema.parse(location));
+}
 export function locationFromJSON(
   jsonString: string,
 ): SafeParseResult<Location, SDKValidationError> {
@@ -65,7 +85,35 @@ export const SystemSummary$inboundSchema: z.ZodType<
     "start_date": "startDate",
   });
 });
+/** @internal */
+export type SystemSummary$Outbound = {
+  id: number;
+  name: string;
+  start_date?: string | null | undefined;
+  location?: Location$Outbound | null | undefined;
+  facilities?: Array<FacilitySummary$Outbound> | null | undefined;
+};
 
+/** @internal */
+export const SystemSummary$outboundSchema: z.ZodType<
+  SystemSummary$Outbound,
+  z.ZodTypeDef,
+  SystemSummary
+> = z.object({
+  id: z.number().int(),
+  name: z.string(),
+  startDate: z.nullable(z.string()).optional(),
+  location: z.nullable(z.lazy(() => Location$outboundSchema)).optional(),
+  facilities: z.nullable(z.array(FacilitySummary$outboundSchema)).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    startDate: "start_date",
+  });
+});
+
+export function systemSummaryToJSON(systemSummary: SystemSummary): string {
+  return JSON.stringify(SystemSummary$outboundSchema.parse(systemSummary));
+}
 export function systemSummaryFromJSON(
   jsonString: string,
 ): SafeParseResult<SystemSummary, SDKValidationError> {