@greensecurity/javascript-sdk 0.44.0-beta.9 → 0.45.0-beta.0

package/src/funcs/webhooksListAllWebhookEndpoints.ts

@@ -25,29 +25,44 @@ import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
 import * as operations from "../models/operations/index.js";
 import { APICall, APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
+import {
+  createPageIterator,
+  haltIterator,
+  PageIterator,
+  Paginator,
+} from "../types/operations.js";
 
 /**
  * List all webhook endpoints
  *
  * @remarks
- * Returns a list of your webhook endpoints.
+ * Returns the webhook endpoints you can see: the ones you registered, plus the ones scoped
+ * to an entity you belong to. `secrets` is never included here, it is only returned once by
+ * `POST /webhooks`.
+ *
+ * Sortable by `id`, `webhook_url`, `created_at` and `updated_at`.
+ *
+ * Requires the `webhook` / `view` permission.
  */
 export function webhooksListAllWebhookEndpoints(
   client: GreenSecurityCore,
   request: operations.ListAllWebhookEndpointsRequest,
   options?: RequestOptions,
 ): APIPromise<
-  Result<
-    operations.ListAllWebhookEndpointsListAllWebhookEndpointsOk,
-    | errors.ApiErrorResponse
-    | GreenSecurityError
-    | ResponseValidationError
-    | ConnectionError
-    | RequestAbortedError
-    | RequestTimeoutError
-    | InvalidRequestError
-    | UnexpectedClientError
-    | SDKValidationError
+  PageIterator<
+    Result<
+      operations.ListAllWebhookEndpointsResponse,
+      | errors.ApiErrorResponse
+      | GreenSecurityError
+      | ResponseValidationError
+      | ConnectionError
+      | RequestAbortedError
+      | RequestTimeoutError
+      | InvalidRequestError
+      | UnexpectedClientError
+      | SDKValidationError
+    >,
+    { page: number }
   >
 > {
   return new APIPromise($do(
@@ -63,17 +78,20 @@ async function $do(
   options?: RequestOptions,
 ): Promise<
   [
-    Result<
-      operations.ListAllWebhookEndpointsListAllWebhookEndpointsOk,
-      | errors.ApiErrorResponse
-      | GreenSecurityError
-      | ResponseValidationError
-      | ConnectionError
-      | RequestAbortedError
-      | RequestTimeoutError
-      | InvalidRequestError
-      | UnexpectedClientError
-      | SDKValidationError
+    PageIterator<
+      Result<
+        operations.ListAllWebhookEndpointsResponse,
+        | errors.ApiErrorResponse
+        | GreenSecurityError
+        | ResponseValidationError
+        | ConnectionError
+        | RequestAbortedError
+        | RequestTimeoutError
+        | InvalidRequestError
+        | UnexpectedClientError
+        | SDKValidationError
+      >,
+      { page: number }
     >,
     APICall,
   ]
@@ -85,7 +103,7 @@ async function $do(
     "Input validation failed",
   );
   if (!parsed.ok) {
-    return [parsed, { status: "invalid" }];
+    return [haltIterator(parsed), { status: "invalid" }];
   }
   const payload = parsed.value;
   const body = null;
@@ -133,7 +151,7 @@ async function $do(
     timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
   }, options);
   if (!requestRes.ok) {
-    return [requestRes, { status: "invalid" }];
+    return [haltIterator(requestRes), { status: "invalid" }];
   }
   const req = requestRes.value;
 
@@ -145,7 +163,7 @@ async function $do(
     retryCodes: context.retryCodes,
   });
   if (!doResult.ok) {
-    return [doResult, { status: "request-error", request: req }];
+    return [haltIterator(doResult), { status: "request-error", request: req }];
   }
   const response = doResult.value;
 
@@ -153,8 +171,8 @@ async function $do(
     HttpMeta: { Response: response, Request: req },
   };
 
-  const [result] = await M.match<
-    operations.ListAllWebhookEndpointsListAllWebhookEndpointsOk,
+  const [result, raw] = await M.match<
+    operations.ListAllWebhookEndpointsResponse,
     | errors.ApiErrorResponse
     | GreenSecurityError
     | ResponseValidationError
@@ -165,17 +183,72 @@ async function $do(
     | UnexpectedClientError
     | SDKValidationError
   >(
-    M.json(
-      200,
-      operations.ListAllWebhookEndpointsListAllWebhookEndpointsOk$inboundSchema,
-    ),
-    M.jsonErr([400, 401, 403], errors.ApiErrorResponse$inboundSchema),
+    M.json(200, operations.ListAllWebhookEndpointsResponse$inboundSchema, {
+      key: "Result",
+    }),
+    M.jsonErr([400, 401, 403, 422], errors.ApiErrorResponse$inboundSchema),
     M.fail("4XX"),
     M.fail([500, "5XX"]),
   )(response, req, { extraFields: responseFields });
   if (!result.ok) {
-    return [result, { status: "complete", request: req, response }];
+    return [haltIterator(result), {
+      status: "complete",
+      request: req,
+      response,
+    }];
   }
 
-  return [result, { status: "complete", request: req, response }];
+  const nextFunc = (
+    responseData: unknown,
+  ): {
+    next: Paginator<
+      Result<
+        operations.ListAllWebhookEndpointsResponse,
+        | errors.ApiErrorResponse
+        | GreenSecurityError
+        | ResponseValidationError
+        | ConnectionError
+        | RequestAbortedError
+        | RequestTimeoutError
+        | InvalidRequestError
+        | UnexpectedClientError
+        | SDKValidationError
+      >
+    >;
+    "~next"?: { page: number };
+  } => {
+    const page = request?.page ?? 1;
+    const nextPage = page + 1;
+
+    if (!responseData) {
+      return { next: () => null };
+    }
+    const results = (responseData as { items: unknown }).items;
+    if (!Array.isArray(results) || !results.length) {
+      return { next: () => null };
+    }
+    const limit = request?.itemsPerPage ?? 0;
+    if (results.length < limit) {
+      return { next: () => null };
+    }
+
+    const nextVal = () =>
+      webhooksListAllWebhookEndpoints(
+        client,
+        {
+          ...request,
+          page: nextPage,
+        },
+        options,
+      );
+
+    return { next: nextVal, "~next": { page: nextPage } };
+  };
+
+  const page = { ...result, ...nextFunc(raw) };
+  return [{ ...page, ...createPageIterator(page, (v) => !v.ok) }, {
+    status: "complete",
+    request: req,
+    response,
+  }];
 }

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/funcs/zonesListOrSearchSecurityZones.ts

@@ -3,7 +3,6 @@
  */
 
 import { GreenSecurityCore } from "../core.js";
-import { dlv } from "../lib/dlv.js";
 import { encodeFormQuery } from "../lib/encodings.js";
 import { matchStatusCode } from "../lib/http.js";
 import * as M from "../lib/matchers.js";
@@ -226,7 +225,7 @@ async function $do(
     if (!responseData) {
       return { next: () => null };
     }
-    const results = dlv(responseData, "items");
+    const results = (responseData as { items: unknown }).items;
     if (!Array.isArray(results) || !results.length) {
       return { next: () => null };
     }

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,15 +6,22 @@ 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;
   options: SDKOptions;
+  timeoutMs?: number;
 };
 
 export type Awaitable<T> = T | Promise<T>;
@@ -28,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
@@ -90,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. */
@@ -102,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 =
@@ -109,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/index.extras.ts

@@ -5,6 +5,9 @@ import { getInternalCore, initializeInternalCore, initializeInternalCoreByUrl }
 import { getFacilitiesJson } from "./admin-funcs/getfacilitiesjson.js";
 import { getVendorRegisterFinalizeData } from "./admin-funcs/vendorregisterfinalizedata.js";
 
+import { pageRedirectSendVerificationCode } from "./admin-funcs/pageRedirectSendVerificationCode.js";
+import { pageRedirectVerifyEmail } from "./admin-funcs/pageRedirectVerifyEmail.js";
+
 import { subscriptionGetSummary } from "./admin-funcs/subscriptionGetSummary.js";
 import { subscriptionGetFacilities } from "./admin-funcs/subscriptionGetFacilities.js";
 import { subscriptionUpdateFacilities } from "./admin-funcs/subscriptionUpdateFacilities.js";
@@ -15,6 +18,7 @@ import { subscriptionFinishScreeningQuestions } from "./admin-funcs/subscription
 import { subscriptionGetPlans } from "./admin-funcs/subscriptionGetPlans.js";
 import { subscriptionUpdatePlan } from "./admin-funcs/subscriptionUpdatePlan.js";
 import { subscriptionGetInvoice } from "./admin-funcs/subscriptionGetInvoice.js";
+import { subscriptionGetSmartBadgePrompt } from "./admin-funcs/subscriptionGetSmartBadgePrompt.js";
 import { subscriptionFinishInvoice } from "./admin-funcs/subscriptionFinishInvoice.js";
 import { subscriptionGetVendorTypes } from "./admin-funcs/subscriptionGetVendorTypes.js";
 import { subscriptionUpdateVendorType } from "./admin-funcs/subscriptionUpdateVendorType.js";
@@ -29,10 +33,16 @@ import { submitPassword } from "./admin-funcs/registerPassword.js";
 import { submitGeneralInfo } from "./admin-funcs/registerGeneralInfo.js";
 import { submitCompany } from "./admin-funcs/registerCompanies.js";
 
-import {smartBadgePairBadge} from "./admin-funcs/smartBadgePairBadge.js";
-import {smartBadgeUnpairBadge} from "./admin-funcs/smartBadgeUnpairBadge.js";
+import { smartBadgePairBadge } from "./admin-funcs/smartBadgePairBadge.js";
+import { smartBadgeUnpairBadge } from "./admin-funcs/smartBadgeUnpairBadge.js";
+import { smartBadgeGetPsks } from "./admin-funcs/smartBadgeGetPsks.js";
+import { smartBadgeReportVerifiedPsk } from "./admin-funcs/smartBadgeReportVerifiedPsk.js";
 
 import { notifyVendorCredentialFileUploaded } from "./admin-funcs/notifyVendorCredentialFileUploaded.js";
+import { companyManagerGetPaymentForm } from "./admin-funcs/companyManagerGetPaymentForm.js";
+import { vendorGetPaymentForm } from "./admin-funcs/vendorGetPaymentForm.js";
+import { vendorGetSystemsRequiringSmartBadge } from "./admin-funcs/vendorGetSystemsRequiringSmartBadge.js";
+import { vendorGetCompanyCredentialsSummary } from "./admin-funcs/vendorGetCompanyCredentialsSummary.js";
 
 export const __internal = {
   getInternalCore,
@@ -47,6 +57,11 @@ export const __internal = {
   submitUserFeedback,
   addJsError,
   handoffStayAlive,
+  
+  pageRedirect: {
+    verifyEmail: pageRedirectVerifyEmail,
+    sendVerificationCode: pageRedirectSendVerificationCode
+  },
 
   // In order of steps
   subscription: {
@@ -60,6 +75,7 @@ export const __internal = {
     getPlans: subscriptionGetPlans,
     updatePlan: subscriptionUpdatePlan,
     getInvoice: subscriptionGetInvoice,
+    getSmartBadgePrompt: subscriptionGetSmartBadgePrompt,
     finishInvoice: subscriptionFinishInvoice,
     getVendorTypes: subscriptionGetVendorTypes,
     updateVendorType: subscriptionUpdateVendorType,
@@ -74,13 +90,25 @@ export const __internal = {
     submitGeneralInfo,
     submitCompany
   },
-  
+
   smartBadge: {
     pairBadge: smartBadgePairBadge,
-    unpairBadge: smartBadgeUnpairBadge
+    unpairBadge: smartBadgeUnpairBadge,
+    getPsks: smartBadgeGetPsks,
+    reportVerifiedPsk: smartBadgeReportVerifiedPsk
   },
 
   vendorCredentialFile: {
     notifyUploaded: notifyVendorCredentialFileUploaded
+  },
+
+  companyManager: {
+    getPaymentForm: companyManagerGetPaymentForm,
+  },
+
+  vendor: {
+    getPaymentForm: vendorGetPaymentForm,
+    getSystemsRequiringSmartBadge: vendorGetSystemsRequiringSmartBadge,
+    getCompanyCredentialsSummary: vendorGetCompanyCredentialsSummary
   }
 };

package/src/lib/config.ts

@@ -79,9 +79,9 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 
 export const SDK_METADATA = {
   language: "typescript",
-  openapiDocVersion: "0.43.1",
-  sdkVersion: "0.44.0-beta.9",
-  genVersion: "2.893.0",
+  openapiDocVersion: "0.44.0",
+  sdkVersion: "0.45.0-beta.0",
+  genVersion: "2.932.9",
   userAgent:
-    "speakeasy-sdk/typescript 0.44.0-beta.9 2.893.0 0.43.1 @greensecurity/javascript-sdk",
+    "speakeasy-sdk/typescript 0.45.0-beta.0 2.932.9 0.44.0 @greensecurity/javascript-sdk",
 } as const;

package/src/lib/encodings.ts

@@ -3,7 +3,7 @@
  */
 
 import { bytesToBase64 } from "./base64.js";
-import { isPlainObject } from "./is-plain-object.js";
+import { isPlainObject } from "./primitives.js";
 
 export class EncodingError extends Error {
   constructor(message: string) {