@greensecurity/javascript-sdk 0.44.0-beta.5 → 0.44.0-beta.50

package/src/lib/sdks.ts

@@ -24,6 +24,7 @@ import {
   matchContentType,
 } from "./http.js";
 import { Logger } from "./logger.js";
+import { combineSignals } from "./primitives.js";
 import { retry, RetryConfig } from "./retries.js";
 import { SecurityState } from "./security.js";
 
@@ -132,27 +133,55 @@ export class ClientSDK {
     if (path) {
       baseURL.pathname = baseURL.pathname.replace(/\/+$/, "") + "/";
       reqURL = new URL(path, baseURL);
+      if (!reqURL.search && baseURL.search) {
+        reqURL.search = baseURL.search;
+      }
     } else {
       reqURL = baseURL;
     }
     reqURL.hash = "";
 
-    let finalQuery = query || "";
-
-    const secQuery: string[] = [];
-    for (const [k, v] of Object.entries(security?.queryParams || {})) {
-      const q = encodeForm(k, v, { charEncoding: "percent" });
-      if (typeof q !== "undefined") {
-        secQuery.push(q);
+    // Appends already-encoded query pairs to a query string, replacing any
+    // existing pairs with the same key so later sources take precedence.
+    const mergeQuery = (current: string, additions: string): string => {
+      if (!additions) {
+        return current;
       }
-    }
-    if (secQuery.length) {
-      finalQuery += `&${secQuery.join("&")}`;
-    }
+      const additionKeys = new Set(
+        additions
+          .split("&")
+          .filter((pair) => pair !== "")
+          .map((pair) => pair.split("=")[0] ?? ""),
+      );
+      const kept = current.split("&").filter((pair) => {
+        return pair !== "" && !additionKeys.has(pair.split("=")[0] ?? "");
+      });
+      return [...kept, additions].join("&");
+    };
+
+    const encodeQueryRecord = (record: Record<string, unknown>): string => {
+      return Object.entries(record)
+        .map(([k, v]) => {
+          if (v == null) {
+            return undefined;
+          }
+          const value = v;
+          return encodeForm(k, value, {
+            explode: Array.isArray(value),
+            charEncoding: "percent",
+          });
+        })
+        .filter((pair): pair is string => typeof pair !== "undefined")
+        .join("&");
+    };
+
+    const finalQuery = [
+      query || "",
+      encodeQueryRecord(security?.queryParams || {}),
+    ].reduce(mergeQuery, reqURL.search.slice(1));
 
     if (finalQuery) {
-      const q = finalQuery.startsWith("&") ? finalQuery.slice(1) : finalQuery;
-      reqURL.search = `?${q}`;
+      reqURL.search = `?${finalQuery}`;
     }
 
     const headers = new Headers(opHeaders);
@@ -198,9 +227,8 @@ export class ClientSDK {
       ...options?.fetchOptions,
       ...options,
     };
-    if (!fetchOptions?.signal && conf.timeoutMs && conf.timeoutMs > 0) {
-      const timeoutSignal = AbortSignal.timeout(conf.timeoutMs);
-      fetchOptions.signal = timeoutSignal;
+    if (!fetchOptions?.signal && conf.timeoutMs != null && conf.timeoutMs > 0) {
+      context.timeoutMs = conf.timeoutMs;
     }
 
     if (conf.body instanceof ReadableStream) {
@@ -247,10 +275,19 @@ export class ClientSDK {
     >
   > {
     const { context, isErrorStatusCode } = options;
+    const timeoutMs = context.timeoutMs;
 
     return retry(
       async () => {
-        const req = await this.#hooks.beforeRequest(context, request.clone());
+        const cloned = request.clone();
+        let attempt = cloned;
+        if (timeoutMs != null && timeoutMs > 0) {
+          const timeoutSignal = AbortSignal.timeout(timeoutMs);
+          const combined = combineSignals(cloned.signal, timeoutSignal)
+            ?? timeoutSignal;
+          attempt = new Request(cloned, { signal: combined });
+        }
+        const req = await this.#hooks.beforeRequest(context, attempt);
         await logRequest(this.#logger, req).catch((e) =>
           this.#logger?.log("Failed to log request:", e)
         );

package/src/lib/security.ts

@@ -13,17 +13,22 @@ type OAuth2PasswordFlow = {
   tokenURL: string;
 };
 
-export enum SecurityErrorCode {
-  Incomplete = "incomplete",
-  UnrecognisedSecurityType = "unrecognized_security_type",
-}
+export const SecurityErrorCode = {
+  Incomplete: "incomplete",
+  UnrecognisedSecurityType: "unrecognized_security_type",
+} as const;
+export type SecurityErrorCode =
+  (typeof SecurityErrorCode)[keyof typeof SecurityErrorCode];
 
 export class SecurityError extends Error {
+  public code: SecurityErrorCode;
+
   constructor(
-    public code: SecurityErrorCode,
+    code: SecurityErrorCode,
     message: string,
   ) {
     super(message);
+    this.code = code;
     this.name = "SecurityError";
   }
 

package/src/models/components/alert.ts

@@ -15,9 +15,30 @@ export const Type = {
   Error: "Error",
   Warning: "Warning",
   Info: "Info",
+  WebNotification: "Web Notification",
+  SmartBadgeScreeningQuestions: "Smart Badge Screening Questions",
 } as const;
 export type Type = OpenEnum<typeof Type>;
 
+export const FollowUpType = {
+  CompleteCheckin: "complete_checkin",
+  AskScreeningQuestions: "ask_screening_questions",
+} as const;
+export type FollowUpType = OpenEnum<typeof FollowUpType>;
+
+/**
+ * Context data for smart badge follow-up alerts.
+ */
+export type AlertContext = {
+  facilityId?: number | null | undefined;
+  handoffId?: number | null | undefined;
+  qrCode?: string | null | undefined;
+  zoneId?: number | null | undefined;
+  vendorScanId?: number | null | undefined;
+  recheckVendorScanId?: number | null | undefined;
+  followUpType?: FollowUpType | null | undefined;
+};
+
 /**
  * A simplified representation of a Alert, typically used in list views.
  */
@@ -31,6 +52,10 @@ export type Alert = {
   type?: Type | null | undefined;
   title?: string | null | undefined;
   plainText?: string | null | undefined;
+  /**
+   * Context data for smart badge follow-up alerts.
+   */
+  alertContext?: AlertContext | null | undefined;
   viewed?: boolean | null | undefined;
   dateViewed?: string | null | undefined;
 };
@@ -39,6 +64,48 @@ export type Alert = {
 export const Type$inboundSchema: z.ZodType<Type, z.ZodTypeDef, unknown> =
   openEnums.inboundSchema(Type);
 
+/** @internal */
+export const FollowUpType$inboundSchema: z.ZodType<
+  FollowUpType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(FollowUpType);
+
+/** @internal */
+export const AlertContext$inboundSchema: z.ZodType<
+  AlertContext,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  facility_id: z.nullable(types.number()).optional(),
+  handoff_id: z.nullable(types.number()).optional(),
+  qr_code: z.nullable(types.string()).optional(),
+  zone_id: z.nullable(types.number()).optional(),
+  vendor_scan_id: z.nullable(types.number()).optional(),
+  recheck_vendor_scan_id: z.nullable(types.number()).optional(),
+  follow_up_type: z.nullable(FollowUpType$inboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "facility_id": "facilityId",
+    "handoff_id": "handoffId",
+    "qr_code": "qrCode",
+    "zone_id": "zoneId",
+    "vendor_scan_id": "vendorScanId",
+    "recheck_vendor_scan_id": "recheckVendorScanId",
+    "follow_up_type": "followUpType",
+  });
+});
+
+export function alertContextFromJSON(
+  jsonString: string,
+): SafeParseResult<AlertContext, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AlertContext$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AlertContext' from JSON`,
+  );
+}
+
 /** @internal */
 export const Alert$inboundSchema: z.ZodType<Alert, z.ZodTypeDef, unknown> = z
   .object({
@@ -51,6 +118,8 @@ export const Alert$inboundSchema: z.ZodType<Alert, z.ZodTypeDef, unknown> = z
     type: z.nullable(Type$inboundSchema).optional(),
     title: z.nullable(types.string()).optional(),
     plain_text: z.nullable(types.string()).optional(),
+    alert_context: z.nullable(z.lazy(() => AlertContext$inboundSchema))
+      .optional(),
     viewed: z.nullable(types.boolean()).optional(),
     date_viewed: z.nullable(types.string()).optional(),
   }).transform((v) => {
@@ -59,6 +128,7 @@ export const Alert$inboundSchema: z.ZodType<Alert, z.ZodTypeDef, unknown> = z
       "date_added": "dateAdded",
       "date_starts": "dateStarts",
       "plain_text": "plainText",
+      "alert_context": "alertContext",
       "date_viewed": "dateViewed",
     });
   });

package/src/models/components/companytargetfacility.ts

@@ -35,9 +35,9 @@ export type IndividualCounts = {
  */
 export type CompanyTargetFacility = {
   /**
-   * CompanyTargetFacility row ID.
+   * CompanyTargetFacility row ID. Null when returned via `include_potential_targets=true` for a facility not yet targeted by the company.
    */
-  id: number;
+  id: number | null;
   /**
    * The linked facility. Returns the facility ID by default; pass `company_target_facility.facility` to `expand` to receive the full facility object.
    */
@@ -97,7 +97,7 @@ export const CompanyTargetFacility$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: types.number(),
+  id: types.nullable(types.number()),
   facility: types.nullable(
     smartUnion([Facility$inboundSchema, types.number()]),
   ),

package/src/models/components/credit.ts

@@ -10,6 +10,10 @@ import { OpenEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import * as types from "../../types/primitives.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  CreditEntitySummary,
+  CreditEntitySummary$inboundSchema,
+} from "./creditentitysummary.js";
 
 export const Action = {
   Credit: "credit",
@@ -18,21 +22,97 @@ export const Action = {
 } as const;
 export type Action = OpenEnum<typeof Action>;
 
+export type CreditsAndDebits = {
+  /**
+   * Compact entity reference by default (`id`, `name`); becomes the entity's full payload when the corresponding `expand` value is requested.
+   */
+  entity?: CreditEntitySummary | null | undefined;
+  invoiceNumber?: string | null | undefined;
+  /**
+   * The invoice's numeric id — use this (not invoice_number) to link to invoice details.
+   */
+  invoiceId?: number | null | undefined;
+};
+
+export type Transfers = {
+  /**
+   * Compact entity reference by default (`id`, `name`); becomes the entity's full payload when the corresponding `expand` value is requested.
+   */
+  fromEntity?: CreditEntitySummary | null | undefined;
+  /**
+   * Compact entity reference by default (`id`, `name`); becomes the entity's full payload when the corresponding `expand` value is requested.
+   */
+  toEntity?: CreditEntitySummary | null | undefined;
+};
+
 export type Credit = {
   id?: number | undefined;
   date?: string | null | undefined;
   action?: Action | undefined;
   amount?: number | undefined;
-  balance?: number | undefined;
-  from?: string | null | undefined;
-  to?: string | null | undefined;
-  invoiceNumber?: string | null | undefined;
+  /**
+   * Account balance immediately after this transaction (running balance at this point in the ledger). Not the account's current overall balance — see `credit_balance` on the list response for that.
+   */
+  balance?: number | null | undefined;
+  creditsAndDebits?: CreditsAndDebits | undefined;
+  transfers?: Transfers | undefined;
 };
 
 /** @internal */
 export const Action$inboundSchema: z.ZodType<Action, z.ZodTypeDef, unknown> =
   openEnums.inboundSchema(Action);
 
+/** @internal */
+export const CreditsAndDebits$inboundSchema: z.ZodType<
+  CreditsAndDebits,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  entity: z.nullable(CreditEntitySummary$inboundSchema).optional(),
+  invoice_number: z.nullable(types.string()).optional(),
+  invoice_id: z.nullable(types.number()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "invoice_number": "invoiceNumber",
+    "invoice_id": "invoiceId",
+  });
+});
+
+export function creditsAndDebitsFromJSON(
+  jsonString: string,
+): SafeParseResult<CreditsAndDebits, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreditsAndDebits$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreditsAndDebits' from JSON`,
+  );
+}
+
+/** @internal */
+export const Transfers$inboundSchema: z.ZodType<
+  Transfers,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  from_entity: z.nullable(CreditEntitySummary$inboundSchema).optional(),
+  to_entity: z.nullable(CreditEntitySummary$inboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "from_entity": "fromEntity",
+    "to_entity": "toEntity",
+  });
+});
+
+export function transfersFromJSON(
+  jsonString: string,
+): SafeParseResult<Transfers, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Transfers$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Transfers' from JSON`,
+  );
+}
+
 /** @internal */
 export const Credit$inboundSchema: z.ZodType<Credit, z.ZodTypeDef, unknown> = z
   .object({
@@ -40,13 +120,14 @@ export const Credit$inboundSchema: z.ZodType<Credit, z.ZodTypeDef, unknown> = z
     date: z.nullable(types.string()).optional(),
     action: types.optional(Action$inboundSchema),
     amount: types.optional(types.number()),
-    balance: types.optional(types.number()),
-    from: z.nullable(types.string()).optional(),
-    to: z.nullable(types.string()).optional(),
-    invoice_number: z.nullable(types.string()).optional(),
+    balance: z.nullable(types.number()).optional(),
+    credits_and_debits: types.optional(
+      z.lazy(() => CreditsAndDebits$inboundSchema),
+    ),
+    transfers: types.optional(z.lazy(() => Transfers$inboundSchema)),
   }).transform((v) => {
     return remap$(v, {
-      "invoice_number": "invoiceNumber",
+      "credits_and_debits": "creditsAndDebits",
     });
   });
 

package/src/models/components/creditentitysummary.ts

@@ -0,0 +1,45 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import {
+  collectExtraKeys as collectExtraKeys$,
+  safeParse,
+} from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * Compact entity reference by default (`id`, `name`); becomes the entity's full payload when the corresponding `expand` value is requested.
+ */
+export type CreditEntitySummary = {
+  id?: number | undefined;
+  name?: string | null | undefined;
+  additionalProperties?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const CreditEntitySummary$inboundSchema: z.ZodType<
+  CreditEntitySummary,
+  z.ZodTypeDef,
+  unknown
+> = collectExtraKeys$(
+  z.object({
+    id: types.optional(types.number()),
+    name: z.nullable(types.string()).optional(),
+  }).catchall(z.any()),
+  "additionalProperties",
+  true,
+);
+
+export function creditEntitySummaryFromJSON(
+  jsonString: string,
+): SafeParseResult<CreditEntitySummary, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreditEntitySummary$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreditEntitySummary' from JSON`,
+  );
+}

package/src/models/components/csvexportenqueuedresponse.ts

@@ -0,0 +1,58 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+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 * as types from "../../types/primitives.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * Returned when an asynchronous CSV export job is enqueued. Poll `status_url` until the export is ready,
+ *
+ * @remarks
+ * then retrieve the file from `download_url`.
+ */
+export type CsvExportEnqueuedResponse = {
+  /**
+   * URL to poll for the status of the export job.
+   */
+  statusUrl: string;
+  /**
+   * URL to download the exported CSV file once the job is ready.
+   */
+  downloadUrl: string;
+  /**
+   * Token identifying the export job, used to check its status.
+   */
+  statusId: string;
+};
+
+/** @internal */
+export const CsvExportEnqueuedResponse$inboundSchema: z.ZodType<
+  CsvExportEnqueuedResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  status_url: types.string(),
+  download_url: types.string(),
+  status_id: types.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "status_url": "statusUrl",
+    "download_url": "downloadUrl",
+    "status_id": "statusId",
+  });
+});
+
+export function csvExportEnqueuedResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CsvExportEnqueuedResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CsvExportEnqueuedResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CsvExportEnqueuedResponse' from JSON`,
+  );
+}

package/src/models/components/csvexportstatusresponse.ts

@@ -0,0 +1,79 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+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 * as types from "../../types/primitives.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * Returned when polling the status of an asynchronous CSV export job. When `ready` is true,
+ *
+ * @remarks
+ * the export is complete and can be downloaded via the URL in `download_url`.
+ */
+export type CsvExportStatusResponse = {
+  /**
+   * When true, the export is ready for download.
+   */
+  ready: boolean;
+  /**
+   * The export job identifier.
+   */
+  statusId: string;
+  /**
+   * URL to download the CSV (present only when `ready` is true).
+   */
+  downloadUrl?: string | undefined;
+  /**
+   * When the export job completed.
+   */
+  finishedAt?: string | undefined;
+  /**
+   * When the export job started.
+   */
+  startedAt?: string | undefined;
+  /**
+   * Timestamp of the last progress heartbeat from the background job. Updated on each pagination loop while the job is running; on completion or failure it equals `finished_at`.
+   */
+  heartbeat?: string | undefined;
+  /**
+   * Error message if the export failed.
+   */
+  error?: string | undefined;
+};
+
+/** @internal */
+export const CsvExportStatusResponse$inboundSchema: z.ZodType<
+  CsvExportStatusResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  ready: types.boolean(),
+  status_id: types.string(),
+  download_url: types.optional(types.string()),
+  finished_at: types.optional(types.string()),
+  started_at: types.optional(types.string()),
+  heartbeat: types.optional(types.string()),
+  error: types.optional(types.string()),
+}).transform((v) => {
+  return remap$(v, {
+    "status_id": "statusId",
+    "download_url": "downloadUrl",
+    "finished_at": "finishedAt",
+    "started_at": "startedAt",
+  });
+});
+
+export function csvExportStatusResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CsvExportStatusResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CsvExportStatusResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CsvExportStatusResponse' from JSON`,
+  );
+}

package/src/models/components/emailpreferences.ts

@@ -11,30 +11,12 @@ import { Result as SafeParseResult } from "../../types/fp.js";
 import * as types from "../../types/primitives.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
-/**
- * Who receives vendor-related notification emails:
- *
- * @remarks
- * - `none` — no recipients
- * - `self` — the user (vendor) themselves
- * - `company_manager` — the vendor's company manager only
- * - `self_and_company_manager` — both
- */
 export const NotificationRecipients = {
   None: "none",
   Self: "self",
   CompanyManager: "company_manager",
   SelfAndCompanyManager: "self_and_company_manager",
 } as const;
-/**
- * Who receives vendor-related notification emails:
- *
- * @remarks
- * - `none` — no recipients
- * - `self` — the user (vendor) themselves
- * - `company_manager` — the vendor's company manager only
- * - `self_and_company_manager` — both
- */
 export type NotificationRecipients = OpenEnum<typeof NotificationRecipients>;
 
 /**
@@ -48,6 +30,10 @@ export type NotificationRecipients = OpenEnum<typeof NotificationRecipients>;
  * Replaces the legacy vendor-side fields `email_recepient` and
  * `send_weekly_summary_email`, which remain on the Vendor object during
  * the migration window but are deprecated.
+ *
+ * `receive_vendor_emails` is company-manager-only and is stored on the
+ * CompanyManager record rather than the User, but is exposed here
+ * alongside the other preferences for a single read/write shape.
  */
 export type EmailPreferences = {
   /**
@@ -68,6 +54,10 @@ export type EmailPreferences = {
    * Whether the user receives the weekly credentialing status summary email.
    */
   sendWeeklyCredentialingStatusEmail?: boolean | undefined;
+  /**
+   * Company-manager-only preference: whether this manager receives a copy of vendor-related notification emails (credential approvals, declines, expirations, etc.) for their company's vendors. Omitted for non-company-manager users. Also depends on each individual vendor's own `notification_recipients` setting including the company manager as a recipient — both must be true for this manager to actually receive a given vendor's emails.
+   */
+  receiveVendorEmails?: boolean | undefined;
 };
 
 /** @internal */
@@ -93,12 +83,14 @@ export const EmailPreferences$inboundSchema: z.ZodType<
     .optional(),
   send_weekly_summary_email: types.optional(types.boolean()),
   send_weekly_credentialing_status_email: types.optional(types.boolean()),
+  receive_vendor_emails: types.optional(types.boolean()),
 }).transform((v) => {
   return remap$(v, {
     "notification_recipients": "notificationRecipients",
     "send_weekly_summary_email": "sendWeeklySummaryEmail",
     "send_weekly_credentialing_status_email":
       "sendWeeklyCredentialingStatusEmail",
+    "receive_vendor_emails": "receiveVendorEmails",
   });
 });
 /** @internal */
@@ -106,6 +98,7 @@ export type EmailPreferences$Outbound = {
   notification_recipients?: string | null | undefined;
   send_weekly_summary_email?: boolean | undefined;
   send_weekly_credentialing_status_email?: boolean | undefined;
+  receive_vendor_emails?: boolean | undefined;
 };
 
 /** @internal */
@@ -118,12 +111,14 @@ export const EmailPreferences$outboundSchema: z.ZodType<
     .optional(),
   sendWeeklySummaryEmail: z.boolean().optional(),
   sendWeeklyCredentialingStatusEmail: z.boolean().optional(),
+  receiveVendorEmails: z.boolean().optional(),
 }).transform((v) => {
   return remap$(v, {
     notificationRecipients: "notification_recipients",
     sendWeeklySummaryEmail: "send_weekly_summary_email",
     sendWeeklyCredentialingStatusEmail:
       "send_weekly_credentialing_status_email",
+    receiveVendorEmails: "receive_vendor_emails",
   });
 });
 

package/src/models/components/expand.ts

@@ -16,6 +16,7 @@ export const Expand = {
   CompanyVendorFields: "company.vendor_fields",
   CompanyVendorTypeRestrictions: "company.vendor_type_restrictions",
   CompanyTargetFacilityFacility: "company_target_facility.facility",
+  VendorTargetFacilityFacility: "vendor_target_facility.facility",
   ContactFacility: "contact.facility",
   ContactSystem: "contact.system",
   ContactDepartment: "contact.department",