@greensecurity/javascript-sdk 0.45.0-beta.15 → 0.45.0-beta.17

package/src/models/components/loginrequirementsfromemail.ts

@@ -17,12 +17,46 @@ export type LoginRequirementsFromEmail = {
    * A proper URI where the user should be sent after completing a SAML login. This is encoded into the response you will get if the user requires a SAML login.
    */
   returnUrl: string;
+  /**
+   * Opaque, signed state that Green Security issues when a third-party service
+   *
+   * @remarks
+   * provider starts a "Login with Green Security" SAML flow at
+   * `/saml/idp/sso`. The login screen receives it as the `sso_state` query
+   * string parameter and must pass it back, byte for byte, on every call to
+   * this endpoint for the remainder of the login journey — including the
+   * second call that carries an `mfa_code`.
+   *
+   * The blob is signed, not encrypted, and it expires five minutes after the
+   * service provider's request arrives. Do not parse it, shorten it, decode
+   * it, or re-encode it.
+   *
+   * **An invalid blob does not fail the login.** This is the opposite of what
+   * most integrators assume, so it is worth stating plainly: a forged, edited
+   * or expired `sso_state` is silently discarded, and the request then
+   * proceeds as an ordinary login. Valid credentials still authenticate and
+   * still return `200` — just with no `sso` object, leaving the user signed in
+   * to Green Security with no way back to the service provider that sent them.
+   * Never treat a `200` as proof that the SSO hand-off survived; check for
+   * `sso` explicitly.
+   *
+   * Every `202` response echoes the *verified* blob back in its own
+   * `sso_state` field. Always send back the value from the response you just
+   * received rather than the one you started with, so that a blob the server
+   * has already rejected is never resent, and so a client does not have to
+   * hold state of its own across the login journey.
+   *
+   * Omit this field entirely for an ordinary login that did not originate
+   * from a service provider.
+   */
+  ssoState?: string | undefined;
 };
 
 /** @internal */
 export type LoginRequirementsFromEmail$Outbound = {
   email: string;
   return_url: string;
+  sso_state?: string | undefined;
 };
 
 /** @internal */
@@ -33,9 +67,11 @@ export const LoginRequirementsFromEmail$outboundSchema: z.ZodType<
 > = z.object({
   email: z.string(),
   returnUrl: z.string(),
+  ssoState: z.string().optional(),
 }).transform((v) => {
   return remap$(v, {
     returnUrl: "return_url",
+    ssoState: "sso_state",
   });
 });
 

package/src/models/components/mfarequiredresponse.ts

@@ -36,6 +36,39 @@ export type MfaRequiredResponse = {
    */
   mobilePhone?: string | undefined;
   mfaMethod?: MfaMethod | undefined;
+  /**
+   * Opaque, signed state that Green Security issues when a third-party service
+   *
+   * @remarks
+   * provider starts a "Login with Green Security" SAML flow at
+   * `/saml/idp/sso`. The login screen receives it as the `sso_state` query
+   * string parameter and must pass it back, byte for byte, on every call to
+   * this endpoint for the remainder of the login journey — including the
+   * second call that carries an `mfa_code`.
+   *
+   * The blob is signed, not encrypted, and it expires five minutes after the
+   * service provider's request arrives. Do not parse it, shorten it, decode
+   * it, or re-encode it.
+   *
+   * **An invalid blob does not fail the login.** This is the opposite of what
+   * most integrators assume, so it is worth stating plainly: a forged, edited
+   * or expired `sso_state` is silently discarded, and the request then
+   * proceeds as an ordinary login. Valid credentials still authenticate and
+   * still return `200` — just with no `sso` object, leaving the user signed in
+   * to Green Security with no way back to the service provider that sent them.
+   * Never treat a `200` as proof that the SSO hand-off survived; check for
+   * `sso` explicitly.
+   *
+   * Every `202` response echoes the *verified* blob back in its own
+   * `sso_state` field. Always send back the value from the response you just
+   * received rather than the one you started with, so that a blob the server
+   * has already rejected is never resent, and so a client does not have to
+   * hold state of its own across the login journey.
+   *
+   * Omit this field entirely for an ordinary login that did not originate
+   * from a service provider.
+   */
+  ssoState?: string | undefined;
 };
 
 /** @internal */
@@ -56,10 +89,12 @@ export const MfaRequiredResponse$inboundSchema: z.ZodType<
   error: types.string(),
   mobile_phone: types.optional(types.string()),
   mfa_method: types.optional(MfaMethod$inboundSchema),
+  sso_state: types.optional(types.string()),
 }).transform((v) => {
   return remap$(v, {
     "mobile_phone": "mobilePhone",
     "mfa_method": "mfaMethod",
+    "sso_state": "ssoState",
   });
 });
 

package/src/models/components/passwordnotsetresponse.ts

@@ -20,9 +20,42 @@ export type PasswordNotSetResponse = {
    */
   error: string;
   /**
-   * URL to redirect the user to set their password (forgot password flow). Includes return_url query param when provided in the request.
+   * URL to redirect the user to set their password (forgot password flow). Carries the `return_url` and `sso_state` query params when those were provided on the request, because the browser follows this redirect and leaves the JSON body behind.
    */
   redirectUrl: string;
+  /**
+   * Opaque, signed state that Green Security issues when a third-party service
+   *
+   * @remarks
+   * provider starts a "Login with Green Security" SAML flow at
+   * `/saml/idp/sso`. The login screen receives it as the `sso_state` query
+   * string parameter and must pass it back, byte for byte, on every call to
+   * this endpoint for the remainder of the login journey — including the
+   * second call that carries an `mfa_code`.
+   *
+   * The blob is signed, not encrypted, and it expires five minutes after the
+   * service provider's request arrives. Do not parse it, shorten it, decode
+   * it, or re-encode it.
+   *
+   * **An invalid blob does not fail the login.** This is the opposite of what
+   * most integrators assume, so it is worth stating plainly: a forged, edited
+   * or expired `sso_state` is silently discarded, and the request then
+   * proceeds as an ordinary login. Valid credentials still authenticate and
+   * still return `200` — just with no `sso` object, leaving the user signed in
+   * to Green Security with no way back to the service provider that sent them.
+   * Never treat a `200` as proof that the SSO hand-off survived; check for
+   * `sso` explicitly.
+   *
+   * Every `202` response echoes the *verified* blob back in its own
+   * `sso_state` field. Always send back the value from the response you just
+   * received rather than the one you started with, so that a blob the server
+   * has already rejected is never resent, and so a client does not have to
+   * hold state of its own across the login journey.
+   *
+   * Omit this field entirely for an ordinary login that did not originate
+   * from a service provider.
+   */
+  ssoState?: string | undefined;
 };
 
 /** @internal */
@@ -35,9 +68,11 @@ export const PasswordNotSetResponse$inboundSchema: z.ZodType<
   success: types.boolean(),
   error: types.string(),
   redirect_url: types.string(),
+  sso_state: types.optional(types.string()),
 }).transform((v) => {
   return remap$(v, {
     "redirect_url": "redirectUrl",
+    "sso_state": "ssoState",
   });
 });
 

package/src/models/components/passwordrequiredresponse.ts

@@ -3,6 +3,7 @@
  */
 
 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";
@@ -18,6 +19,39 @@ export type PasswordRequiredResponse = {
    * Error describing the exact condition of what further steps are needed to finish the login process.
    */
   error: string;
+  /**
+   * Opaque, signed state that Green Security issues when a third-party service
+   *
+   * @remarks
+   * provider starts a "Login with Green Security" SAML flow at
+   * `/saml/idp/sso`. The login screen receives it as the `sso_state` query
+   * string parameter and must pass it back, byte for byte, on every call to
+   * this endpoint for the remainder of the login journey — including the
+   * second call that carries an `mfa_code`.
+   *
+   * The blob is signed, not encrypted, and it expires five minutes after the
+   * service provider's request arrives. Do not parse it, shorten it, decode
+   * it, or re-encode it.
+   *
+   * **An invalid blob does not fail the login.** This is the opposite of what
+   * most integrators assume, so it is worth stating plainly: a forged, edited
+   * or expired `sso_state` is silently discarded, and the request then
+   * proceeds as an ordinary login. Valid credentials still authenticate and
+   * still return `200` — just with no `sso` object, leaving the user signed in
+   * to Green Security with no way back to the service provider that sent them.
+   * Never treat a `200` as proof that the SSO hand-off survived; check for
+   * `sso` explicitly.
+   *
+   * Every `202` response echoes the *verified* blob back in its own
+   * `sso_state` field. Always send back the value from the response you just
+   * received rather than the one you started with, so that a blob the server
+   * has already rejected is never resent, and so a client does not have to
+   * hold state of its own across the login journey.
+   *
+   * Omit this field entirely for an ordinary login that did not originate
+   * from a service provider.
+   */
+  ssoState?: string | undefined;
 };
 
 /** @internal */
@@ -29,6 +63,11 @@ export const PasswordRequiredResponse$inboundSchema: z.ZodType<
   requires: types.literal("password"),
   success: types.boolean(),
   error: types.string(),
+  sso_state: types.optional(types.string()),
+}).transform((v) => {
+  return remap$(v, {
+    "sso_state": "ssoState",
+  });
 });
 
 export function passwordRequiredResponseFromJSON(

package/src/models/components/samlloginrequiredresponse.ts

@@ -28,6 +28,39 @@ export type SamlLoginRequiredResponse = {
    * This is the URL that should be opened to initiate the SAML login flow
    */
   ssoUrl: string;
+  /**
+   * Opaque, signed state that Green Security issues when a third-party service
+   *
+   * @remarks
+   * provider starts a "Login with Green Security" SAML flow at
+   * `/saml/idp/sso`. The login screen receives it as the `sso_state` query
+   * string parameter and must pass it back, byte for byte, on every call to
+   * this endpoint for the remainder of the login journey — including the
+   * second call that carries an `mfa_code`.
+   *
+   * The blob is signed, not encrypted, and it expires five minutes after the
+   * service provider's request arrives. Do not parse it, shorten it, decode
+   * it, or re-encode it.
+   *
+   * **An invalid blob does not fail the login.** This is the opposite of what
+   * most integrators assume, so it is worth stating plainly: a forged, edited
+   * or expired `sso_state` is silently discarded, and the request then
+   * proceeds as an ordinary login. Valid credentials still authenticate and
+   * still return `200` — just with no `sso` object, leaving the user signed in
+   * to Green Security with no way back to the service provider that sent them.
+   * Never treat a `200` as proof that the SSO hand-off survived; check for
+   * `sso` explicitly.
+   *
+   * Every `202` response echoes the *verified* blob back in its own
+   * `sso_state` field. Always send back the value from the response you just
+   * received rather than the one you started with, so that a blob the server
+   * has already rejected is never resent, and so a client does not have to
+   * hold state of its own across the login journey.
+   *
+   * Omit this field entirely for an ordinary login that did not originate
+   * from a service provider.
+   */
+  ssoState?: string | undefined;
 };
 
 /** @internal */
@@ -41,10 +74,12 @@ export const SamlLoginRequiredResponse$inboundSchema: z.ZodType<
   error: types.string(),
   sso_instructions: types.optional(types.string()),
   sso_url: types.string(),
+  sso_state: types.optional(types.string()),
 }).transform((v) => {
   return remap$(v, {
     "sso_instructions": "ssoInstructions",
     "sso_url": "ssoUrl",
+    "sso_state": "ssoState",
   });
 });
 

package/src/models/components/ssocontinuation.ts

@@ -0,0 +1,71 @@
+/*
+ * 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";
+
+/**
+ * Where to send the browser to finish a "Login with Green Security" flow.
+ *
+ * @remarks
+ *
+ * Present on a `200` from `POST /users/authenticate` only when the request
+ * carried a valid, unexpired `sso_state`. Its absence means the login
+ * succeeded but the SAML flow did not resume — treat the login as an
+ * ordinary one rather than retrying.
+ *
+ * This object is additive. The login itself is unaffected by it: the
+ * caller's own permanent token is in `user_token` exactly as it would be on
+ * any other successful authentication, and it is not the token embedded in
+ * `continue_url`.
+ */
+export type SsoContinuation = {
+  /**
+   * An absolute, single-use URL on Green Security's domain. Navigate the
+   *
+   * @remarks
+   * browser to it (a full page navigation, not `fetch`); it answers with a
+   * self-submitting form that POSTs the signed `SAMLResponse` and the
+   * original `RelayState` to the service provider's assertion consumer
+   * service URL.
+   *
+   * The `token` in this URL is a separate **one-time** token that is
+   * consumed the first time the URL is followed, so the URL is good for
+   * exactly one navigation. It is not the caller's permanent token, which
+   * is returned unchanged in `user_token`. Treat the URL as a secret:
+   * whoever follows it first receives that user's assertion.
+   *
+   * Never fetch this URL from your own back end: the response is meant for
+   * the user's browser, and posting the assertion from anywhere else
+   * breaks the flow.
+   */
+  continueUrl: string;
+};
+
+/** @internal */
+export const SsoContinuation$inboundSchema: z.ZodType<
+  SsoContinuation,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  continue_url: types.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "continue_url": "continueUrl",
+  });
+});
+
+export function ssoContinuationFromJSON(
+  jsonString: string,
+): SafeParseResult<SsoContinuation, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SsoContinuation$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SsoContinuation' from JSON`,
+  );
+}

package/src/models/components/webhooksubscription.ts

@@ -12,6 +12,9 @@ import { ClosedEnum } from "../../types/enums.js";
  * and `destroyed` lifecycle of every entity that supports webhooks.
  */
 export const WebhookSubscription = {
+  FullReportCreated: "FullReport.created",
+  FullReportUpdated: "FullReport.updated",
+  FullReportDestroyed: "FullReport.destroyed",
   TargetFacilityStatusChangeCreated: "TargetFacilityStatusChange.created",
   TargetFacilityStatusChangeUpdated: "TargetFacilityStatusChange.updated",
   TargetFacilityStatusChangeDestroyed: "TargetFacilityStatusChange.destroyed",

package/src/models/components/webhooksubscriptiondetail.ts

@@ -14,6 +14,7 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
  * The entity the event is about.
  */
 export const Model = {
+  FullReport: "FullReport",
   TargetFacilityStatusChange: "TargetFacilityStatusChange",
   Vendor: "Vendor",
   VendorScan: "VendorScan",

package/src/models/operations/postauthenticate.ts

@@ -26,7 +26,7 @@ export type PostAuthenticateResponseBody =
   | components.PasswordNotSetResponse;
 
 export type PostAuthenticateResponse =
-  | components.User
+  | components.AuthenticateSuccessResponse
   | components.MfaRequiredResponse
   | components.SamlLoginRequiredResponse
   | components.PasswordRequiredResponse
@@ -85,7 +85,7 @@ export const PostAuthenticateResponse$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = smartUnion([
-  components.User$inboundSchema,
+  components.AuthenticateSuccessResponse$inboundSchema,
   z.union([
     components.MfaRequiredResponse$inboundSchema,
     components.SamlLoginRequiredResponse$inboundSchema,

package/src/models/webhooks/index.ts

@@ -2,6 +2,9 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
+export * from "./sendfullreportcreated.js";
+export * from "./sendfullreportdestroyed.js";
+export * from "./sendfullreportupdated.js";
 export * from "./sendtargetfacilitystatuschangecreated.js";
 export * from "./sendtargetfacilitystatuschangedestroyed.js";
 export * from "./sendtargetfacilitystatuschangeupdated.js";

package/src/models/webhooks/sendfullreportcreated.ts

@@ -0,0 +1,104 @@
+/*
+ * 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 SendFullReportCreatedRequest = {
+  /**
+   * `t=<unix seconds>,v1=<hex hmac>`, one `v1` per active secret. Each is
+   *
+   * @remarks
+   * `HMAC-SHA256(secret, "<t>.<raw body>")`. Compare with a constant-time function and
+   * reject a timestamp that is not recent.
+   */
+  greenSecuritySignature: string;
+  /**
+   * The event this delivery belongs to. Route on it when one URL serves several events.
+   */
+  greenSecurityEvent: string;
+  /**
+   * Stable per delivery, including across retries. Key your de-duplication on it.
+   */
+  greenSecurityIdempotencyKey: string;
+  /**
+   * The entity in the body.
+   */
+  greenWebhookId: string;
+  fullReport: components.FullReport;
+};
+
+/** @internal */
+export const SendFullReportCreatedRequest$inboundSchema: z.ZodType<
+  SendFullReportCreatedRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  "Green-Security-Signature": types.string(),
+  "Green-Security-Event": types.string(),
+  "Green-Security-Idempotency-Key": types.string(),
+  "Green-Webhook-Id": types.string(),
+  FullReport: components.FullReport$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "Green-Security-Signature": "greenSecuritySignature",
+    "Green-Security-Event": "greenSecurityEvent",
+    "Green-Security-Idempotency-Key": "greenSecurityIdempotencyKey",
+    "Green-Webhook-Id": "greenWebhookId",
+    "FullReport": "fullReport",
+  });
+});
+/** @internal */
+export type SendFullReportCreatedRequest$Outbound = {
+  "Green-Security-Signature": string;
+  "Green-Security-Event": string;
+  "Green-Security-Idempotency-Key": string;
+  "Green-Webhook-Id": string;
+  FullReport: components.FullReport$Outbound;
+};
+
+/** @internal */
+export const SendFullReportCreatedRequest$outboundSchema: z.ZodType<
+  SendFullReportCreatedRequest$Outbound,
+  z.ZodTypeDef,
+  SendFullReportCreatedRequest
+> = z.object({
+  greenSecuritySignature: z.string(),
+  greenSecurityEvent: z.string(),
+  greenSecurityIdempotencyKey: z.string(),
+  greenWebhookId: z.string(),
+  fullReport: components.FullReport$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    greenSecuritySignature: "Green-Security-Signature",
+    greenSecurityEvent: "Green-Security-Event",
+    greenSecurityIdempotencyKey: "Green-Security-Idempotency-Key",
+    greenWebhookId: "Green-Webhook-Id",
+    fullReport: "FullReport",
+  });
+});
+
+export function sendFullReportCreatedRequestToJSON(
+  sendFullReportCreatedRequest: SendFullReportCreatedRequest,
+): string {
+  return JSON.stringify(
+    SendFullReportCreatedRequest$outboundSchema.parse(
+      sendFullReportCreatedRequest,
+    ),
+  );
+}
+export function sendFullReportCreatedRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<SendFullReportCreatedRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SendFullReportCreatedRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SendFullReportCreatedRequest' from JSON`,
+  );
+}

package/src/models/webhooks/sendfullreportdestroyed.ts

@@ -0,0 +1,104 @@
+/*
+ * 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 SendFullReportDestroyedRequest = {
+  /**
+   * `t=<unix seconds>,v1=<hex hmac>`, one `v1` per active secret. Each is
+   *
+   * @remarks
+   * `HMAC-SHA256(secret, "<t>.<raw body>")`. Compare with a constant-time function and
+   * reject a timestamp that is not recent.
+   */
+  greenSecuritySignature: string;
+  /**
+   * The event this delivery belongs to. Route on it when one URL serves several events.
+   */
+  greenSecurityEvent: string;
+  /**
+   * Stable per delivery, including across retries. Key your de-duplication on it.
+   */
+  greenSecurityIdempotencyKey: string;
+  /**
+   * The entity in the body.
+   */
+  greenWebhookId: string;
+  fullReport: components.FullReport;
+};
+
+/** @internal */
+export const SendFullReportDestroyedRequest$inboundSchema: z.ZodType<
+  SendFullReportDestroyedRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  "Green-Security-Signature": types.string(),
+  "Green-Security-Event": types.string(),
+  "Green-Security-Idempotency-Key": types.string(),
+  "Green-Webhook-Id": types.string(),
+  FullReport: components.FullReport$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "Green-Security-Signature": "greenSecuritySignature",
+    "Green-Security-Event": "greenSecurityEvent",
+    "Green-Security-Idempotency-Key": "greenSecurityIdempotencyKey",
+    "Green-Webhook-Id": "greenWebhookId",
+    "FullReport": "fullReport",
+  });
+});
+/** @internal */
+export type SendFullReportDestroyedRequest$Outbound = {
+  "Green-Security-Signature": string;
+  "Green-Security-Event": string;
+  "Green-Security-Idempotency-Key": string;
+  "Green-Webhook-Id": string;
+  FullReport: components.FullReport$Outbound;
+};
+
+/** @internal */
+export const SendFullReportDestroyedRequest$outboundSchema: z.ZodType<
+  SendFullReportDestroyedRequest$Outbound,
+  z.ZodTypeDef,
+  SendFullReportDestroyedRequest
+> = z.object({
+  greenSecuritySignature: z.string(),
+  greenSecurityEvent: z.string(),
+  greenSecurityIdempotencyKey: z.string(),
+  greenWebhookId: z.string(),
+  fullReport: components.FullReport$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    greenSecuritySignature: "Green-Security-Signature",
+    greenSecurityEvent: "Green-Security-Event",
+    greenSecurityIdempotencyKey: "Green-Security-Idempotency-Key",
+    greenWebhookId: "Green-Webhook-Id",
+    fullReport: "FullReport",
+  });
+});
+
+export function sendFullReportDestroyedRequestToJSON(
+  sendFullReportDestroyedRequest: SendFullReportDestroyedRequest,
+): string {
+  return JSON.stringify(
+    SendFullReportDestroyedRequest$outboundSchema.parse(
+      sendFullReportDestroyedRequest,
+    ),
+  );
+}
+export function sendFullReportDestroyedRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<SendFullReportDestroyedRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SendFullReportDestroyedRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SendFullReportDestroyedRequest' from JSON`,
+  );
+}