@greensecurity/javascript-sdk 0.44.0-beta.54 → 0.44.0-beta.56

package/src/funcs/webhooksUpdatesTheWebhookEndpointWithTheGivenId.ts

@@ -31,7 +31,31 @@ import { Result } from "../types/fp.js";
  * Updates the webhook endpoint with the given ID.
  *
  * @remarks
- * Updates the webhook endpoint with the given ID.
+ * Changes the URL, the events, their expansion scopes or the consumers of an endpoint.
+ * Anything you leave out keeps its current value.
+ *
+ * Two properties replace rather than merge: naming any consumer clears the others, and
+ * `subscriptions` replaces every event, so an event you do not list again is dropped along
+ * with its scopes. `expand` on its own, without `subscriptions`, re-scopes the events the
+ * endpoint already receives — each one takes the scopes that name its own entity, so an
+ * endpoint receiving two models can be re-scoped in a single request (send `[]` to clear every
+ * scope). A scope naming an entity the endpoint does not receive applies to nothing and is
+ * rejected. New consumers are re-authorized against your own access, so an endpoint cannot be
+ * pointed at an entity you could not have registered it for in the first place.
+ *
+ * Changing `webhook_url` is reserved to whoever registered the endpoint, and to admins.
+ * Deliveries are filtered by the registering user's access, so a new destination would receive
+ * whatever that access reaches — if you did not register it, register your own instead.
+ *
+ * Changing the URL or the consumers withdraws the deliveries still queued for this endpoint.
+ * Their payloads were serialized for the previous configuration, so they would otherwise
+ * arrive at the new destination describing the old one. Changing only `subscriptions` or
+ * `expand` leaves queued deliveries alone.
+ *
+ * The signing secret cannot be rotated here, and `id`, `signature_algo` and `secrets` are
+ * ignored if you send them back.
+ *
+ * Requires the `webhook` / `edit` permission.
  */
 export function webhooksUpdatesTheWebhookEndpointWithTheGivenId(
   client: GreenSecurityCore,
@@ -90,7 +114,9 @@ async function $do(
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = encodeJSON("body", payload.WebhookEndpoint, { explode: true });
+  const body = encodeJSON("body", payload.WebhookEndpointUpdate, {
+    explode: true,
+  });
 
   const pathParams = {
     id: encodeSimple("id", payload.id, {
@@ -167,7 +193,7 @@ async function $do(
     | SDKValidationError
   >(
     M.json(200, components.WebhookEndpoint$inboundSchema),
-    M.jsonErr([400, 401, 403, 404], errors.ApiErrorResponse$inboundSchema),
+    M.jsonErr([400, 401, 403, 404, 422], errors.ApiErrorResponse$inboundSchema),
     M.fail("4XX"),
     M.fail([500, "5XX"]),
   )(response, req, { extraFields: responseFields });

package/src/hooks/hooks.ts

@@ -3,6 +3,8 @@
  */
 
 import { RequestInput } from "../lib/http.js";
+import { ERR, Result } from "../types/fp.js";
+import { WebhookAuthenticationError } from "../types/webhooks.js";
 import {
   AfterErrorContext,
   AfterErrorHook,
@@ -16,7 +18,10 @@ import {
   Hooks,
   SDKInitHook,
   SDKInitOptions,
+  WebhookVerificationContext,
+  WebhookVerificationHook,
 } from "./types.js";
+import { WebhookSecurityHook } from "./webhook-security-custom.js";
 
 import { initHooks } from "./registration.js";
 
@@ -26,9 +31,12 @@ export class SDKHooks implements Hooks {
   beforeRequestHooks: BeforeRequestHook[] = [];
   afterSuccessHooks: AfterSuccessHook[] = [];
   afterErrorHooks: AfterErrorHook[] = [];
+  webhookVerificationHooks: WebhookVerificationHook[] = [];
 
   constructor() {
-    const presetHooks: Array<Hook> = [];
+    const presetHooks: Array<Hook> = [
+      new WebhookSecurityHook(),
+    ];
 
     for (const hook of presetHooks) {
       if ("sdkInit" in hook) {
@@ -46,6 +54,9 @@ export class SDKHooks implements Hooks {
       if ("afterError" in hook) {
         this.registerAfterErrorHook(hook);
       }
+      if ("verifyWebhook" in hook) {
+        this.registerWebhookVerificationHook(hook);
+      }
     }
     initHooks(this);
   }
@@ -129,4 +140,24 @@ export class SDKHooks implements Hooks {
 
     return { response: res, error: err };
   }
+
+  registerWebhookVerificationHook(hook: WebhookVerificationHook) {
+    this.webhookVerificationHooks.push(hook);
+  }
+
+  async verifyWebhook(
+    hookCtx: WebhookVerificationContext,
+    { request, secret }: { request: Request; secret: string },
+  ): Promise<Result<true, WebhookAuthenticationError>> {
+    let result: Result<true, WebhookAuthenticationError> = ERR(
+      new WebhookAuthenticationError("No hooks registered to verify webhooks"),
+    );
+    for (const hook of this.webhookVerificationHooks) {
+      result = await hook.verifyWebhook(hookCtx, { request, secret });
+      if (!result.ok) {
+        return result;
+      }
+    }
+    return result;
+  }
 }

package/src/hooks/types.ts

@@ -6,11 +6,17 @@ import { SDKOptions } from "../lib/config.js";
 import { HTTPClient, RequestInput } from "../lib/http.js";
 import { RetryConfig } from "../lib/retries.js";
 import { SecurityState } from "../lib/security.js";
+import { Result } from "../types/fp.js";
+import {
+  WebhookAuthenticationError,
+  WebhookRecipient,
+} from "../types/webhooks.js";
 
 export type HookContext = {
   baseURL: string | URL;
   operationID: string;
   oAuth2Scopes: string[] | null;
+  webhookRecipient?: WebhookRecipient;
   securitySource?: any | (() => Promise<any>);
   retryConfig: RetryConfig;
   resolvedSecurity: SecurityState | null;
@@ -29,6 +35,7 @@ export type BeforeCreateRequestContext = HookContext & {};
 export type BeforeRequestContext = HookContext & {};
 export type AfterSuccessContext = HookContext & {};
 export type AfterErrorContext = HookContext & {};
+export type WebhookVerificationContext = {};
 
 /**
  * SDKInitHook is called when the SDK is initializing. The
@@ -91,6 +98,12 @@ export interface AfterErrorHook {
     error: unknown;
   }>;
 }
+export interface WebhookVerificationHook {
+  verifyWebhook: (
+    hookCtx: WebhookVerificationContext,
+    { request, secret }: { request: Request; secret: string },
+  ) => Awaitable<Result<true, WebhookAuthenticationError>>;
+}
 
 export interface Hooks {
   /** Registers a hook to be used by the SDK for initialization event. */
@@ -103,6 +116,8 @@ export interface Hooks {
   registerAfterSuccessHook(hook: AfterSuccessHook): void;
   /** Registers a hook to be used by the SDK for the after error event. */
   registerAfterErrorHook(hook: AfterErrorHook): void;
+  /** Registers a hook to be used by the SDK for the webhook verification event. */
+  registerWebhookVerificationHook(hook: WebhookVerificationHook): void;
 }
 
 export type Hook =
@@ -110,4 +125,5 @@ export type Hook =
   | BeforeCreateRequestHook
   | BeforeRequestHook
   | AfterSuccessHook
-  | AfterErrorHook;
+  | AfterErrorHook
+  | WebhookVerificationHook;

package/src/hooks/webhook-security-custom.ts

@@ -0,0 +1,165 @@
+import {
+  BeforeRequestContext,
+  BeforeRequestHook,
+  WebhookVerificationContext,
+  WebhookVerificationHook,
+} from "./types.js";
+
+import { ERR, OK, Result } from "../types/fp.js";
+import { WebhookAuthenticationError } from "../types/webhooks.js";
+
+export class WebhookSecurityHook
+  implements BeforeRequestHook, WebhookVerificationHook
+{
+  private auth = new WebhookSecurity();
+
+  async beforeRequest(
+    hookCtx: BeforeRequestContext,
+    request: Request,
+  ): Promise<Request> {
+    if (!hookCtx.webhookRecipient) return request;
+    return this.auth.sign({ secret: hookCtx.webhookRecipient.secret, request });
+  }
+
+  async verifyWebhook(
+    _hookCtx: WebhookVerificationContext,
+    { request, secret }: { request: Request; secret: string },
+  ): Promise<Result<true, WebhookAuthenticationError>> {
+    try {
+      await this.auth.verify({ request, secret });
+      return OK(true);
+    } catch (e) {
+      if (e instanceof WebhookAuthenticationError) return ERR(e);
+      throw e;
+    }
+  }
+}
+
+const headerName = "x-webhook-signature";
+
+export class WebhookSecurity {
+  /**
+   * Signs a webhook request by generating a signature using the provided secret
+   * @returns A new Request object with the signature header added.
+   */
+  async sign({
+    secret,
+    request,
+  }: {
+    secret: string;
+    request: Request;
+  }): Promise<Request> {
+    // Validation: Ensure the request has a body and a secret is provided
+    this._assert(request.body, "Unable to sign webhook with missing body");
+    this._assert(secret, "Unable to sign webhook, missing secret");
+
+    // Clone the original request to avoid mutating it
+    const newRequest = request.clone();
+
+    // Read the body content from the request
+    const bodyBytes = await request.arrayBuffer();
+    this._assert(bodyBytes, "Unable to sign webhook with missing body");
+
+    // Safely access the SubtleCrypto interface for cryptographic operations
+    const crypto = globalThis?.crypto?.subtle;
+    this._assert(
+      crypto,
+      "SubtleCrypto not found, if you're using node 18, please upgrade to a more recent version of node",
+    );
+
+    // Encode the secret into bytes, assume UTF-8 encoding
+    const encoder = new TextEncoder();
+    const secretBytes = encoder.encode(secret);
+
+    // Import the secret as a CryptoKey for HMAC signing
+    const cryptoKey = await crypto.importKey(
+      "raw",
+      secretBytes,
+      { name: "HMAC", hash: "SHA-256" },
+      false,
+      ["sign"],
+    );
+
+    // Generate the HMAC signature for the request body
+    const signatureBytes = await crypto.sign("HMAC", cryptoKey, bodyBytes);
+    const encodedSignature = Buffer.from(signatureBytes).toString("hex");
+
+    // Add the signature to the request headers
+    newRequest.headers.set(headerName, encodedSignature);
+
+    return newRequest;
+  }
+
+  /**
+   * Verifies the authenticity of a webhook request by comparing signatures using constant-time comparison
+   */
+  async verify({
+    request,
+    secret,
+  }: {
+    request: Request;
+    secret: string;
+  }): Promise<boolean> {
+    this._assert(secret, "Unable to verify webhook missing secret");
+
+    // Clone the request to avoid reading the body multiple times
+    request = request.clone();
+
+    // Retrieve the incoming signature from the request headers
+    const incomingSignature = request.headers.get(headerName);
+    this._assert(
+      incomingSignature,
+      "Unable to verify webhook missing signature",
+    );
+
+    // Read the body content from the request
+    const bodyBytes = await request.arrayBuffer();
+    this._assert(bodyBytes, "Unable to verify webhook with missing body");
+
+    // Safely access the SubtleCrypto interface for cryptographic operations
+    const crypto = globalThis?.crypto?.subtle;
+    this._assert(
+      crypto,
+      "SubtleCrypto not found, if you're using node 18, please upgrade to a more recent version of node",
+    );
+
+    // Encode the secret into bytes, assume UTF-8 encoding
+    const encoder = new TextEncoder();
+    const secretBytes = encoder.encode(secret);
+
+    // Import the secret as a CryptoKey for HMAC verification
+    const cryptoKey = await crypto.importKey(
+      "raw",
+      secretBytes,
+      { name: "HMAC", hash: "SHA-256" },
+      false,
+      ["verify"],
+    );
+
+    // Decode the incoming signature from the header encoding
+    let incomingSignatureBytes: BufferSource;
+    try {
+      incomingSignatureBytes = Uint8Array.from(
+        incomingSignature.match(/.{1,2}/g) || [],
+        byte => parseInt(byte, 16),
+      );
+    } catch (e) {
+      this._assert(false, `Invalid signature format: ${e}`);
+    }
+
+    // Use SubtleCrypto.verify for constant-time comparison (protects against timing attacks)
+    const isValid = await crypto.verify(
+      "HMAC",
+      cryptoKey,
+      incomingSignatureBytes,
+      bodyBytes,
+    );
+
+    this._assert(isValid, "Invalid signature");
+    return true;
+  }
+
+  private _assert(condition: any, message: string): asserts condition {
+    if (!condition) throw new WebhookAuthenticationError(message);
+  }
+}

package/src/lib/config.ts

@@ -80,8 +80,8 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "0.43.5",
-  sdkVersion: "0.44.0-beta.54",
+  sdkVersion: "0.44.0-beta.56",
   genVersion: "2.924.0",
   userAgent:
-    "speakeasy-sdk/typescript 0.44.0-beta.54 2.924.0 0.43.5 @greensecurity/javascript-sdk",
+    "speakeasy-sdk/typescript 0.44.0-beta.56 2.924.0 0.43.5 @greensecurity/javascript-sdk",
 } as const;

package/src/lib/sdks.ts

@@ -12,6 +12,7 @@ import {
   UnexpectedClientError,
 } from "../models/errors/httpclienterrors.js";
 import { ERR, OK, Result } from "../types/fp.js";
+import { WebhookAuthenticationError } from "../types/webhooks.js";
 import { stringToBase64 } from "./base64.js";
 import { SDK_METADATA, SDKOptions, serverURLFromOptions } from "./config.js";
 import { encodeForm } from "./encodings.js";
@@ -344,6 +345,12 @@ export class ClientSDK {
       },
     );
   }
+
+  async _verifyWebhook(
+    { request, secret }: { request: Request; secret: string },
+  ): Promise<Result<true, WebhookAuthenticationError>> {
+    return this.#hooks.verifyWebhook({}, { request, secret });
+  }
 }
 
 const jsonLikeContentTypeRE = /^(application|text)\/([^+]+\+)*json.*/;

package/src/models/components/appointmentsummary.ts

@@ -47,7 +47,44 @@ export const AppointmentSummary$inboundSchema: z.ZodType<
     "standing_appt": "standingAppt",
   });
 });
+/** @internal */
+export type AppointmentSummary$Outbound = {
+  id: number;
+  title?: string | null | undefined;
+  start?: string | null | undefined;
+  end?: string | null | undefined;
+  all_day?: boolean | null | undefined;
+  standing_appt?: boolean | null | undefined;
+  status?: string | null | undefined;
+};
 
+/** @internal */
+export const AppointmentSummary$outboundSchema: z.ZodType<
+  AppointmentSummary$Outbound,
+  z.ZodTypeDef,
+  AppointmentSummary
+> = z.object({
+  id: z.number().int(),
+  title: z.nullable(z.string()).optional(),
+  start: z.nullable(z.string()).optional(),
+  end: z.nullable(z.string()).optional(),
+  allDay: z.nullable(z.boolean()).optional(),
+  standingAppt: z.nullable(z.boolean()).optional(),
+  status: z.nullable(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    allDay: "all_day",
+    standingAppt: "standing_appt",
+  });
+});
+
+export function appointmentSummaryToJSON(
+  appointmentSummary: AppointmentSummary,
+): string {
+  return JSON.stringify(
+    AppointmentSummary$outboundSchema.parse(appointmentSummary),
+  );
+}
 export function appointmentSummaryFromJSON(
   jsonString: string,
 ): SafeParseResult<AppointmentSummary, SDKValidationError> {

package/src/models/components/company.ts

@@ -11,10 +11,14 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
   CompanyVendorField,
   CompanyVendorField$inboundSchema,
+  CompanyVendorField$Outbound,
+  CompanyVendorField$outboundSchema,
 } from "./companyvendorfield.js";
 import {
   CompanyVendorTypeRestriction,
   CompanyVendorTypeRestriction$inboundSchema,
+  CompanyVendorTypeRestriction$Outbound,
+  CompanyVendorTypeRestriction$outboundSchema,
 } from "./companyvendortyperestriction.js";
 
 export type CompanyLocation = {
@@ -83,7 +87,35 @@ export const CompanyLocation$inboundSchema: z.ZodType<
   zip: z.nullable(types.string()).optional(),
   country: z.nullable(types.string()).optional(),
 });
+/** @internal */
+export type CompanyLocation$Outbound = {
+  address?: string | null | undefined;
+  phone?: string | null | undefined;
+  city?: string | null | undefined;
+  state?: string | null | undefined;
+  zip?: string | null | undefined;
+  country?: string | null | undefined;
+};
 
+/** @internal */
+export const CompanyLocation$outboundSchema: z.ZodType<
+  CompanyLocation$Outbound,
+  z.ZodTypeDef,
+  CompanyLocation
+> = z.object({
+  address: z.nullable(z.string()).optional(),
+  phone: z.nullable(z.string()).optional(),
+  city: z.nullable(z.string()).optional(),
+  state: z.nullable(z.string()).optional(),
+  zip: z.nullable(z.string()).optional(),
+  country: z.nullable(z.string()).optional(),
+});
+
+export function companyLocationToJSON(
+  companyLocation: CompanyLocation,
+): string {
+  return JSON.stringify(CompanyLocation$outboundSchema.parse(companyLocation));
+}
 export function companyLocationFromJSON(
   jsonString: string,
 ): SafeParseResult<CompanyLocation, SDKValidationError> {
@@ -103,7 +135,25 @@ export const CompanyContact$inboundSchema: z.ZodType<
   name: types.nullable(types.string()),
   email: z.nullable(types.string()).optional(),
 });
+/** @internal */
+export type CompanyContact$Outbound = {
+  name: string | null;
+  email?: string | null | undefined;
+};
+
+/** @internal */
+export const CompanyContact$outboundSchema: z.ZodType<
+  CompanyContact$Outbound,
+  z.ZodTypeDef,
+  CompanyContact
+> = z.object({
+  name: z.nullable(z.string()),
+  email: z.nullable(z.string()).optional(),
+});
 
+export function companyContactToJSON(companyContact: CompanyContact): string {
+  return JSON.stringify(CompanyContact$outboundSchema.parse(companyContact));
+}
 export function companyContactFromJSON(
   jsonString: string,
 ): SafeParseResult<CompanyContact, SDKValidationError> {
@@ -135,7 +185,44 @@ export const Tax$inboundSchema: z.ZodType<Tax, z.ZodTypeDef, unknown> = z
       "w9_updated_at": "w9UpdatedAt",
     });
   });
+/** @internal */
+export type Tax$Outbound = {
+  tax_id: string | null;
+  tax_exempt?: boolean | null | undefined;
+  tax_exempt_code?: string | null | undefined;
+  w9_file_name?: string | null | undefined;
+  w9_content_type?: string | null | undefined;
+  w9_file_size?: string | null | undefined;
+  w9_updated_at?: string | null | undefined;
+};
+
+/** @internal */
+export const Tax$outboundSchema: z.ZodType<Tax$Outbound, z.ZodTypeDef, Tax> = z
+  .object({
+    taxId: z.nullable(z.string()),
+    taxExempt: z.nullable(z.boolean()).optional(),
+    taxExemptCode: z.nullable(z.string()).optional(),
+    w9FileName: z.nullable(z.string()).optional(),
+    w9ContentType: z.nullable(z.string()).optional(),
+    w9FileSize: z.nullable(z.string()).optional(),
+    w9UpdatedAt: z.nullable(
+      z.date().transform(v => v.toISOString().slice(0, "YYYY-MM-DD".length)),
+    ).optional(),
+  }).transform((v) => {
+    return remap$(v, {
+      taxId: "tax_id",
+      taxExempt: "tax_exempt",
+      taxExemptCode: "tax_exempt_code",
+      w9FileName: "w9_file_name",
+      w9ContentType: "w9_content_type",
+      w9FileSize: "w9_file_size",
+      w9UpdatedAt: "w9_updated_at",
+    });
+  });
 
+export function taxToJSON(tax: Tax): string {
+  return JSON.stringify(Tax$outboundSchema.parse(tax));
+}
 export function taxFromJSON(
   jsonString: string,
 ): SafeParseResult<Tax, SDKValidationError> {
@@ -161,7 +248,36 @@ export const Stats$inboundSchema: z.ZodType<Stats, z.ZodTypeDef, unknown> = z
       "facility_approved_count": "facilityApprovedCount",
     });
   });
+/** @internal */
+export type Stats$Outbound = {
+  vendor_inactive_count?: number | null | undefined;
+  vendor_active_count?: number | null | undefined;
+  facility_targeted_count?: number | null | undefined;
+  facility_approved_count?: number | null | undefined;
+};
 
+/** @internal */
+export const Stats$outboundSchema: z.ZodType<
+  Stats$Outbound,
+  z.ZodTypeDef,
+  Stats
+> = z.object({
+  vendorInactiveCount: z.nullable(z.number().int()).optional(),
+  vendorActiveCount: z.nullable(z.number().int()).optional(),
+  facilityTargetedCount: z.nullable(z.number().int()).optional(),
+  facilityApprovedCount: z.nullable(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    vendorInactiveCount: "vendor_inactive_count",
+    vendorActiveCount: "vendor_active_count",
+    facilityTargetedCount: "facility_targeted_count",
+    facilityApprovedCount: "facility_approved_count",
+  });
+});
+
+export function statsToJSON(stats: Stats): string {
+  return JSON.stringify(Stats$outboundSchema.parse(stats));
+}
 export function statsFromJSON(
   jsonString: string,
 ): SafeParseResult<Stats, SDKValidationError> {
@@ -196,7 +312,53 @@ export const Company$inboundSchema: z.ZodType<Company, z.ZodTypeDef, unknown> =
       "vendor_type_restrictions": "vendorTypeRestrictions",
     });
   });
+/** @internal */
+export type Company$Outbound = {
+  id: number;
+  name: string | null;
+  status?: string | null | undefined;
+  credit_balance?: string | null | undefined;
+  location?: CompanyLocation$Outbound | null | undefined;
+  contact?: CompanyContact$Outbound | undefined;
+  tax?: Tax$Outbound | undefined;
+  stats?: Stats$Outbound | undefined;
+  vendor_fields?: Array<CompanyVendorField$Outbound> | null | undefined;
+  vendor_type_restrictions?:
+    | Array<CompanyVendorTypeRestriction$Outbound | null>
+    | null
+    | undefined;
+};
 
+/** @internal */
+export const Company$outboundSchema: z.ZodType<
+  Company$Outbound,
+  z.ZodTypeDef,
+  Company
+> = z.object({
+  id: z.number().int(),
+  name: z.nullable(z.string()),
+  status: z.nullable(z.string()).optional(),
+  creditBalance: z.nullable(z.string()).optional(),
+  location: z.nullable(z.lazy(() => CompanyLocation$outboundSchema)).optional(),
+  contact: z.lazy(() => CompanyContact$outboundSchema).optional(),
+  tax: z.lazy(() => Tax$outboundSchema).optional(),
+  stats: z.lazy(() => Stats$outboundSchema).optional(),
+  vendorFields: z.nullable(z.array(CompanyVendorField$outboundSchema))
+    .optional(),
+  vendorTypeRestrictions: z.nullable(
+    z.array(z.nullable(CompanyVendorTypeRestriction$outboundSchema)),
+  ).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    creditBalance: "credit_balance",
+    vendorFields: "vendor_fields",
+    vendorTypeRestrictions: "vendor_type_restrictions",
+  });
+});
+
+export function companyToJSON(company: Company): string {
+  return JSON.stringify(Company$outboundSchema.parse(company));
+}
 export function companyFromJSON(
   jsonString: string,
 ): SafeParseResult<Company, SDKValidationError> {

package/src/models/components/companyvendorfield.ts

@@ -35,7 +35,38 @@ export const CompanyVendorField$inboundSchema: z.ZodType<
     "field_type": "fieldType",
   });
 });
+/** @internal */
+export type CompanyVendorField$Outbound = {
+  id: number;
+  name: string;
+  show_to_vendor: boolean;
+  field_type: string;
+};
+
+/** @internal */
+export const CompanyVendorField$outboundSchema: z.ZodType<
+  CompanyVendorField$Outbound,
+  z.ZodTypeDef,
+  CompanyVendorField
+> = z.object({
+  id: z.number().int(),
+  name: z.string(),
+  showToVendor: z.boolean(),
+  fieldType: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    showToVendor: "show_to_vendor",
+    fieldType: "field_type",
+  });
+});
 
+export function companyVendorFieldToJSON(
+  companyVendorField: CompanyVendorField,
+): string {
+  return JSON.stringify(
+    CompanyVendorField$outboundSchema.parse(companyVendorField),
+  );
+}
 export function companyVendorFieldFromJSON(
   jsonString: string,
 ): SafeParseResult<CompanyVendorField, SDKValidationError> {