@greensecurity/javascript-sdk 0.43.1-beta.5 → 0.43.1-beta.52

package/src/models/operations/listvendorinvoices.ts

@@ -5,24 +5,11 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import * as types from "../../types/primitives.js";
 import * as components from "../components/index.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
-/**
- * Filter invoices by financial_status
- */
-export const InvoiceFinancialStatus = {
-  Paid: "paid",
-  Unpaid: "unpaid",
-} as const;
-/**
- * Filter invoices by financial_status
- */
-export type InvoiceFinancialStatus = ClosedEnum<typeof InvoiceFinancialStatus>;
-
 export type ListVendorInvoicesRequest = {
   /**
    * A comma-separated list of object attributes to sort on.
@@ -49,13 +36,13 @@ export type ListVendorInvoicesRequest = {
    */
   vendorIdOrMe: string;
   /**
-   * Filter invoices by invoice number
+   * Filter invoices by invoice number (digits or digits-digits)
    */
   invoiceNumber?: string | undefined;
   /**
-   * Filter invoices by financial_status
+   * Filter invoices by financial status
    */
-  invoiceFinancialStatus?: InvoiceFinancialStatus | undefined;
+  invoiceFinancialStatus?: components.InvoiceFinancialStatus | undefined;
 };
 
 /**
@@ -73,11 +60,6 @@ export type ListVendorInvoicesResponse = {
   result: ListVendorInvoicesListVendorInvoicesOk;
 };
 
-/** @internal */
-export const InvoiceFinancialStatus$outboundSchema: z.ZodNativeEnum<
-  typeof InvoiceFinancialStatus
-> = z.nativeEnum(InvoiceFinancialStatus);
-
 /** @internal */
 export type ListVendorInvoicesRequest$Outbound = {
   sort?: string | null | undefined;
@@ -103,7 +85,8 @@ export const ListVendorInvoicesRequest$outboundSchema: z.ZodType<
   expand: z.array(components.Expand$outboundSchema).optional(),
   vendorIdOrMe: z.string(),
   invoiceNumber: z.string().optional(),
-  invoiceFinancialStatus: InvoiceFinancialStatus$outboundSchema.optional(),
+  invoiceFinancialStatus: components.InvoiceFinancialStatus$outboundSchema
+    .optional(),
 }).transform((v) => {
   return remap$(v, {
     itemsPerPage: "items_per_page",

package/src/models/operations/securityzonecheckin.ts

@@ -81,6 +81,25 @@ export const Requires = {
 } as const;
 export type Requires = ClosedEnum<typeof Requires>;
 
+/**
+ * Reduced list of attributes of Handoff record
+ */
+export type HandoffHandoff = {
+  id?: number | undefined;
+  /**
+   * Reduced list of attributes of Zone record
+   */
+  zone?: components.Zone | undefined;
+  qrCode?: string | null | undefined;
+  dateCreated?: string | null | undefined;
+  dateReceived?: string | null | undefined;
+  dateCompleted?: string | null | undefined;
+  status?: string | null | undefined;
+  gpsCheckin?: boolean | undefined;
+};
+
+export type Handoff = HandoffHandoff | number;
+
 export type Results = {
   hasValidPaymentProfile?: boolean | undefined;
   subscriptionExpires?: string | null | undefined;
@@ -110,10 +129,7 @@ export type Results = {
 export type SecurityZoneCheckinSecurityZoneCheckinOk = {
   success?: boolean | undefined;
   requires?: Requires | undefined;
-  /**
-   * Reduced list of attributes of Handoff record
-   */
-  handoff?: components.Handoff | null | undefined;
+  handoff?: HandoffHandoff | number | null | undefined;
   results?: Results | undefined;
 };
 
@@ -278,6 +294,54 @@ export function securityZoneCheckinRequestBodyToJSON(
 export const Requires$inboundSchema: z.ZodNativeEnum<typeof Requires> = z
   .nativeEnum(Requires);
 
+/** @internal */
+export const HandoffHandoff$inboundSchema: z.ZodType<
+  HandoffHandoff,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: types.optional(types.number()),
+  zone: types.optional(components.Zone$inboundSchema),
+  qr_code: z.nullable(types.string()).optional(),
+  date_created: z.nullable(types.string()).optional(),
+  date_received: z.nullable(types.string()).optional(),
+  date_completed: z.nullable(types.string()).optional(),
+  status: z.nullable(types.string()).optional(),
+  gps_checkin: types.optional(types.boolean()),
+}).transform((v) => {
+  return remap$(v, {
+    "qr_code": "qrCode",
+    "date_created": "dateCreated",
+    "date_received": "dateReceived",
+    "date_completed": "dateCompleted",
+    "gps_checkin": "gpsCheckin",
+  });
+});
+
+export function handoffHandoffFromJSON(
+  jsonString: string,
+): SafeParseResult<HandoffHandoff, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => HandoffHandoff$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'HandoffHandoff' from JSON`,
+  );
+}
+
+/** @internal */
+export const Handoff$inboundSchema: z.ZodType<Handoff, z.ZodTypeDef, unknown> =
+  smartUnion([z.lazy(() => HandoffHandoff$inboundSchema), types.number()]);
+
+export function handoffFromJSON(
+  jsonString: string,
+): SafeParseResult<Handoff, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Handoff$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Handoff' from JSON`,
+  );
+}
+
 /** @internal */
 export const Results$inboundSchema: z.ZodType<Results, z.ZodTypeDef, unknown> =
   z.object({
@@ -334,7 +398,9 @@ export const SecurityZoneCheckinSecurityZoneCheckinOk$inboundSchema: z.ZodType<
 > = z.object({
   success: types.optional(types.boolean()),
   requires: types.optional(Requires$inboundSchema),
-  handoff: z.nullable(components.Handoff$inboundSchema).optional(),
+  handoff: z.nullable(
+    smartUnion([z.lazy(() => HandoffHandoff$inboundSchema), types.number()]),
+  ).optional(),
   results: types.optional(z.lazy(() => Results$inboundSchema)),
 });
 

package/src/models/operations/submitscreeningresponse.ts

@@ -0,0 +1,169 @@
+/*
+ * 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 * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type SubmitScreeningResponseRequestBody = {
+  /**
+   * ID of the screening question being answered.
+   */
+  screeningQuestionId: number;
+  /**
+   * ID of the selected screening answer for single-select questions.
+   */
+  screeningAnswerId?: number | null | undefined;
+  /**
+   * IDs of the selected screening answers for multi-select questions.
+   *
+   * @remarks
+   */
+  multipleScreeningAnswerIds?: Array<number> | null | undefined;
+  /**
+   * Optional vendor ID. Used when the authenticated user is a company manager submitting a response on behalf of a vendor
+   *
+   * @remarks
+   */
+  vendorId?: number | null | undefined;
+  /**
+   * Custom free-text answer for questions that accept typed input.
+   */
+  customAnswer?: string | null | undefined;
+};
+
+export type SubmitScreeningResponseRequest = {
+  /**
+   * The identifier of the object
+   */
+  id: number;
+  requestBody: SubmitScreeningResponseRequestBody;
+};
+
+/**
+ * Response returned after a screening question answer is submitted.
+ *
+ * @remarks
+ */
+export type SubmitScreeningResponseResponseBody = {
+  success?: boolean | undefined;
+  /**
+   * Indicates whether there is another unanswered screening question available, assuming triggered actions do not stop the flow.
+   *
+   * @remarks
+   */
+  hasNextQuestion?: boolean | undefined;
+  /**
+   * List of actions triggered by this screening response. Present only when there is no next question (i.e., `has_next_question` is false).
+   *
+   * @remarks
+   */
+  triggeredActions?:
+    | Array<components.ScreeningAnswerActionSummary>
+    | null
+    | undefined;
+};
+
+/** @internal */
+export type SubmitScreeningResponseRequestBody$Outbound = {
+  screening_question_id: number;
+  screening_answer_id?: number | null | undefined;
+  multiple_screening_answer_ids?: Array<number> | null | undefined;
+  vendor_id?: number | null | undefined;
+  custom_answer?: string | null | undefined;
+};
+
+/** @internal */
+export const SubmitScreeningResponseRequestBody$outboundSchema: z.ZodType<
+  SubmitScreeningResponseRequestBody$Outbound,
+  z.ZodTypeDef,
+  SubmitScreeningResponseRequestBody
+> = z.object({
+  screeningQuestionId: z.number().int(),
+  screeningAnswerId: z.nullable(z.number().int()).optional(),
+  multipleScreeningAnswerIds: z.nullable(z.array(z.number().int())).optional(),
+  vendorId: z.nullable(z.number().int()).optional(),
+  customAnswer: z.nullable(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    screeningQuestionId: "screening_question_id",
+    screeningAnswerId: "screening_answer_id",
+    multipleScreeningAnswerIds: "multiple_screening_answer_ids",
+    vendorId: "vendor_id",
+    customAnswer: "custom_answer",
+  });
+});
+
+export function submitScreeningResponseRequestBodyToJSON(
+  submitScreeningResponseRequestBody: SubmitScreeningResponseRequestBody,
+): string {
+  return JSON.stringify(
+    SubmitScreeningResponseRequestBody$outboundSchema.parse(
+      submitScreeningResponseRequestBody,
+    ),
+  );
+}
+
+/** @internal */
+export type SubmitScreeningResponseRequest$Outbound = {
+  id: number;
+  RequestBody: SubmitScreeningResponseRequestBody$Outbound;
+};
+
+/** @internal */
+export const SubmitScreeningResponseRequest$outboundSchema: z.ZodType<
+  SubmitScreeningResponseRequest$Outbound,
+  z.ZodTypeDef,
+  SubmitScreeningResponseRequest
+> = z.object({
+  id: z.number().int(),
+  requestBody: z.lazy(() => SubmitScreeningResponseRequestBody$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    requestBody: "RequestBody",
+  });
+});
+
+export function submitScreeningResponseRequestToJSON(
+  submitScreeningResponseRequest: SubmitScreeningResponseRequest,
+): string {
+  return JSON.stringify(
+    SubmitScreeningResponseRequest$outboundSchema.parse(
+      submitScreeningResponseRequest,
+    ),
+  );
+}
+
+/** @internal */
+export const SubmitScreeningResponseResponseBody$inboundSchema: z.ZodType<
+  SubmitScreeningResponseResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  success: types.optional(types.boolean()),
+  has_next_question: types.optional(types.boolean()),
+  triggered_actions: z.nullable(
+    z.array(components.ScreeningAnswerActionSummary$inboundSchema),
+  ).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "has_next_question": "hasNextQuestion",
+    "triggered_actions": "triggeredActions",
+  });
+});
+
+export function submitScreeningResponseResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<SubmitScreeningResponseResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      SubmitScreeningResponseResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SubmitScreeningResponseResponseBody' from JSON`,
+  );
+}

package/src/models/operations/updateuseralerts.ts

@@ -11,6 +11,12 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type UpdateUserAlertsRequestBody = {
   alertIds?: Array<number> | undefined;
+  /**
+   * The ID of the user to update alerts for. Only authorized API Users can specify a user other than themselves.
+   *
+   * @remarks
+   */
+  userId?: number | undefined;
 };
 
 /**
@@ -23,6 +29,7 @@ export type UpdateUserAlertsUpdateUserAlertsOk = {
 /** @internal */
 export type UpdateUserAlertsRequestBody$Outbound = {
   alert_ids?: Array<number> | undefined;
+  user_id?: number | undefined;
 };
 
 /** @internal */
@@ -32,9 +39,11 @@ export const UpdateUserAlertsRequestBody$outboundSchema: z.ZodType<
   UpdateUserAlertsRequestBody
 > = z.object({
   alertIds: z.array(z.number().int()).optional(),
+  userId: z.number().int().optional(),
 }).transform((v) => {
   return remap$(v, {
     alertIds: "alert_ids",
+    userId: "user_id",
   });
 });
 

package/src/react-query/_types.ts

@@ -160,3 +160,16 @@ export type MutationHookOptions<
     "mutationKey" | "mutationFn" | keyof RequestOptions
   >
   & RequestOptions;
+
+/**
+ * Removes non-serializable properties (functions and symbols) from a PageIterator for SSR hydration.
+ * React Server Components cannot serialize functions or Symbol properties across the server/client boundary.
+ */
+export function pageIteratorToJSON<T extends { "~next"?: unknown }>(
+  page: T,
+): T {
+  const { next: _, ...rest } = page as T & { next?: unknown };
+  // Symbol properties are copied by spread but can't be serialized for RSC
+  delete (rest as Record<symbol, unknown>)[Symbol.asyncIterator];
+  return rest as T;
+}

package/src/react-query/alertsListAlerts.core.ts

@@ -0,0 +1,181 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import {
+  QueryClient,
+  QueryFunctionContext,
+  QueryKey,
+} from "@tanstack/react-query";
+import { GreenSecurityCore } from "../core.js";
+import { alertsListAlerts } from "../funcs/alertsListAlerts.js";
+import { combineSignals } from "../lib/primitives.js";
+import { RequestOptions } from "../lib/sdks.js";
+import * as components from "../models/components/index.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+import { PageIterator, unwrapResultIterator } from "../types/operations.js";
+import { pageIteratorToJSON } from "./_types.js";
+export type AlertsListAlertsQueryData = operations.ListAlertsResponse;
+
+export type AlertsListAlertsInfiniteQueryData = PageIterator<
+  operations.ListAlertsResponse,
+  { page: number }
+>;
+
+export type AlertsListAlertsPageParams = PageIterator<
+  operations.ListAlertsResponse,
+  { page: number }
+>["~next"];
+
+export function prefetchAlertsListAlerts(
+  queryClient: QueryClient,
+  client$: GreenSecurityCore,
+  request: operations.ListAlertsRequest,
+  options?: RequestOptions,
+): Promise<void> {
+  return queryClient.prefetchQuery({
+    ...buildAlertsListAlertsQuery(
+      client$,
+      request,
+      options,
+    ),
+  });
+}
+
+export function prefetchAlertsListAlertsInfinite(
+  queryClient: QueryClient,
+  client$: GreenSecurityCore,
+  request: operations.ListAlertsRequest,
+  options?: RequestOptions,
+): Promise<void> {
+  return queryClient.prefetchInfiniteQuery({
+    ...buildAlertsListAlertsInfiniteQuery(
+      client$,
+      request,
+      options,
+    ),
+    initialPageParam: undefined as AlertsListAlertsPageParams,
+    getNextPageParam: (previousPage: AlertsListAlertsInfiniteQueryData) =>
+      previousPage["~next"],
+  });
+}
+
+export function buildAlertsListAlertsQuery(
+  client$: GreenSecurityCore,
+  request: operations.ListAlertsRequest,
+  options?: RequestOptions,
+): {
+  queryKey: QueryKey;
+  queryFn: (
+    context: QueryFunctionContext,
+  ) => Promise<AlertsListAlertsQueryData>;
+} {
+  return {
+    queryKey: queryKeyAlertsListAlerts({
+      sort: request.sort,
+      desc: request.desc,
+      page: request.page,
+      itemsPerPage: request.itemsPerPage,
+      userIdOrMe: request.userIdOrMe,
+    }),
+    queryFn: async function alertsListAlertsQueryFn(
+      ctx,
+    ): Promise<AlertsListAlertsQueryData> {
+      const sig = combineSignals(
+        ctx.signal,
+        options?.signal,
+        options?.fetchOptions?.signal,
+      );
+      const mergedOptions = {
+        ...options?.fetchOptions,
+        ...options,
+        signal: sig,
+      };
+
+      return unwrapAsync(alertsListAlerts(
+        client$,
+        request,
+        mergedOptions,
+      ));
+    },
+  };
+}
+
+export function buildAlertsListAlertsInfiniteQuery(
+  client$: GreenSecurityCore,
+  request: operations.ListAlertsRequest,
+  options?: RequestOptions,
+): {
+  queryKey: QueryKey;
+  queryFn: (
+    context: QueryFunctionContext<QueryKey, AlertsListAlertsPageParams>,
+  ) => Promise<AlertsListAlertsInfiniteQueryData>;
+} {
+  return {
+    queryKey: queryKeyAlertsListAlertsInfinite({
+      sort: request.sort,
+      desc: request.desc,
+      page: request.page,
+      itemsPerPage: request.itemsPerPage,
+      userIdOrMe: request.userIdOrMe,
+    }),
+    queryFn: async function alertsListAlertsQuery(
+      ctx,
+    ): Promise<AlertsListAlertsInfiniteQueryData> {
+      const sig = combineSignals(ctx.signal, options?.fetchOptions?.signal);
+      const mergedOptions = {
+        ...options,
+        fetchOptions: { ...options?.fetchOptions, signal: sig },
+      };
+
+      if (!ctx.pageParam) {
+        const pageResult = await unwrapResultIterator(alertsListAlerts(
+          client$,
+          request,
+          mergedOptions,
+        ));
+        return pageIteratorToJSON(pageResult);
+      }
+      const pageResult = await unwrapResultIterator(alertsListAlerts(
+        client$,
+        {
+          ...request,
+          page: ctx.pageParam.page,
+        },
+        mergedOptions,
+      ));
+      return pageIteratorToJSON(pageResult);
+    },
+  };
+}
+
+export function queryKeyAlertsListAlerts(
+  parameters: {
+    sort?: string | null | undefined;
+    desc?: components.Desc | undefined;
+    page?: number | undefined;
+    itemsPerPage?: number | undefined;
+    userIdOrMe?: string | undefined;
+  },
+): QueryKey {
+  return ["@greensecurity/javascript-sdk", "alerts", "listAlerts", parameters];
+}
+
+export function queryKeyAlertsListAlertsInfinite(
+  parameters: {
+    sort?: string | null | undefined;
+    desc?: components.Desc | undefined;
+    page?: number | undefined;
+    itemsPerPage?: number | undefined;
+    userIdOrMe?: string | undefined;
+  },
+): QueryKey {
+  return [
+    "@greensecurity/javascript-sdk",
+    "alerts",
+    "listAlerts",
+    "infinite",
+    parameters,
+  ];
+}