@chilkat/react-native 11.6.1 → 11.7.0

package/nitrogen/generated/shared/c++/HybridPdfSpec.cpp

@@ -36,6 +36,8 @@ namespace margelo::nitro::chilkat {
       prototype.registerHybridSetter("ownerPassword", &HybridPdfSpec::setOwnerPassword);
       prototype.registerHybridGetter("userPassword", &HybridPdfSpec::getUserPassword);
       prototype.registerHybridSetter("userPassword", &HybridPdfSpec::setUserPassword);
+      prototype.registerHybridGetter("preserveSignatures", &HybridPdfSpec::getPreserveSignatures);
+      prototype.registerHybridSetter("preserveSignatures", &HybridPdfSpec::setPreserveSignatures);
       prototype.registerHybridGetter("onPercentDone", &HybridPdfSpec::getOnPercentDone);
       prototype.registerHybridSetter("onPercentDone", &HybridPdfSpec::setOnPercentDone);
       prototype.registerHybridGetter("onProgressInfo", &HybridPdfSpec::getOnProgressInfo);
@@ -57,15 +59,32 @@ namespace margelo::nitro::chilkat {
       prototype.registerHybridMethod("getMetadata", &HybridPdfSpec::getMetadata);
       prototype.registerHybridMethod("addVerificationInfo", &HybridPdfSpec::addVerificationInfo);
       prototype.registerHybridMethod("addVerificationInfoAsync", &HybridPdfSpec::addVerificationInfoAsync);
+      prototype.registerHybridMethod("addVerificationInfo2", &HybridPdfSpec::addVerificationInfo2);
       prototype.registerHybridMethod("signPdfBd", &HybridPdfSpec::signPdfBd);
       prototype.registerHybridMethod("signPdfBdAsync", &HybridPdfSpec::signPdfBdAsync);
+      prototype.registerHybridMethod("signPdf2", &HybridPdfSpec::signPdf2);
       prototype.registerHybridMethod("getEmbeddedFileInfo", &HybridPdfSpec::getEmbeddedFileInfo);
       prototype.registerHybridMethod("getEmbeddedFileBd", &HybridPdfSpec::getEmbeddedFileBd);
       prototype.registerHybridMethod("addEmbeddedFiles", &HybridPdfSpec::addEmbeddedFiles);
       prototype.registerHybridMethod("addEmbeddedFilesBd", &HybridPdfSpec::addEmbeddedFilesBd);
       prototype.registerHybridMethod("updateMetadata", &HybridPdfSpec::updateMetadata);
+      prototype.registerHybridMethod("updateMetadata2", &HybridPdfSpec::updateMetadata2);
       prototype.registerHybridMethod("updateMetadataBd", &HybridPdfSpec::updateMetadataBd);
       prototype.registerHybridMethod("getLastJsonData", &HybridPdfSpec::getLastJsonData);
+      prototype.registerHybridMethod("optimize", &HybridPdfSpec::optimize);
+      prototype.registerHybridMethod("writeFile", &HybridPdfSpec::writeFile);
+      prototype.registerHybridMethod("writeBd", &HybridPdfSpec::writeBd);
+      prototype.registerHybridMethod("watermark", &HybridPdfSpec::watermark);
+      prototype.registerHybridMethod("protection", &HybridPdfSpec::protection);
+      prototype.registerHybridMethod("extractText", &HybridPdfSpec::extractText);
+      prototype.registerHybridMethod("extractTextSb", &HybridPdfSpec::extractTextSb);
+      prototype.registerHybridMethod("addEncryptCert", &HybridPdfSpec::addEncryptCert);
+      prototype.registerHybridMethod("clearEncryptCerts", &HybridPdfSpec::clearEncryptCerts);
+      prototype.registerHybridMethod("setDecryptCert", &HybridPdfSpec::setDecryptCert);
+      prototype.registerHybridMethod("preLoadCheck", &HybridPdfSpec::preLoadCheck);
+      prototype.registerHybridMethod("preLoadCheckBd", &HybridPdfSpec::preLoadCheckBd);
+      prototype.registerHybridMethod("textReplace", &HybridPdfSpec::textReplace);
+      prototype.registerHybridMethod("addEmbeddedFiles2", &HybridPdfSpec::addEmbeddedFiles2);
       prototype.registerHybridMethod("abort", &HybridPdfSpec::abort);
     });
   }

package/nitrogen/generated/shared/c++/HybridPdfSpec.hpp

@@ -87,6 +87,8 @@ namespace margelo::nitro::chilkat {
       virtual void setOwnerPassword(const std::string& ownerPassword) = 0;
       virtual std::string getUserPassword() = 0;
       virtual void setUserPassword(const std::string& userPassword) = 0;
+      virtual bool getPreserveSignatures() = 0;
+      virtual void setPreserveSignatures(bool preserveSignatures) = 0;
       virtual std::optional<std::function<void(double /* pctDone */)>> getOnPercentDone() = 0;
       virtual void setOnPercentDone(const std::optional<std::function<void(double /* pctDone */)>>& onPercentDone) = 0;
       virtual std::optional<std::function<void(const std::string& /* name */, const std::string& /* value */)>> getOnProgressInfo() = 0;
@@ -111,15 +113,32 @@ namespace margelo::nitro::chilkat {
       virtual void getMetadata(const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
       virtual void addVerificationInfo(const std::shared_ptr<HybridJsonObjectSpec>& jsonOptions, const std::string& outFilePath) = 0;
       virtual std::shared_ptr<Promise<void>> addVerificationInfoAsync(const std::shared_ptr<HybridJsonObjectSpec>& jsonOptions, const std::string& outFilePath) = 0;
+      virtual void addVerificationInfo2(const std::shared_ptr<HybridJsonObjectSpec>& jsonOptions) = 0;
       virtual void signPdfBd(const std::shared_ptr<HybridJsonObjectSpec>& jsonOptions, const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
       virtual std::shared_ptr<Promise<void>> signPdfBdAsync(const std::shared_ptr<HybridJsonObjectSpec>& jsonOptions, const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void signPdf2(const std::shared_ptr<HybridJsonObjectSpec>& jsonOptions) = 0;
       virtual void getEmbeddedFileInfo(double index, const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
       virtual void getEmbeddedFileBd(double index, const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
       virtual void addEmbeddedFiles(const std::shared_ptr<HybridJsonObjectSpec>& json, const std::string& outFilePath) = 0;
       virtual void addEmbeddedFilesBd(const std::shared_ptr<HybridJsonObjectSpec>& json, const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
       virtual void updateMetadata(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& outFilePath) = 0;
+      virtual void updateMetadata2(const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
       virtual void updateMetadataBd(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
       virtual void getLastJsonData(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void optimize(const std::string& op, const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) = 0;
+      virtual void writeFile(const std::string& path) = 0;
+      virtual void writeBd(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void watermark(const std::string& op, const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) = 0;
+      virtual void protection(const std::string& op, const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) = 0;
+      virtual void extractText(const std::string& op, const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) = 0;
+      virtual void extractTextSb(const std::string& op, const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridStringBuilderSpec>& sbOut, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) = 0;
+      virtual void addEncryptCert(const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void clearEncryptCerts() = 0;
+      virtual void setDecryptCert(const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void preLoadCheck(const std::string& path, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) = 0;
+      virtual void preLoadCheckBd(const std::shared_ptr<HybridBinDataSpec>& bd, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) = 0;
+      virtual void textReplace(const std::string& op, const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) = 0;
+      virtual void addEmbeddedFiles2(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
       virtual void abort() = 0;
 
     protected:

package/nitrogen/generated/shared/c++/HybridSocketSpec.cpp

@@ -141,6 +141,13 @@ namespace margelo::nitro::chilkat {
       prototype.registerHybridGetter("sniHostname", &HybridSocketSpec::getSniHostname);
       prototype.registerHybridSetter("sniHostname", &HybridSocketSpec::setSniHostname);
       prototype.registerHybridGetter("numBytesAvailable", &HybridSocketSpec::getNumBytesAvailable);
+      prototype.registerHybridGetter("alpnProtocols", &HybridSocketSpec::getAlpnProtocols);
+      prototype.registerHybridSetter("alpnProtocols", &HybridSocketSpec::setAlpnProtocols);
+      prototype.registerHybridGetter("requireSniMatch", &HybridSocketSpec::getRequireSniMatch);
+      prototype.registerHybridSetter("requireSniMatch", &HybridSocketSpec::setRequireSniMatch);
+      prototype.registerHybridGetter("tlsTicketLifetimeSeconds", &HybridSocketSpec::getTlsTicketLifetimeSeconds);
+      prototype.registerHybridSetter("tlsTicketLifetimeSeconds", &HybridSocketSpec::setTlsTicketLifetimeSeconds);
+      prototype.registerHybridGetter("tlsSessionResumed", &HybridSocketSpec::getTlsSessionResumed);
       prototype.registerHybridGetter("onPercentDone", &HybridSocketSpec::getOnPercentDone);
       prototype.registerHybridSetter("onPercentDone", &HybridSocketSpec::setOnPercentDone);
       prototype.registerHybridGetter("onProgressInfo", &HybridSocketSpec::getOnProgressInfo);
@@ -255,6 +262,9 @@ namespace margelo::nitro::chilkat {
       prototype.registerHybridMethod("getRcvdClientCert", &HybridSocketSpec::getRcvdClientCert);
       prototype.registerHybridMethod("sshNewChannel", &HybridSocketSpec::sshNewChannel);
       prototype.registerHybridMethod("sshNewChannelAsync", &HybridSocketSpec::sshNewChannelAsync);
+      prototype.registerHybridMethod("addSslServerCert", &HybridSocketSpec::addSslServerCert);
+      prototype.registerHybridMethod("clearSslServerCerts", &HybridSocketSpec::clearSslServerCerts);
+      prototype.registerHybridMethod("setTlsTicketKey", &HybridSocketSpec::setTlsTicketKey);
       prototype.registerHybridMethod("abort", &HybridSocketSpec::abort);
     });
   }

package/nitrogen/generated/shared/c++/HybridSocketSpec.hpp

@@ -196,6 +196,13 @@ namespace margelo::nitro::chilkat {
       virtual std::string getSniHostname() = 0;
       virtual void setSniHostname(const std::string& sniHostname) = 0;
       virtual double getNumBytesAvailable() = 0;
+      virtual std::string getAlpnProtocols() = 0;
+      virtual void setAlpnProtocols(const std::string& alpnProtocols) = 0;
+      virtual bool getRequireSniMatch() = 0;
+      virtual void setRequireSniMatch(bool requireSniMatch) = 0;
+      virtual double getTlsTicketLifetimeSeconds() = 0;
+      virtual void setTlsTicketLifetimeSeconds(double tlsTicketLifetimeSeconds) = 0;
+      virtual bool getTlsSessionResumed() = 0;
       virtual std::optional<std::function<void(double /* pctDone */)>> getOnPercentDone() = 0;
       virtual void setOnPercentDone(const std::optional<std::function<void(double /* pctDone */)>>& onPercentDone) = 0;
       virtual std::optional<std::function<void(const std::string& /* name */, const std::string& /* value */)>> getOnProgressInfo() = 0;
@@ -313,6 +320,9 @@ namespace margelo::nitro::chilkat {
       virtual void getRcvdClientCert(double index, const std::shared_ptr<HybridCertSpec>& cert) = 0;
       virtual void sshNewChannel(const std::string& hostname, double port, bool ssl, double maxWaitMs, const std::shared_ptr<HybridSocketSpec>& channel) = 0;
       virtual std::shared_ptr<Promise<void>> sshNewChannelAsync(const std::string& hostname, double port, bool ssl, double maxWaitMs, const std::shared_ptr<HybridSocketSpec>& channel) = 0;
+      virtual void addSslServerCert(const std::shared_ptr<HybridCertSpec>& cert, const std::string& hostname) = 0;
+      virtual void clearSslServerCerts() = 0;
+      virtual void setTlsTicketKey(const std::shared_ptr<HybridBinDataSpec>& binKey) = 0;
       virtual void abort() = 0;
 
     protected:

package/nitrogen/generated/shared/c++/HybridSpiderSpec.hpp

@@ -123,8 +123,8 @@ namespace margelo::nitro::chilkat {
       virtual void clearFailedUrls() = 0;
       virtual void clearOutboundLinks() = 0;
       virtual void clearSpideredUrls() = 0;
-      virtual void crawlNext() = 0;
-      virtual std::shared_ptr<Promise<void>> crawlNextAsync() = 0;
+      virtual bool crawlNext() = 0;
+      virtual std::shared_ptr<Promise<bool>> crawlNextAsync() = 0;
       virtual std::string fetchRobotsText() = 0;
       virtual std::shared_ptr<Promise<std::string>> fetchRobotsTextAsync() = 0;
       virtual std::string getAvoidPattern(double index) = 0;
@@ -135,8 +135,8 @@ namespace margelo::nitro::chilkat {
       virtual std::string getUnspideredUrl(double index) = 0;
       virtual std::string getUrlDomain(const std::string& url) = 0;
       virtual void initialize(const std::string& domain) = 0;
-      virtual void recrawlLast() = 0;
-      virtual std::shared_ptr<Promise<void>> recrawlLastAsync() = 0;
+      virtual bool recrawlLast() = 0;
+      virtual std::shared_ptr<Promise<bool>> recrawlLastAsync() = 0;
       virtual void skipUnspidered(double index) = 0;
       virtual void sleepMs(double numMilliseconds) = 0;
       virtual void abort() = 0;

package/nitrogen/generated/shared/c++/HybridStringBuilderSpec.cpp

@@ -98,6 +98,7 @@ namespace margelo::nitro::chilkat {
       prototype.registerHybridMethod("markdownToHtml", &HybridStringBuilderSpec::markdownToHtml);
       prototype.registerHybridMethod("getRangeSb", &HybridStringBuilderSpec::getRangeSb);
       prototype.registerHybridMethod("appendLn", &HybridStringBuilderSpec::appendLn);
+      prototype.registerHybridMethod("htmlToMarkdown", &HybridStringBuilderSpec::htmlToMarkdown);
     });
   }
 

package/nitrogen/generated/shared/c++/HybridStringBuilderSpec.hpp

@@ -143,6 +143,7 @@ namespace margelo::nitro::chilkat {
       virtual void markdownToHtml(const std::shared_ptr<HybridJsonObjectSpec>& options, const std::shared_ptr<HybridStringBuilderSpec>& sbHtml) = 0;
       virtual void getRangeSb(double startIndex, double numChars, bool removeFlag, const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
       virtual void appendLn(const std::string& str) = 0;
+      virtual void htmlToMarkdown() = 0;
 
     protected:
       // Hybrid Setup

package/nitrogen/generated/shared/c++/HybridZipEntrySpec.hpp

@@ -121,8 +121,8 @@ namespace margelo::nitro::chilkat {
       virtual std::shared_ptr<Promise<void>> unzipToBdAsync(const std::shared_ptr<HybridBinDataSpec>& binData) = 0;
       virtual void unzipToSb(double lineEndingBehavior, const std::string& srcCharset, const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
       virtual std::shared_ptr<Promise<void>> unzipToSbAsync(double lineEndingBehavior, const std::string& srcCharset, const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
-      virtual void getNextMatch(const std::string& pattern) = 0;
-      virtual void getNext() = 0;
+      virtual bool getNextMatch(const std::string& pattern) = 0;
+      virtual bool getNext() = 0;
       virtual void abort() = 0;
 
     protected:

package/package.json

@@ -1,7 +1,7 @@
 {
   "_generated": "Generated by ReactNativeNs.RnGenerator -- do not edit (the version comes from generateForMicroVersion.txt)",
   "name": "@chilkat/react-native",
-  "version": "11.6.1",
+  "version": "11.7.0",
   "description": "The Chilkat class library for React Native (a Nitro Module): HTTP, REST, email (SMTP/POP3/IMAP), FTP, SFTP, SSH, zip, encryption, digital signatures, certificates, XML, JSON and more.",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/index.ts

@@ -34,6 +34,7 @@ import type { EdDSA as EdDSASpec } from './specs/EdDSA.nitro'
 import type { Email as EmailSpec } from './specs/Email.nitro'
 import type { EmailBundle as EmailBundleSpec } from './specs/EmailBundle.nitro'
 import type { FileAccess as FileAccessSpec } from './specs/FileAccess.nitro'
+import type { Formats as FormatsSpec } from './specs/Formats.nitro'
 import type { Ftp2 as Ftp2Spec } from './specs/Ftp2.nitro'
 import type { Global as GlobalSpec } from './specs/Global.nitro'
 import type { Gzip as GzipSpec } from './specs/Gzip.nitro'
@@ -164,6 +165,8 @@ export type EmailBundle = EmailBundleSpec
 export const EmailBundle = getHybridObjectConstructor<EmailBundleSpec>('EmailBundle')
 export type FileAccess = FileAccessSpec
 export const FileAccess = getHybridObjectConstructor<FileAccessSpec>('FileAccess')
+export type Formats = FormatsSpec
+export const Formats = getHybridObjectConstructor<FormatsSpec>('Formats')
 export type Ftp2 = Ftp2Spec
 export const Ftp2 = getHybridObjectConstructor<Ftp2Spec>('Ftp2')
 export type Global = GlobalSpec

package/src/specs/Ai.nitro.ts

@@ -969,11 +969,8 @@ export interface Ai extends HybridObject<{ ios: 'c++', android: 'c++' }> {
    * This method returns the function calls in `json` if the output contains any. Returns `true` if
    * one or more function calls were returned, otherwise returns `false`. This only applies to
    * manual function tool calling, not automatic JS tool calls.
-   *
-   * @throws Error if the call fails (the message names the reason); the full log is in
-   * {@link Ai.lastErrorText}.
    */
-  getFunctionCalls(json: JsonObject): void
+  getFunctionCalls(json: JsonObject): boolean
 
   /**
    * Returns the web search sources the model used in the most recent {@link Ai.ask}, if web search
@@ -1008,11 +1005,8 @@ export interface Ai extends HybridObject<{ ios: 'c++', android: 'c++' }> {
    * **Streaming:** In streaming mode, a standardized `web_search_call` event is delivered through
    * {@link Ai.nextAiEvent} when the provider begins a search, and the normalized results are
    * available from this method after the `null_terminator` event completes the response.
-   *
-   * @throws Error if the call fails (the message names the reason); the full log is in
-   * {@link Ai.lastErrorText}.
    */
-  getSearchResults(json: JsonObject): void
+  getSearchResults(json: JsonObject): boolean
 
   /**
    * Registers the tools provided by the connected MCP (Model Context Protocol) server `cMcp` so the
@@ -1092,11 +1086,8 @@ export interface Ai extends HybridObject<{ ios: 'c++', android: 'c++' }> {
    * the output (in which case {@link Ai.lastResponseRefused} is `true` and {@link Ai.refusalText}
    * contains the explanation), if there is no output, or if the output is not valid JSON. The raw
    * JSON text is also available from {@link Ai.getOutputText}.
-   *
-   * @throws Error if the call fails (the message names the reason); the full log is in
-   * {@link Ai.lastErrorText}.
    */
-  getOutputJson(json: JsonObject): void
+  getOutputJson(json: JsonObject): boolean
 
   /**
    * Provide a function call result to the model. This only applies to `manual function tool

package/src/specs/Cert.nitro.ts

@@ -319,12 +319,22 @@ export interface Cert extends HybridObject<{ ios: 'c++', android: 'c++' }> {
   readonly privateKeyExportable: boolean
 
   /**
-   * `true` if the certificate or any certificate in the chain of authority has been revoked. This
-   * information is not available when running on Windows 95/98 computers.
-   * **Note: **If this property is `false`, it could mean that it was not able to check the
-   * revocation status. Because of this uncertainty, a CheckRevoked method has been added. It
-   * returns an integer indicating one of three possible states: 1 (revoked), 0 (not revoked), -1
-   * (unable to check revocation status).
+   * **Deprecated:** This property does not check the revocation status of the certificate, and
+   * always returns `false`. Do not use it to decide whether a certificate is revoked.
+   *
+   * To check whether a certificate has been revoked, call {@link Cert.checkRevoked} (Windows only),
+   * which returns 1 (revoked), 0 (not revoked), or -1 (unable to check). Applications on any
+   * operating system can also send an OCSP request to the certificate's {@link Cert.ocspUrl}, if
+   * the certificate has one.
+   *
+   * (A property cannot do this work because checking revocation can require contacting a CRL
+   * distribution point or an OCSP responder over the network, which can take a long time. In some
+   * programming languages, properties are evaluated at design time in the IDE.)
+   *
+   * **Note:** Chilkat does not check certificate revocation status during the TLS handshake.
+   * Settings such as `RequireSslCertVerify` verify signatures, expiration, and the chain to a
+   * trusted root, but not revocation. To reject a revoked server certificate, the application must
+   * check it after connecting.
    *
    * This property is read-only.
    */
@@ -570,7 +580,15 @@ export interface Cert extends HybridObject<{ ios: 'c++', android: 'c++' }> {
    * accessing any network based resources for revocation checking. In other words, just check the
    * cached revocation information on the local computer.
    *
+   * `CertVerifyRevocation` can use the certificate's CRL distribution points as well as OCSP. If it
+   * returns -1, see the `LastErrorText`. One cause is that the issuing intermediate CA certificate
+   * is not present in the Windows certificate store.
+   *
    * Non-Windows (and Windows) applications can send an OCSP request as shown in the example below.
+   * Note that some CAs publish revocation status only through CRLs, not OCSP. For example, Let's
+   * Encrypt removed the OCSP URL from its certificates in May 2025 and shut down its OCSP
+   * responders in August 2025, so an OCSP request is not possible for current Let's Encrypt
+   * certificates.
    */
   checkRevoked(): number
 

package/src/specs/CodeSign.nitro.ts

@@ -4,18 +4,22 @@ import type { Cert } from './Cert.nitro'
 import type { JsonObject } from './JsonObject.nitro'
 
 /**
- * Sign, verify, inspect, and remove Authenticode signatures on Windows executables.
+ * Sign, verify, inspect, and remove Authenticode signatures on Windows executables, installers, and
+ * scripts.
  *
  * `CodeSign` works directly with Authenticode signatures on
- * Windows executable files such as `.exe` and `.dll`.
+ * Windows executable files such as `.exe` and `.dll`, and,
+ * starting in v11.7.0, on Windows Installer packages (`.msi`),
+ * PowerShell files (`.ps1`, `.psm1`, `.psd1`), and
+ * VBScript files (`.vbs`).
  * It provides functionality for applying a code-signing signature, validating
  * whether a signed executable can be trusted, extracting signature information,
  * retrieving the signer certificate, and removing an existing signature.
  *
- * **Sign EXE and DLL files**
+ * **Sign executables, installers, and scripts**
  *
- * Apply Authenticode signatures to Windows executable files using a
- * certificate and associated private key.
+ * Apply Authenticode signatures to EXE, DLL, MSI, PowerShell, and VBScript
+ * files using a certificate and associated private key.
  *
  * **Validate trust**
  *
@@ -34,7 +38,7 @@ import type { JsonObject } from './JsonObject.nitro'
  *
  * **Remove signatures**
  *
- * Remove an existing Authenticode signature from a Windows executable when
+ * Remove an existing Authenticode signature from a signed file when
  * an unsigned output file is required.
  *
  * **Diagnostics**
@@ -44,7 +48,7 @@ import type { JsonObject } from './JsonObject.nitro'
  *
  * **Common pattern:**
  * Load or provide a code-signing certificate that has access to its private
- * key, sign the target `.exe` or `.dll`, optionally add
+ * key, sign the target file, optionally add
  * timestamping if supported by the signing workflow, then verify the resulting
  * signature and inspect diagnostics if validation does not succeed.
  *
@@ -145,10 +149,17 @@ export interface CodeSign extends HybridObject<{ ios: 'c++', android: 'c++' }> {
    * | `codesign-allow-expired-cert` | | Prevents Authenticode verification from failing solely
    * because the signing certificate is expired. |
    *
-   * **Use only for an explicit trust policy:** This option relaxes the certificate-expiration
-   * check; it does not disable file-integrity, signature, chain, or other validation checks. It is
-   * not a substitute for timestamping. A signature carrying a valid trusted timestamp should
-   * ordinarily remain verifiable after the signing certificate expires without this option.
+   * | `codesign-allow-cert-padding` | | Starting in v11.7.0. Prevents verification of an EXE or DLL
+   * from failing solely because the PE certificate table fails the strict check (extra data or
+   * entries outside the verified signature). The failed check is still reported in `LastErrorText`.
+   * Use only for files known to carry such data, such as some installers that store configuration
+   * data in the certificate table. |
+   *
+   * **Use only for an explicit trust policy:** Each option relaxes only the one check it names;
+   * neither disables the file-integrity, signature, chain, or other validation checks.
+   * `codesign-allow-expired-cert` is not a substitute for timestamping. A signature carrying a
+   * valid trusted timestamp should ordinarily remain verifiable after the signing certificate
+   * expires without this option.
    */
   uncommonOptions: string
 
@@ -170,9 +181,12 @@ export interface CodeSign extends HybridObject<{ ios: 'c++', android: 'c++' }> {
   // ---- Methods ----
 
   /**
-   * Verifies the embedded Microsoft Authenticode signature of the Windows executable or DLL
-   * specified by `path`. Structured information about the signature, signer, certificate chain,
-   * digest algorithms, timestamp, and validation result is written to `sigInfo`.
+   * Verifies the embedded Microsoft Authenticode signature of the file specified by `path`: a
+   * Windows executable or DLL, or, starting in v11.7.0, a Windows Installer package (`.msi`),
+   * PowerShell file (`.ps1`, `.psm1`, `.psd1`), or VBScript file (`.vbs`). See {@link
+   * CodeSign.addSignature} for the supported file types. Other file types cause the method to
+   * return `false`. Structured information about the signature, signer, certificate chain, digest
+   * algorithms, timestamp, and validation result is written to `sigInfo`.
    *
    * Returns `true` when the signature satisfies the applicable Authenticode validation checks under
    * the current Windows trust configuration. This includes confirming that the signed portions of
@@ -180,6 +194,17 @@ export interface CodeSign extends HybridObject<{ ios: 'c++', android: 'c++' }> {
    * applicable. An unsigned file or a signature that does not validate causes the method to return
    * `false`. Inspect `sigInfo` and `LastErrorText` for details.
    *
+   * Starting in v11.7.0, verification of an EXE or DLL also includes a strict check of the PE
+   * certificate table: it must hold exactly one signature entry, containing exactly the signature
+   * that was verified, with no extra data. Data in the certificate table is not covered by the
+   * Authenticode signature (see CVE-2013-3900), so anything hidden there would be unsigned. A file
+   * that fails this check causes the method to return `false` unless the
+   * `codesign-allow-cert-padding` option is set in {@link CodeSign.uncommonOptions}.
+   *
+   * MSI packages signed with an ECDSA certificate: this method can return `true` for such a
+   * package, while Windows itself reports the signature as invalid. This is a limitation of signed
+   * MSI files on Windows, not a Chilkat defect; see the note in {@link CodeSign.addSignature}.
+   *
    * **What successful verification means:** Authenticode verifies publisher identity, file
    * integrity, and certificate trust according to the validation policy. It does not prove that the
    * software is bug-free, safe to execute, or free of malicious behavior. Trust results can also
@@ -192,9 +217,14 @@ export interface CodeSign extends HybridObject<{ ios: 'c++', android: 'c++' }> {
   verifySignature(path: string, sigInfo: JsonObject): void
 
   /**
-   * Removes the embedded Authenticode signature from the Windows executable or DLL specified by
-   * `path`. The file is modified in place. Returns `true` if the signature is successfully removed;
-   * otherwise returns `false`.
+   * Removes the embedded Authenticode signature from the file specified by `path`: a Windows
+   * executable or DLL, or, starting in v11.7.0, a Windows Installer package (`.msi`), PowerShell
+   * file (`.ps1`, `.psm1`, `.psd1`), or VBScript file (`.vbs`). The file is modified in place.
+   * Returns `true` if the signature is successfully removed; otherwise returns `false`.
+   *
+   * For PowerShell and VBScript files, the signature comment block is removed from the end of the
+   * file. For MSI packages, the digital signature stream and the extended signature stream
+   * (`MsiDigitalSignatureEx`) are removed.
    *
    * **Effect of removal:** The resulting file is no longer Authenticode-signed and no longer
    * carries the removed publisher and timestamp information. This operation does not delete the
@@ -207,9 +237,44 @@ export interface CodeSign extends HybridObject<{ ios: 'c++', android: 'c++' }> {
   removeSignature(path: string): void
 
   /**
-   * Adds a Microsoft Authenticode signature to the Windows executable or DLL specified by `path`.
-   * The file is modified in place. `cert` supplies the code-signing certificate and must provide
-   * access to its associated private key. `options` supplies the signing configuration as JSON.
+   * Adds a Microsoft Authenticode signature to the file specified by `path`. The file is modified
+   * in place. `cert` supplies the code-signing certificate and must provide access to its
+   * associated private key. `options` supplies the signing configuration as JSON.
+   *
+   * Starting in v11.7.0, Windows Installer packages, PowerShell files, and VBScript files can be
+   * signed in addition to Windows executables and DLLs. The supported file types are:
+   *
+   * File typeExtensionsWhere the signature is stored
+   *
+   * | Windows PE images | | `.exe`, `.dll`, and other PE files such as `.sys` and `.ocx` | | The PE
+   * certificate table. PE files are identified from the file content, not the extension. |
+   *
+   * | Windows Installer packages (starting in v11.7.0) | | `.msi` | | The package's digital
+   * signature stream. |
+   *
+   * | PowerShell scripts, modules, and data files (starting in v11.7.0) | | `.ps1`, `.psm1`,
+   * `.psd1` | | A comment block appended to the file (`# SIG # Begin signature block` ... `# SIG #
+   * End signature block`). The file's text encoding (UTF-8, UTF-8 with BOM, or UTF-16) is kept. |
+   *
+   * | VBScript files (starting in v11.7.0) | | `.vbs` | | A comment block appended to the file (`''
+   * SIG '' Begin signature block` ... `'' SIG '' End signature block`). |
+   *
+   * Any other file type (for example `.js`, `.cab`, or `.cat`) causes the method to return `false`,
+   * with `LastErrorText` explaining that the file type is not supported, and the file is not
+   * modified. The file must already exist; this method does not create it.
+   *
+   * Starting in v11.7.0, if the file is already Authenticode-signed, the existing signature is
+   * removed and replaced by the new one. (Before v11.7.0, signing an already-signed EXE or DLL
+   * added a second signature entry instead of replacing the first.)
+   *
+   * **MSI packages and ECDSA certificates:** Windows does not accept an Authenticode signature on
+   * an MSI package when the signing certificate uses an ECDSA key. Windows signature checks, such
+   * as `signtool verify`, `Get-AuthenticodeSignature`, and the file's Digital Signatures
+   * properties, report the signature as invalid (`TRUST_E_BAD_DIGEST`, 0x80096010). This is a
+   * limitation of signed MSI files on Windows, not a Chilkat defect: an MSI signed by Microsoft's
+   * `signtool` with the same ECDSA certificate is rejected in the same way, and its signed content
+   * is identical to the signature Chilkat produces. Use an RSA code-signing certificate to sign MSI
+   * packages. ECDSA certificates work for EXE, DLL, PowerShell, and VBScript files.
    *
    * Common `options` options include:
    *
@@ -271,6 +336,9 @@ export interface CodeSign extends HybridObject<{ ios: 'c++', android: 'c++' }> {
    * The returned object contains the public certificate only; it does not provide the signer's
    * private key. Call this method after `VerifySignature` and use the same `CodeSign` instance.
    *
+   * Starting in v11.7.0, the signer certificate is available only after a call to `VerifySignature`
+   * that returned `true`. After a failed verification, this method returns `false`.
+   *
    * **Certificate retrieval versus trust:** Successfully retrieving the signer certificate does not
    * independently validate the signature or establish trust. Use the result of `VerifySignature`
    * and the returned signature information when making a trust decision.

package/src/specs/Compression.nitro.ts

@@ -139,10 +139,18 @@ export interface Compression extends HybridObject<{ ios: 'c++', android: 'c++' }
 
   /**
    * Specifies the compression algorithm to use. Supported values are
-   * `deflate`, `zlib`, `bzip2`, and `lzw`.
+   * `deflate`, `zlib`, `gzip`, `bzip2`, and `lzw`.
    *
    * The `zlib` option is the deflate algorithm with a zlib header.
    *
+   * The `gzip` option (starting in v11.7.0) is the deflate algorithm in the gzip format (RFC 1952):
+   * a gzip
+   * header, the deflate data, and a trailer with the CRC-32 and size of the uncompressed data. When
+   * decompressing in one
+   * call, the CRC-32 and size are checked. Before v11.7.0, `gzip` was not recognized and was
+   * treated as
+   * `deflate`.
+   *
    * **Note:** `ppmd` is deprecated and should not be used.
    * It was only available on 32-bit systems and specifically used the J variant.
    * New applications should use one of the supported algorithms listed above.

package/src/specs/Dns.nitro.ts

@@ -198,22 +198,16 @@ export interface Dns extends HybridObject<{ ios: 'c++', android: 'c++' }> {
    *
    * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
    * {@link Dns.queryAsync}.
-   *
-   * @throws Error if the call fails (the message names the reason); the full log is in
-   * {@link Dns.lastErrorText}.
    */
-  query(recordType: string, domain: string, answer: JsonObject): void
+  query(recordType: string, domain: string, answer: JsonObject): boolean
 
   /**
    * Asynchronous form of {@link Dns.query}: the same call on a native worker thread,
    * settling on the JavaScript thread. While it is pending, other calls on this object throw,
    * except {@link Dns.abort} (which cancels it) and the {@link Dns.onPercentDone} /
    * {@link Dns.onProgressInfo} callbacks, which report progress while it runs.
-   *
-   * The promise rejects with an Error if the call fails; the full log is in
-   * {@link Dns.lastErrorText}.
    */
-  queryAsync(recordType: string, domain: string, answer: JsonObject): Promise<void>
+  queryAsync(recordType: string, domain: string, answer: JsonObject): Promise<boolean>
 
   /**
    * Adds a new nameserver to the collection of nameservers used by Chilkat for DNS queries and

package/src/specs/FileAccess.nitro.ts

@@ -403,7 +403,12 @@ export interface FileAccess extends HybridObject<{ ios: 'c++', android: 'c++' }>
   fileSeek(offset: number, origin: number): void
 
   /**
-   * Returns the file size in bytes as a signed 32-bit integer, or `-1` on failure.
+   * Returns the file size in bytes as a signed 32-bit integer.
+   *
+   * **Failure returns 0:** If the size cannot be obtained (for example, the file does not exist or
+   * cannot be accessed), the return value is `0`, which is the same as for an empty file. To detect
+   * failure, use `FileSizeStr`, which fails instead of returning a size, or check first with
+   * `FileExists3`.
    *
    * **Large files:** A signed 32-bit result cannot represent files larger than approximately 2 GB.
    * Use `FileSize64` or `FileSizeStr` for large files.
@@ -810,7 +815,12 @@ export interface FileAccess extends HybridObject<{ ios: 'c++', android: 'c++' }>
   fileWrite2(byteData: ArrayBuffer): void
 
   /**
-   * Returns the size of `filePath` in bytes as a signed 64-bit integer, or `-1` on failure.
+   * Returns the size of `filePath` in bytes as a signed 64-bit integer.
+   *
+   * **Failure returns 0:** If the size cannot be obtained (for example, the file does not exist or
+   * cannot be accessed), the return value is `0`, which is the same as for an empty file. To detect
+   * failure, use `FileSizeStr`, which fails instead of returning a size, or check first with
+   * `FileExists3`.
    *
    * 64-bit integers are passed as JavaScript numbers (exact up to 2^53).
    */