@bitwarden/sdk-internal 0.2.0-main.159 → 0.2.0-main.160

package/VERSION

@@ -1 +1 @@
-c6835e59d5abdd50a117729dd718a23029a71ad8
+08722745ba9689df9505591848cd26d4f54c01e9

package/bitwarden_wasm_internal.d.ts

@@ -338,6 +338,19 @@ export interface ExportError extends Error {
 
 export function isExportError(error: any): error is ExportError;
 
+export type UsernameGeneratorRequest =
+  | { word: { capitalize: boolean; include_number: boolean } }
+  | { subaddress: { type: AppendType; email: string } }
+  | { catchall: { type: AppendType; domain: string } }
+  | { forwarded: { service: ForwarderServiceType; website: string | undefined } };
+
+export interface UsernameError extends Error {
+  name: "UsernameError";
+  variant: "InvalidApiKey" | "Unknown" | "ResponseContent" | "Reqwest";
+}
+
+export function isUsernameError(error: any): error is UsernameError;
+
 /**
  * Password generator request options.
  */
@@ -1089,27 +1102,57 @@ export class GeneratorClient {
   private constructor();
   free(): void;
   /**
-   * Generates a password from a provided request
+   * Generates a random password.
    *
-   * # Arguments
-   * - `request` - Settings for the character sets and password length
+   * The character sets and password length can be customized using the `input` parameter.
    *
-   * # Returns
-   * - `Ok(String)` containing the generated password
-   * - `Err(PasswordError)` if password generation fails
-   */
-  password(request: PasswordGeneratorRequest): string;
-  /**
-   * Generates a passphrase from a provided request
+   * # Examples
    *
-   * # Arguments
-   * - `request` - Settings for the word count, word separators character sets
+   * ```
+   * use bitwarden_core::Client;
+   * use bitwarden_generators::{GeneratorClientsExt, PassphraseError, PasswordGeneratorRequest};
    *
-   * # Returns
-   * - `Ok(String)` containing the generated passphrase
-   * - `Err(PassphraseError)` if passphrase generation fails
-   */
-  passphrase(request: PassphraseGeneratorRequest): string;
+   * async fn test() -> Result<(), PassphraseError> {
+   *     let input = PasswordGeneratorRequest {
+   *         lowercase: true,
+   *         uppercase: true,
+   *         numbers: true,
+   *         length: 20,
+   *         ..Default::default()
+   *     };
+   *     let password = Client::new(None).generator().password(input).unwrap();
+   *     println!("{}", password);
+   *     Ok(())
+   * }
+   * ```
+   */
+  password(input: PasswordGeneratorRequest): string;
+  /**
+   * Generates a random passphrase.
+   * A passphrase is a combination of random words separated by a character.
+   * An example of passphrase is `correct horse battery staple`.
+   *
+   * The number of words and their case, the word separator, and the inclusion of
+   * a number in the passphrase can be customized using the `input` parameter.
+   *
+   * # Examples
+   *
+   * ```
+   * use bitwarden_core::Client;
+   * use bitwarden_generators::{GeneratorClientsExt, PassphraseError, PassphraseGeneratorRequest};
+   *
+   * async fn test() -> Result<(), PassphraseError> {
+   *     let input = PassphraseGeneratorRequest {
+   *         num_words: 4,
+   *         ..Default::default()
+   *     };
+   *     let passphrase = Client::new(None).generator().passphrase(input).unwrap();
+   *     println!("{}", passphrase);
+   *     Ok(())
+   * }
+   * ```
+   */
+  passphrase(input: PassphraseGeneratorRequest): string;
 }
 export class IncomingMessage {
   free(): void;

package/bitwarden_wasm_internal_bg.js

@@ -309,6 +309,19 @@ export function isExportError(error) {
   }
 }
 
+/**
+ * @param {any} error
+ * @returns {boolean}
+ */
+export function isUsernameError(error) {
+  try {
+    const ret = wasm.isUsernameError(addBorrowedObject(error));
+    return ret !== 0;
+  } finally {
+    heap[stack_pointer++] = undefined;
+  }
+}
+
 /**
  * @param {any} error
  * @returns {boolean}
@@ -600,7 +613,7 @@ function __wbg_adapter_53(arg0, arg1, arg2) {
   );
 }
 
-function __wbg_adapter_237(arg0, arg1, arg2, arg3) {
+function __wbg_adapter_238(arg0, arg1, arg2, arg3) {
   wasm.wasm_bindgen__convert__closures__invoke2_mut__h2a33b0877ef96682(
     arg0,
     arg1,
@@ -936,7 +949,7 @@ export class BitwardenClient {
    * @returns {GeneratorClient}
    */
   generator() {
-    const ret = wasm.bitwardenclient_generator(this.__wbg_ptr);
+    const ret = wasm.bitwardenclient_crypto(this.__wbg_ptr);
     return GeneratorClient.__wrap(ret);
   }
   /**
@@ -1485,23 +1498,38 @@ export class GeneratorClient {
     wasm.__wbg_generatorclient_free(ptr, 0);
   }
   /**
-   * Generates a password from a provided request
+   * Generates a random password.
    *
-   * # Arguments
-   * - `request` - Settings for the character sets and password length
+   * The character sets and password length can be customized using the `input` parameter.
    *
-   * # Returns
-   * - `Ok(String)` containing the generated password
-   * - `Err(PasswordError)` if password generation fails
-   * @param {PasswordGeneratorRequest} request
+   * # Examples
+   *
+   * ```
+   * use bitwarden_core::Client;
+   * use bitwarden_generators::{GeneratorClientsExt, PassphraseError, PasswordGeneratorRequest};
+   *
+   * async fn test() -> Result<(), PassphraseError> {
+   *     let input = PasswordGeneratorRequest {
+   *         lowercase: true,
+   *         uppercase: true,
+   *         numbers: true,
+   *         length: 20,
+   *         ..Default::default()
+   *     };
+   *     let password = Client::new(None).generator().password(input).unwrap();
+   *     println!("{}", password);
+   *     Ok(())
+   * }
+   * ```
+   * @param {PasswordGeneratorRequest} input
    * @returns {string}
    */
-  password(request) {
+  password(input) {
     let deferred2_0;
     let deferred2_1;
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.generatorclient_password(retptr, this.__wbg_ptr, addHeapObject(request));
+      wasm.generatorclient_password(retptr, this.__wbg_ptr, addHeapObject(input));
       var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
       var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
       var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -1522,23 +1550,38 @@ export class GeneratorClient {
     }
   }
   /**
-   * Generates a passphrase from a provided request
+   * Generates a random passphrase.
+   * A passphrase is a combination of random words separated by a character.
+   * An example of passphrase is `correct horse battery staple`.
    *
-   * # Arguments
-   * - `request` - Settings for the word count, word separators character sets
+   * The number of words and their case, the word separator, and the inclusion of
+   * a number in the passphrase can be customized using the `input` parameter.
    *
-   * # Returns
-   * - `Ok(String)` containing the generated passphrase
-   * - `Err(PassphraseError)` if passphrase generation fails
-   * @param {PassphraseGeneratorRequest} request
+   * # Examples
+   *
+   * ```
+   * use bitwarden_core::Client;
+   * use bitwarden_generators::{GeneratorClientsExt, PassphraseError, PassphraseGeneratorRequest};
+   *
+   * async fn test() -> Result<(), PassphraseError> {
+   *     let input = PassphraseGeneratorRequest {
+   *         num_words: 4,
+   *         ..Default::default()
+   *     };
+   *     let passphrase = Client::new(None).generator().passphrase(input).unwrap();
+   *     println!("{}", passphrase);
+   *     Ok(())
+   * }
+   * ```
+   * @param {PassphraseGeneratorRequest} input
    * @returns {string}
    */
-  passphrase(request) {
+  passphrase(input) {
     let deferred2_0;
     let deferred2_1;
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.generatorclient_passphrase(retptr, this.__wbg_ptr, addHeapObject(request));
+      wasm.generatorclient_passphrase(retptr, this.__wbg_ptr, addHeapObject(input));
       var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
       var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
       var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -2654,7 +2697,7 @@ export function __wbg_new_23a2665fac83c611(arg0, arg1) {
       const a = state0.a;
       state0.a = 0;
       try {
-        return __wbg_adapter_237(a, state0.b, arg0, arg1);
+        return __wbg_adapter_238(a, state0.b, arg0, arg1);
       } finally {
         state0.a = a;
       }
@@ -3021,13 +3064,13 @@ export function __wbindgen_cb_drop(arg0) {
   return ret;
 }
 
-export function __wbindgen_closure_wrapper2876(arg0, arg1, arg2) {
-  const ret = makeMutClosure(arg0, arg1, 664, __wbg_adapter_50);
+export function __wbindgen_closure_wrapper2889(arg0, arg1, arg2) {
+  const ret = makeMutClosure(arg0, arg1, 669, __wbg_adapter_50);
   return addHeapObject(ret);
 }
 
-export function __wbindgen_closure_wrapper3269(arg0, arg1, arg2) {
-  const ret = makeMutClosure(arg0, arg1, 786, __wbg_adapter_53);
+export function __wbindgen_closure_wrapper3282(arg0, arg1, arg2) {
+  const ret = makeMutClosure(arg0, arg1, 791, __wbg_adapter_53);
   return addHeapObject(ret);
 }
 

package/bitwarden_wasm_internal_bg.wasm.d.ts

@@ -31,6 +31,10 @@ export const exporterclient_export_cxf: (
 ) => void;
 export const exporterclient_import_cxf: (a: number, b: number, c: number, d: number) => void;
 export const isExportError: (a: number) => number;
+export const __wbg_generatorclient_free: (a: number, b: number) => void;
+export const generatorclient_password: (a: number, b: number, c: number) => void;
+export const generatorclient_passphrase: (a: number, b: number, c: number) => void;
+export const isUsernameError: (a: number) => number;
 export const isPasswordError: (a: number) => number;
 export const isPassphraseError: (a: number) => number;
 export const __wbg_outgoingmessage_free: (a: number, b: number) => void;
@@ -105,13 +109,10 @@ export const bitwardenclient_version: (a: number, b: number) => void;
 export const bitwardenclient_throw: (a: number, b: number, c: number, d: number) => void;
 export const bitwardenclient_http_get: (a: number, b: number, c: number) => number;
 export const bitwardenclient_crypto: (a: number) => number;
-export const bitwardenclient_generator: (a: number) => number;
 export const cryptoclient_initialize_user_crypto: (a: number, b: number) => number;
 export const cryptoclient_initialize_org_crypto: (a: number, b: number) => number;
 export const cryptoclient_make_key_pair: (a: number, b: number, c: number, d: number) => void;
 export const cryptoclient_verify_asymmetric_keys: (a: number, b: number, c: number) => void;
-export const generatorclient_password: (a: number, b: number, c: number) => void;
-export const generatorclient_passphrase: (a: number, b: number, c: number) => void;
 export const set_log_level: (a: number) => void;
 export const init_sdk: (a: number) => void;
 export const __wbg_purecrypto_free: (a: number, b: number) => void;
@@ -179,10 +180,10 @@ export const vaultclient_attachments: (a: number) => number;
 export const vaultclient_totp: (a: number) => number;
 export const isTestError: (a: number) => number;
 export const bitwardenclient_vault: (a: number) => number;
+export const bitwardenclient_generator: (a: number) => number;
 export const bitwardenclient_exporters: (a: number) => number;
 export const vaultclient_ciphers: (a: number) => number;
 export const vaultclient_folders: (a: number) => number;
-export const __wbg_generatorclient_free: (a: number, b: number) => void;
 export const __wbg_vaultclient_free: (a: number, b: number) => void;
 export const __wbg_totpclient_free: (a: number, b: number) => void;
 export const __wbg_foldersclient_free: (a: number, b: number) => void;