@zyphr-dev/node-sdk 0.1.48 → 0.1.49

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zyphr-dev/node-sdk",
-  "version": "0.1.48",
+  "version": "0.1.49",
   "description": "Official Zyphr SDK for Node.js, React, and React Native",
   "type": "module",
   "main": "./dist/index.cjs",

package/src/.openapi-generator/FILES

@@ -270,9 +270,12 @@ src/models/OrganizationMembershipResponse.ts
 src/models/OrganizationMembershipWithUser.ts
 src/models/OrganizationResponse.ts
 src/models/PaginationMeta.ts
-src/models/PasswordRequirements.ts
+src/models/PasswordPolicy.ts
 src/models/PasswordRequirementsResponse.ts
 src/models/PasswordRequirementsResponseData.ts
+src/models/PasswordStrength.ts
+src/models/PasswordStrengthRequest.ts
+src/models/PasswordStrengthResponse.ts
 src/models/PayloadTooLargeError.ts
 src/models/PayloadTooLargeErrorError.ts
 src/models/PayloadTooLargeErrorErrorDetails.ts

package/src/client.ts

@@ -33,6 +33,7 @@ import {
   AuthWebAuthnApi,
   DevicesApi,
   DomainsApi,
+  UtilityApi,
   EmailsApi,
   InboundEmailApi,
   InboxApi,
@@ -98,6 +99,9 @@ export class Zyphr {
   readonly webhooks: WebhooksApi;
   readonly topics: TopicsApi;
   readonly devices: DevicesApi;
+
+  /** Publishable-key-safe utilities: password policy + pre-submit strength check. */
+  readonly utility: UtilityApi;
   readonly domains: DomainsApi;
   /** Inbound (received) email — read access. Requires the `email:read` scope. */
   readonly inbound: InboundEmailApi;
@@ -156,6 +160,7 @@ export class Zyphr {
     this.webhooks = new WebhooksApi(config);
     this.topics = new TopicsApi(config);
     this.devices = new DevicesApi(config);
+    this.utility = new UtilityApi(config);
     this.domains = new DomainsApi(config);
     this.inbound = new InboundEmailApi(config);
 

package/src/clientAuth.ts

@@ -50,6 +50,7 @@ import {
   AuthUserProfileApi,
   AuthWebAuthnApi,
   DevicesApi,
+  UtilityApi,
 } from './src/apis/index.js';
 import { parseErrorResponse } from './errors.js';
 
@@ -138,6 +139,13 @@ export class ZyphrClient {
   /** Device registration for push (takes an OS-acquired token). */
   readonly devices: DevicesApi;
 
+  /**
+   * Utility endpoints that are publishable-key-safe: the application's password
+   * policy (`getPasswordRequirements`) and a pre-submit password strength check
+   * (`checkPasswordStrength`). Useful for building a live registration UX.
+   */
+  readonly utility: UtilityApi;
+
   private readonly applicationKey: string;
   private accessToken?: string;
 
@@ -196,6 +204,7 @@ export class ZyphrClient {
       webauthn: new AuthWebAuthnApi(config),
     };
     this.devices = new DevicesApi(config);
+    this.utility = new UtilityApi(config);
   }
 
   /** Store the end-user access token; it is applied automatically to subsequent user-scoped calls. */

package/src/src/apis/UtilityApi.ts

@@ -17,14 +17,24 @@ import * as runtime from '../runtime';
 import type {
   ApiError,
   PasswordRequirementsResponse,
+  PasswordStrengthRequest,
+  PasswordStrengthResponse,
 } from '../models/index';
 import {
     ApiErrorFromJSON,
     ApiErrorToJSON,
     PasswordRequirementsResponseFromJSON,
     PasswordRequirementsResponseToJSON,
+    PasswordStrengthRequestFromJSON,
+    PasswordStrengthRequestToJSON,
+    PasswordStrengthResponseFromJSON,
+    PasswordStrengthResponseToJSON,
 } from '../models/index';
 
+export interface UtilityApiCheckPasswordStrengthRequest {
+    passwordStrengthRequest: PasswordStrengthRequest;
+}
+
 /**
  * UtilityApi - interface
  * 
@@ -33,7 +43,23 @@ import {
  */
 export interface UtilityApiInterface {
     /**
-     * Get password requirements for the application. Useful for client-side validation before registration.
+     * Pre-submit password check for a live registration/reset experience. Returns whether the password would be accepted by the server (`valid`), a strength `score` (0-100) and `label`, and actionable `feedback`. When an `email` is supplied, a password that resembles the email\'s local-part is flagged and marked invalid. The password is never logged or persisted.
+     * @summary Check password strength
+     * @param {PasswordStrengthRequest} passwordStrengthRequest 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof UtilityApiInterface
+     */
+    checkPasswordStrengthRaw(requestParameters: UtilityApiCheckPasswordStrengthRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PasswordStrengthResponse>>;
+
+    /**
+     * Pre-submit password check for a live registration/reset experience. Returns whether the password would be accepted by the server (`valid`), a strength `score` (0-100) and `label`, and actionable `feedback`. When an `email` is supplied, a password that resembles the email\'s local-part is flagged and marked invalid. The password is never logged or persisted.
+     * Check password strength
+     */
+    checkPasswordStrength(passwordStrengthRequest: PasswordStrengthRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PasswordStrengthResponse>;
+
+    /**
+     * Get password requirements for the application. Returns both a structured `policy` object (for driving a live requirements checklist) and human-readable `requirements` display strings. Useful for client-side validation before registration.
      * @summary Get password requirements
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
@@ -42,7 +68,7 @@ export interface UtilityApiInterface {
     getPasswordRequirementsRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PasswordRequirementsResponse>>;
 
     /**
-     * Get password requirements for the application. Useful for client-side validation before registration.
+     * Get password requirements for the application. Returns both a structured `policy` object (for driving a live requirements checklist) and human-readable `requirements` display strings. Useful for client-side validation before registration.
      * Get password requirements
      */
     getPasswordRequirements(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PasswordRequirementsResponse>;
@@ -55,7 +81,49 @@ export interface UtilityApiInterface {
 export class UtilityApi extends runtime.BaseAPI implements UtilityApiInterface {
 
     /**
-     * Get password requirements for the application. Useful for client-side validation before registration.
+     * Pre-submit password check for a live registration/reset experience. Returns whether the password would be accepted by the server (`valid`), a strength `score` (0-100) and `label`, and actionable `feedback`. When an `email` is supplied, a password that resembles the email\'s local-part is flagged and marked invalid. The password is never logged or persisted.
+     * Check password strength
+     */
+    async checkPasswordStrengthRaw(requestParameters: UtilityApiCheckPasswordStrengthRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PasswordStrengthResponse>> {
+        if (requestParameters['passwordStrengthRequest'] == null) {
+            throw new runtime.RequiredError(
+                'passwordStrengthRequest',
+                'Required parameter "passwordStrengthRequest" was null or undefined when calling checkPasswordStrength().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["X-Application-Key"] = await this.configuration.apiKey("X-Application-Key"); // ApplicationPublicKey authentication
+        }
+
+        const response = await this.request({
+            path: `/auth/password-strength`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PasswordStrengthRequestToJSON(requestParameters['passwordStrengthRequest']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => PasswordStrengthResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Pre-submit password check for a live registration/reset experience. Returns whether the password would be accepted by the server (`valid`), a strength `score` (0-100) and `label`, and actionable `feedback`. When an `email` is supplied, a password that resembles the email\'s local-part is flagged and marked invalid. The password is never logged or persisted.
+     * Check password strength
+     */
+    async checkPasswordStrength(passwordStrengthRequest: PasswordStrengthRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PasswordStrengthResponse> {
+        const response = await this.checkPasswordStrengthRaw({ passwordStrengthRequest: passwordStrengthRequest }, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Get password requirements for the application. Returns both a structured `policy` object (for driving a live requirements checklist) and human-readable `requirements` display strings. Useful for client-side validation before registration.
      * Get password requirements
      */
     async getPasswordRequirementsRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PasswordRequirementsResponse>> {
@@ -78,7 +146,7 @@ export class UtilityApi extends runtime.BaseAPI implements UtilityApiInterface {
     }
 
     /**
-     * Get password requirements for the application. Useful for client-side validation before registration.
+     * Get password requirements for the application. Returns both a structured `policy` object (for driving a live requirements checklist) and human-readable `requirements` display strings. Useful for client-side validation before registration.
      * Get password requirements
      */
     async getPasswordRequirements(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PasswordRequirementsResponse> {

package/src/src/models/PasswordPolicy.ts

@@ -0,0 +1,120 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Zyphr API
+ * Zyphr is a multi-channel notification platform that enables developers to send emails, push notifications, SMS, and in-app messages through a unified API.  ## Authentication  All API requests require authentication using an API key. Include your API key in the `X-API-Key` header:  ``` X-API-Key: zy_live_xxxxxxxxxxxx ```  API keys can be created in the Zyphr Dashboard. Use `zy_test_*` keys for testing and `zy_live_*` keys for production.  ## Rate Limiting  The API implements rate limiting to ensure fair usage. Rate limit information is included in response headers:  - `X-RateLimit-Limit`: Maximum requests per window - `X-RateLimit-Remaining`: Remaining requests in current window - `X-RateLimit-Reset`: Unix timestamp when the window resets  ## Account Sending Status  Every authenticated response carries the account\'s current sending state so you can surface it in your own tooling without a separate call:  - `X-Account-Sending-Status`: `active`, `throttled`, or `frozen` - `X-Account-Sending-Status-Reason`: human-readable reason (present only when the status is `throttled` or `frozen`)  This header is informational and non-blocking on non-send endpoints (reads, billing, and deliverability stay available). Send-capable endpoints additionally enforce the state: a frozen account receives `403 account_frozen` and a throttled account receives `429 account_throttled`, both with the reason in the error message.  ## Errors  All errors follow a consistent format:  ```json {   \"error\": {     \"code\": \"error_code\",     \"message\": \"Human readable message\",     \"details\": {}   },   \"meta\": {     \"request_id\": \"req_xxxx\"   } } ```
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: support@zyphr.dev
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { mapValues } from '../runtime';
+/**
+ * Structured password policy rules for the application. Use these fields to drive a live, client-side requirements checklist (e.g. a green/grey indicator per rule) before submitting a registration or reset.
+ * @export
+ * @interface PasswordPolicy
+ */
+export interface PasswordPolicy {
+    /**
+     * Minimum password length.
+     * @type {number}
+     * @memberof PasswordPolicy
+     */
+    minLength: number;
+    /**
+     * Maximum password length.
+     * @type {number}
+     * @memberof PasswordPolicy
+     */
+    maxLength: number;
+    /**
+     * Whether at least one uppercase letter (A-Z) is required.
+     * @type {boolean}
+     * @memberof PasswordPolicy
+     */
+    requireUppercase: boolean;
+    /**
+     * Whether at least one lowercase letter (a-z) is required.
+     * @type {boolean}
+     * @memberof PasswordPolicy
+     */
+    requireLowercase: boolean;
+    /**
+     * Whether at least one number (0-9) is required.
+     * @type {boolean}
+     * @memberof PasswordPolicy
+     */
+    requireNumbers: boolean;
+    /**
+     * Whether at least one special character is required.
+     * @type {boolean}
+     * @memberof PasswordPolicy
+     */
+    requireSpecial: boolean;
+    /**
+     * Whether commonly used passwords are rejected.
+     * @type {boolean}
+     * @memberof PasswordPolicy
+     */
+    disallowCommon: boolean;
+}
+
+/**
+ * Check if a given object implements the PasswordPolicy interface.
+ */
+export function instanceOfPasswordPolicy(value: object): value is PasswordPolicy {
+    if (!('minLength' in value) || value['minLength'] === undefined) return false;
+    if (!('maxLength' in value) || value['maxLength'] === undefined) return false;
+    if (!('requireUppercase' in value) || value['requireUppercase'] === undefined) return false;
+    if (!('requireLowercase' in value) || value['requireLowercase'] === undefined) return false;
+    if (!('requireNumbers' in value) || value['requireNumbers'] === undefined) return false;
+    if (!('requireSpecial' in value) || value['requireSpecial'] === undefined) return false;
+    if (!('disallowCommon' in value) || value['disallowCommon'] === undefined) return false;
+    return true;
+}
+
+export function PasswordPolicyFromJSON(json: any): PasswordPolicy {
+    return PasswordPolicyFromJSONTyped(json, false);
+}
+
+export function PasswordPolicyFromJSONTyped(json: any, ignoreDiscriminator: boolean): PasswordPolicy {
+    if (json == null) {
+        return json;
+    }
+    return {
+        
+        'minLength': json['min_length'],
+        'maxLength': json['max_length'],
+        'requireUppercase': json['require_uppercase'],
+        'requireLowercase': json['require_lowercase'],
+        'requireNumbers': json['require_numbers'],
+        'requireSpecial': json['require_special'],
+        'disallowCommon': json['disallow_common'],
+    };
+}
+
+export function PasswordPolicyToJSON(json: any): PasswordPolicy {
+    return PasswordPolicyToJSONTyped(json, false);
+}
+
+export function PasswordPolicyToJSONTyped(value?: PasswordPolicy | null, ignoreDiscriminator: boolean = false): any {
+    if (value == null) {
+        return value;
+    }
+
+    return {
+        
+        'min_length': value['minLength'],
+        'max_length': value['maxLength'],
+        'require_uppercase': value['requireUppercase'],
+        'require_lowercase': value['requireLowercase'],
+        'require_numbers': value['requireNumbers'],
+        'require_special': value['requireSpecial'],
+        'disallow_common': value['disallowCommon'],
+    };
+}
+

package/src/src/models/PasswordRequirementsResponseData.ts

@@ -13,13 +13,13 @@
  */
 
 import { mapValues } from '../runtime';
-import type { PasswordRequirements } from './PasswordRequirements';
+import type { PasswordPolicy } from './PasswordPolicy';
 import {
-    PasswordRequirementsFromJSON,
-    PasswordRequirementsFromJSONTyped,
-    PasswordRequirementsToJSON,
-    PasswordRequirementsToJSONTyped,
-} from './PasswordRequirements';
+    PasswordPolicyFromJSON,
+    PasswordPolicyFromJSONTyped,
+    PasswordPolicyToJSON,
+    PasswordPolicyToJSONTyped,
+} from './PasswordPolicy';
 
 /**
  * 
@@ -29,16 +29,24 @@ import {
 export interface PasswordRequirementsResponseData {
     /**
      * 
-     * @type {PasswordRequirements}
+     * @type {PasswordPolicy}
      * @memberof PasswordRequirementsResponseData
      */
-    requirements?: PasswordRequirements;
+    policy: PasswordPolicy;
+    /**
+     * Human-readable display strings for the active password rules (e.g. "At least 8 characters"). Backward-compatible with the original response shape.
+     * @type {Array<string>}
+     * @memberof PasswordRequirementsResponseData
+     */
+    requirements: Array<string>;
 }
 
 /**
  * Check if a given object implements the PasswordRequirementsResponseData interface.
  */
 export function instanceOfPasswordRequirementsResponseData(value: object): value is PasswordRequirementsResponseData {
+    if (!('policy' in value) || value['policy'] === undefined) return false;
+    if (!('requirements' in value) || value['requirements'] === undefined) return false;
     return true;
 }
 
@@ -52,7 +60,8 @@ export function PasswordRequirementsResponseDataFromJSONTyped(json: any, ignoreD
     }
     return {
         
-        'requirements': json['requirements'] == null ? undefined : PasswordRequirementsFromJSON(json['requirements']),
+        'policy': PasswordPolicyFromJSON(json['policy']),
+        'requirements': json['requirements'],
     };
 }
 
@@ -67,7 +76,8 @@ export function PasswordRequirementsResponseDataToJSONTyped(value?: PasswordRequ
 
     return {
         
-        'requirements': PasswordRequirementsToJSON(value['requirements']),
+        'policy': PasswordPolicyToJSON(value['policy']),
+        'requirements': value['requirements'],
     };
 }
 

package/src/src/models/{PasswordRequirements.ts → PasswordStrength.ts}

@@ -16,90 +16,91 @@ import { mapValues } from '../runtime';
 /**
  * 
  * @export
- * @interface PasswordRequirements
+ * @interface PasswordStrength
  */
-export interface PasswordRequirements {
+export interface PasswordStrength {
     /**
-     * 
-     * @type {number}
-     * @memberof PasswordRequirements
-     */
-    minLength?: number;
-    /**
-     * 
-     * @type {number}
-     * @memberof PasswordRequirements
-     */
-    maxLength?: number;
-    /**
-     * 
+     * Whether the password would be accepted by the server's enforcement path. A password that is valid here is accepted by registration.
      * @type {boolean}
-     * @memberof PasswordRequirements
+     * @memberof PasswordStrength
      */
-    requireUppercase?: boolean;
+    valid: boolean;
     /**
-     * 
-     * @type {boolean}
-     * @memberof PasswordRequirements
+     * Strength score, 0-100.
+     * @type {number}
+     * @memberof PasswordStrength
      */
-    requireLowercase?: boolean;
+    score: number;
     /**
-     * 
-     * @type {boolean}
-     * @memberof PasswordRequirements
+     * Strength label derived from the score.
+     * @type {string}
+     * @memberof PasswordStrength
      */
-    requireNumbers?: boolean;
+    label: PasswordStrengthLabelEnum;
     /**
-     * 
-     * @type {boolean}
-     * @memberof PasswordRequirements
+     * Actionable feedback — policy errors plus strength-improvement suggestions.
+     * @type {Array<string>}
+     * @memberof PasswordStrength
      */
-    requireSpecial?: boolean;
+    feedback: Array<string>;
 }
 
+
+/**
+ * @export
+ */
+export const PasswordStrengthLabelEnum = {
+    WEAK: 'weak',
+    FAIR: 'fair',
+    GOOD: 'good',
+    STRONG: 'strong'
+} as const;
+export type PasswordStrengthLabelEnum = typeof PasswordStrengthLabelEnum[keyof typeof PasswordStrengthLabelEnum];
+
+
 /**
- * Check if a given object implements the PasswordRequirements interface.
+ * Check if a given object implements the PasswordStrength interface.
  */
-export function instanceOfPasswordRequirements(value: object): value is PasswordRequirements {
+export function instanceOfPasswordStrength(value: object): value is PasswordStrength {
+    if (!('valid' in value) || value['valid'] === undefined) return false;
+    if (!('score' in value) || value['score'] === undefined) return false;
+    if (!('label' in value) || value['label'] === undefined) return false;
+    if (!('feedback' in value) || value['feedback'] === undefined) return false;
     return true;
 }
 
-export function PasswordRequirementsFromJSON(json: any): PasswordRequirements {
-    return PasswordRequirementsFromJSONTyped(json, false);
+export function PasswordStrengthFromJSON(json: any): PasswordStrength {
+    return PasswordStrengthFromJSONTyped(json, false);
 }
 
-export function PasswordRequirementsFromJSONTyped(json: any, ignoreDiscriminator: boolean): PasswordRequirements {
+export function PasswordStrengthFromJSONTyped(json: any, ignoreDiscriminator: boolean): PasswordStrength {
     if (json == null) {
         return json;
     }
     return {
         
-        'minLength': json['min_length'] == null ? undefined : json['min_length'],
-        'maxLength': json['max_length'] == null ? undefined : json['max_length'],
-        'requireUppercase': json['require_uppercase'] == null ? undefined : json['require_uppercase'],
-        'requireLowercase': json['require_lowercase'] == null ? undefined : json['require_lowercase'],
-        'requireNumbers': json['require_numbers'] == null ? undefined : json['require_numbers'],
-        'requireSpecial': json['require_special'] == null ? undefined : json['require_special'],
+        'valid': json['valid'],
+        'score': json['score'],
+        'label': json['label'],
+        'feedback': json['feedback'],
     };
 }
 
-export function PasswordRequirementsToJSON(json: any): PasswordRequirements {
-    return PasswordRequirementsToJSONTyped(json, false);
+export function PasswordStrengthToJSON(json: any): PasswordStrength {
+    return PasswordStrengthToJSONTyped(json, false);
 }
 
-export function PasswordRequirementsToJSONTyped(value?: PasswordRequirements | null, ignoreDiscriminator: boolean = false): any {
+export function PasswordStrengthToJSONTyped(value?: PasswordStrength | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
 
     return {
         
-        'min_length': value['minLength'],
-        'max_length': value['maxLength'],
-        'require_uppercase': value['requireUppercase'],
-        'require_lowercase': value['requireLowercase'],
-        'require_numbers': value['requireNumbers'],
-        'require_special': value['requireSpecial'],
+        'valid': value['valid'],
+        'score': value['score'],
+        'label': value['label'],
+        'feedback': value['feedback'],
     };
 }
 

package/src/src/models/PasswordStrengthRequest.ts

@@ -0,0 +1,74 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Zyphr API
+ * Zyphr is a multi-channel notification platform that enables developers to send emails, push notifications, SMS, and in-app messages through a unified API.  ## Authentication  All API requests require authentication using an API key. Include your API key in the `X-API-Key` header:  ``` X-API-Key: zy_live_xxxxxxxxxxxx ```  API keys can be created in the Zyphr Dashboard. Use `zy_test_*` keys for testing and `zy_live_*` keys for production.  ## Rate Limiting  The API implements rate limiting to ensure fair usage. Rate limit information is included in response headers:  - `X-RateLimit-Limit`: Maximum requests per window - `X-RateLimit-Remaining`: Remaining requests in current window - `X-RateLimit-Reset`: Unix timestamp when the window resets  ## Account Sending Status  Every authenticated response carries the account\'s current sending state so you can surface it in your own tooling without a separate call:  - `X-Account-Sending-Status`: `active`, `throttled`, or `frozen` - `X-Account-Sending-Status-Reason`: human-readable reason (present only when the status is `throttled` or `frozen`)  This header is informational and non-blocking on non-send endpoints (reads, billing, and deliverability stay available). Send-capable endpoints additionally enforce the state: a frozen account receives `403 account_frozen` and a throttled account receives `429 account_throttled`, both with the reason in the error message.  ## Errors  All errors follow a consistent format:  ```json {   \"error\": {     \"code\": \"error_code\",     \"message\": \"Human readable message\",     \"details\": {}   },   \"meta\": {     \"request_id\": \"req_xxxx\"   } } ```
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: support@zyphr.dev
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { mapValues } from '../runtime';
+/**
+ * Pre-submit password strength check request. The password is evaluated against the application's policy and never logged or persisted.
+ * @export
+ * @interface PasswordStrengthRequest
+ */
+export interface PasswordStrengthRequest {
+    /**
+     * The password to evaluate.
+     * @type {string}
+     * @memberof PasswordStrengthRequest
+     */
+    password: string;
+    /**
+     * Optional. When provided, the password is checked for similarity to the email's local-part; a match is flagged and marks the password invalid.
+     * @type {string}
+     * @memberof PasswordStrengthRequest
+     */
+    email?: string;
+}
+
+/**
+ * Check if a given object implements the PasswordStrengthRequest interface.
+ */
+export function instanceOfPasswordStrengthRequest(value: object): value is PasswordStrengthRequest {
+    if (!('password' in value) || value['password'] === undefined) return false;
+    return true;
+}
+
+export function PasswordStrengthRequestFromJSON(json: any): PasswordStrengthRequest {
+    return PasswordStrengthRequestFromJSONTyped(json, false);
+}
+
+export function PasswordStrengthRequestFromJSONTyped(json: any, ignoreDiscriminator: boolean): PasswordStrengthRequest {
+    if (json == null) {
+        return json;
+    }
+    return {
+        
+        'password': json['password'],
+        'email': json['email'] == null ? undefined : json['email'],
+    };
+}
+
+export function PasswordStrengthRequestToJSON(json: any): PasswordStrengthRequest {
+    return PasswordStrengthRequestToJSONTyped(json, false);
+}
+
+export function PasswordStrengthRequestToJSONTyped(value?: PasswordStrengthRequest | null, ignoreDiscriminator: boolean = false): any {
+    if (value == null) {
+        return value;
+    }
+
+    return {
+        
+        'password': value['password'],
+        'email': value['email'],
+    };
+}
+