@linqapp/sdk 0.28.0 → 0.28.2

package/resources/webhooks.d.ts

@@ -175,7 +175,7 @@ export declare namespace MessageEventV2 {
          */
         type: 'imessage_app';
         /**
-         * The URL delivered to the iMessage app on tap.
+         * The URL the recipient's app opens when the user taps the card.
          */
         url: string;
         /**
@@ -321,7 +321,7 @@ export declare namespace MessagePayload {
          */
         type: 'imessage_app';
         /**
-         * The URL delivered to the iMessage app on tap.
+         * The URL the recipient's app opens when the user taps the card.
          */
         url: string;
         /**
@@ -1777,13 +1777,13 @@ export declare namespace PhoneNumberStatusUpdatedWebhookEvent {
          */
         changed_at: string;
         /**
-         * @deprecated Current reputation of this phone line as assessed by risk-service.
+         * @deprecated Current reputation of this phone line.
          *
-         * - `HEALTHY` — No elevated risk detected.
-         * - `AT_RISK` — Elevated risk indicators present; consider reducing send volume or
-         *   reviewing messaging patterns.
-         * - `CRITICAL` — High risk; further sending may result in line flagging or
-         *   restriction.
+         * - `HEALTHY` — The line is in good standing. Send normally.
+         * - `AT_RISK` — The line's overall engagement is trending down. Slow the line's
+         *   send pace and review your messaging patterns.
+         * - `CRITICAL` — Strong signals that messages from this line aren't landing well.
+         *   Pause outbound on the line until it recovers.
          *
          * Defaults to `HEALTHY` for lines that have not yet been scored.
          */
@@ -1801,13 +1801,13 @@ export declare namespace PhoneNumberStatusUpdatedWebhookEvent {
          */
         phone_number: string;
         /**
-         * @deprecated Current reputation of this phone line as assessed by risk-service.
+         * @deprecated Current reputation of this phone line.
          *
-         * - `HEALTHY` — No elevated risk detected.
-         * - `AT_RISK` — Elevated risk indicators present; consider reducing send volume or
-         *   reviewing messaging patterns.
-         * - `CRITICAL` — High risk; further sending may result in line flagging or
-         *   restriction.
+         * - `HEALTHY` — The line is in good standing. Send normally.
+         * - `AT_RISK` — The line's overall engagement is trending down. Slow the line's
+         *   send pace and review your messaging patterns.
+         * - `CRITICAL` — Strong signals that messages from this line aren't landing well.
+         *   Pause outbound on the line until it recovers.
          *
          * Defaults to `HEALTHY` for lines that have not yet been scored.
          */

package/src/client.ts

@@ -32,6 +32,11 @@ import {
   Attachments,
   SupportedContentType,
 } from './resources/attachments';
+import {
+  AvailableNumber,
+  AvailableNumberRetrieveParams,
+  AvailableNumberRetrieveResponse,
+} from './resources/available-number';
 import {
   Capability,
   CapabilityCheckIMessageParams,
@@ -51,14 +56,23 @@ import {
   Message,
   MessageAddReactionParams,
   MessageAddReactionResponse,
+  MessageCreateParams,
+  MessageCreateResponse,
   MessageEffect,
   MessageListMessagesThreadParams,
+  MessageUpdateAppCardParams,
+  MessageUpdateAppCardResponse,
   MessageUpdateParams,
   Messages,
   MessagesListMessagesPagination,
   ReplyTo,
 } from './resources/messages';
-import { PhoneNumberListResponse, PhoneNumbers } from './resources/phone-numbers';
+import {
+  PhoneNumberListResponse,
+  PhoneNumberUpdateParams,
+  PhoneNumberUpdateResponse,
+  PhoneNumbers,
+} from './resources/phone-numbers';
 import { PhonenumberListResponse, Phonenumbers } from './resources/phonenumbers';
 import { WebhookEventListResponse, WebhookEventType, WebhookEvents } from './resources/webhook-events';
 import {
@@ -141,7 +155,7 @@ export interface ClientOptions {
    * Standard Webhooks signature on incoming webhook requests.
    *
    * Format: a base64-encoded key, optionally with a `whsec_` prefix
-   * (e.g. `whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw7Jxx2Oll+OE=`).
+   * (e.g. `whsec_<your-webhook-signing-secret>`).
    *
    */
   webhookSecret?: string | null | undefined;
@@ -338,9 +352,6 @@ export class LinqAPIV3 {
     return buildHeaders([{ Authorization: `Bearer ${this.apiKey}` }]);
   }
 
-  /**
-   * Basic re-implementation of `qs.stringify` for primitive types.
-   */
   protected stringifyQuery(query: object | Record<string, unknown>): string {
     return stringifyQuery(query);
   }
@@ -805,11 +816,19 @@ export class LinqAPIV3 {
     return () => controller.abort();
   }
 
-  private buildBody({ options: { body, headers: rawHeaders } }: { options: FinalRequestOptions }): {
+  private buildBody({ options }: { options: FinalRequestOptions }): {
     bodyHeaders: HeadersLike;
     body: BodyInit | undefined;
   } {
+    const { body, headers: rawHeaders } = options;
     if (!body) {
+      // A resource method always passes a `body` key when its operation defines a
+      // request body, even if the caller omitted an optional body param. Keep the
+      // content-type for those, and only elide it for operations with no body at
+      // all (e.g. GET/DELETE).
+      if (body == null && 'body' in options) {
+        return this.#encoder({ body, headers: buildHeaders([rawHeaders]) });
+      }
       return { bodyHeaders: undefined, body: undefined };
     }
     const headers = buildHeaders([rawHeaders]);
@@ -890,6 +909,46 @@ export class LinqAPIV3 {
    * - A `link` part cannot be combined with other parts in the same message.
    * - Maximum URL length: 2,048 characters.
    *
+   * ## Ephemeral Messages (Privacy Tier)
+   *
+   * For regulated or sensitive conversations, opt in to the **ephemeral messages** tier by contacting your Linq support contact. When enabled, every message on the covered phone numbers is automatically given a fixed **24-hour retention window** — after that window the platform permanently deletes the message from Linq storage. There is no per-message flag; ephemerality is applied automatically based on your configuration.
+   *
+   * You can request it at two scopes:
+   *
+   * | Scope | Effect |
+   * |---|---|
+   * | **Partner-wide** | Every outbound and inbound message on every phone number under your account is retained for 24 hours, then deleted. |
+   * | **Per phone number** | Only the specified phone numbers have their messages auto-deleted. The rest follow the standard message-retention policy. |
+   *
+   * **Behavioral differences vs the standard default:**
+   *
+   * | Aspect | Standard | Ephemeral |
+   * |---|---|---|
+   * | Retention | Retained per the standard message-retention policy | **Hard backstop: 24 hours** from when the message is created |
+   * | After expiry | Message stays retrievable | Message is permanently deleted — `GET /v3/messages/{messageId}` returns `404` and it no longer appears in `GET /v3/chats/{chatId}/messages` |
+   * | Content on expiry | N/A | Text, formatting, and attachment references are scrubbed; the message is gone, not blanked out |
+   * | Cross-partner isolation | Enforced | Enforced |
+   *
+   * **How the 24-hour window works:**
+   *
+   * - The window is fixed at **24 hours from message creation** (`created_at`) and cannot be configured per message.
+   * - It mirrors the ephemeral *attachments* 1-day backstop, so a message and any media it carries expire together.
+   * - Expiry is delivery-independent — the clock starts when the message is created, not when it is delivered or read.
+   *
+   * **What you observe:**
+   *
+   * - **No expiry timestamp is exposed.** API responses and webhook payloads do not include the deletion time. If you need it, compute `created_at + 24h` yourself.
+   * - **No deletion webhook is sent.** There is no `message.deleted` event — a message simply stops being retrievable once its window passes.
+   * - **Delivery is unaffected.** Ephemeral messages send, deliver, and fire the usual `message.sent` / `message.received` and status webhooks exactly like standard messages. Only retention changes.
+   *
+   * **When to choose ephemeral:**
+   *
+   * - You have a compliance requirement that the platform must not retain message content beyond a short window.
+   * - The conversation is high-sensitivity (PHI, financial, identity verification) and you do not want it sitting in storage long-term.
+   * - Your application is the system of record — you capture what you need from the delivery webhook in real time and do not rely on reading message history back from Linq later.
+   *
+   * **Important:** ephemeral applies in *both directions* — messages you send **and** messages received by the phone numbers in that scope. Because Linq can no longer return the message after 24 hours, persist anything you need to keep from the webhook payload at the time it is delivered.
+   *
    */
   messages: API.Messages = new API.Messages(this);
   /**
@@ -1056,7 +1115,7 @@ export class LinqAPIV3 {
    * |---|---|---|
    * | Attachment bytes | Retained until you `DELETE` | **Auto-removed after 1 day**, also removable via `DELETE` |
    * | Attachment metadata (id, filename, mime type, size) | Retained until you `DELETE` | Removed alongside the bytes |
-   * | Message body & parts | Retained per message-retention policy | Retained per message-retention policy |
+   * | Message body & parts | Retained per message-retention policy | Retained per message-retention policy — unless the line also has **ephemeral messages** enabled (see the Messages page), in which case the message and its parts are deleted 24 hours after creation |
    * | Audit log of deletions | Retained per platform retention policy | Retained per platform retention policy |
    *
    * **In transit:** TLS 1.2+ everywhere. **At rest:** AES-256 (server-side encryption).
@@ -1096,6 +1155,17 @@ export class LinqAPIV3 {
    *
    */
   phoneNumbers: API.PhoneNumbers = new API.PhoneNumbers(this);
+  /**
+   * Phone Numbers represent the phone numbers assigned to your partner account.
+   *
+   * Use the list phone numbers endpoint to discover which phone numbers are available
+   * for sending messages.
+   *
+   * When creating chats, listing chats, or sending a voice memo, use one of your assigned phone numbers
+   * in the `from` field.
+   *
+   */
+  availableNumber: API.AvailableNumber = new API.AvailableNumber(this);
   /**
    * Webhook Subscriptions allow you to receive real-time notifications when events
    * occur on your account.
@@ -1380,6 +1450,7 @@ LinqAPIV3.Messages = Messages;
 LinqAPIV3.Attachments = Attachments;
 LinqAPIV3.Phonenumbers = Phonenumbers;
 LinqAPIV3.PhoneNumbers = PhoneNumbers;
+LinqAPIV3.AvailableNumber = AvailableNumber;
 LinqAPIV3.WebhookEvents = WebhookEvents;
 LinqAPIV3.WebhookSubscriptions = WebhookSubscriptions;
 LinqAPIV3.Capability = Capability;
@@ -1424,11 +1495,15 @@ export declare namespace LinqAPIV3 {
     type Message as Message,
     type MessageEffect as MessageEffect,
     type ReplyTo as ReplyTo,
+    type MessageCreateResponse as MessageCreateResponse,
     type MessageAddReactionResponse as MessageAddReactionResponse,
+    type MessageUpdateAppCardResponse as MessageUpdateAppCardResponse,
     type MessagesListMessagesPagination as MessagesListMessagesPagination,
+    type MessageCreateParams as MessageCreateParams,
     type MessageListMessagesThreadParams as MessageListMessagesThreadParams,
     type MessageAddReactionParams as MessageAddReactionParams,
     type MessageUpdateParams as MessageUpdateParams,
+    type MessageUpdateAppCardParams as MessageUpdateAppCardParams,
   };
 
   export {
@@ -1441,7 +1516,18 @@ export declare namespace LinqAPIV3 {
 
   export { Phonenumbers as Phonenumbers, type PhonenumberListResponse as PhonenumberListResponse };
 
-  export { PhoneNumbers as PhoneNumbers, type PhoneNumberListResponse as PhoneNumberListResponse };
+  export {
+    PhoneNumbers as PhoneNumbers,
+    type PhoneNumberUpdateResponse as PhoneNumberUpdateResponse,
+    type PhoneNumberListResponse as PhoneNumberListResponse,
+    type PhoneNumberUpdateParams as PhoneNumberUpdateParams,
+  };
+
+  export {
+    AvailableNumber as AvailableNumber,
+    type AvailableNumberRetrieveResponse as AvailableNumberRetrieveResponse,
+    type AvailableNumberRetrieveParams as AvailableNumberRetrieveParams,
+  };
 
   export {
     WebhookEvents as WebhookEvents,

package/src/internal/qs/LICENSE.md

@@ -0,0 +1,13 @@
+BSD 3-Clause License
+
+Copyright (c) 2014, Nathan LaFreniere and other [contributors](https://github.com/puruvj/neoqs/graphs/contributors) All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/src/internal/qs/README.md

@@ -0,0 +1,3 @@
+# qs
+
+This is a vendored version of [neoqs](https://github.com/PuruVJ/neoqs) which is a TypeScript rewrite of [qs](https://github.com/ljharb/qs), a query string library.

package/src/internal/qs/formats.ts

@@ -0,0 +1,10 @@
+import type { Format } from './types';
+
+export const default_format: Format = 'RFC3986';
+export const default_formatter = (v: PropertyKey) => String(v);
+export const formatters: Record<Format, (str: PropertyKey) => string> = {
+  RFC1738: (v: PropertyKey) => String(v).replace(/%20/g, '+'),
+  RFC3986: default_formatter,
+};
+export const RFC1738 = 'RFC1738';
+export const RFC3986 = 'RFC3986';

package/src/internal/qs/index.ts

@@ -0,0 +1,13 @@
+import { default_format, formatters, RFC1738, RFC3986 } from './formats';
+
+const formats = {
+  formatters,
+  RFC1738,
+  RFC3986,
+  default: default_format,
+};
+
+export { stringify } from './stringify';
+export { formats };
+
+export type { DefaultDecoder, DefaultEncoder, Format, ParseOptions, StringifyOptions } from './types';

package/src/internal/qs/stringify.ts

@@ -0,0 +1,385 @@
+import { encode, is_buffer, maybe_map, has } from './utils';
+import { default_format, default_formatter, formatters } from './formats';
+import type { NonNullableProperties, StringifyOptions } from './types';
+import { isArray } from '../utils/values';
+
+const array_prefix_generators = {
+  brackets(prefix: PropertyKey) {
+    return String(prefix) + '[]';
+  },
+  comma: 'comma',
+  indices(prefix: PropertyKey, key: string) {
+    return String(prefix) + '[' + key + ']';
+  },
+  repeat(prefix: PropertyKey) {
+    return String(prefix);
+  },
+};
+
+const push_to_array = function (arr: any[], value_or_array: any) {
+  Array.prototype.push.apply(arr, isArray(value_or_array) ? value_or_array : [value_or_array]);
+};
+
+let toISOString;
+
+const defaults = {
+  addQueryPrefix: false,
+  allowDots: false,
+  allowEmptyArrays: false,
+  arrayFormat: 'indices',
+  charset: 'utf-8',
+  charsetSentinel: false,
+  delimiter: '&',
+  encode: true,
+  encodeDotInKeys: false,
+  encoder: encode,
+  encodeValuesOnly: false,
+  format: default_format,
+  formatter: default_formatter,
+  /** @deprecated */
+  indices: false,
+  serializeDate(date) {
+    return (toISOString ??= Function.prototype.call.bind(Date.prototype.toISOString))(date);
+  },
+  skipNulls: false,
+  strictNullHandling: false,
+} as NonNullableProperties<StringifyOptions & { formatter: (typeof formatters)['RFC1738'] }>;
+
+function is_non_nullish_primitive(v: unknown): v is string | number | boolean | symbol | bigint {
+  return (
+    typeof v === 'string' ||
+    typeof v === 'number' ||
+    typeof v === 'boolean' ||
+    typeof v === 'symbol' ||
+    typeof v === 'bigint'
+  );
+}
+
+const sentinel = {};
+
+function inner_stringify(
+  object: any,
+  prefix: PropertyKey,
+  generateArrayPrefix: StringifyOptions['arrayFormat'] | ((prefix: string, key: string) => string),
+  commaRoundTrip: boolean,
+  allowEmptyArrays: boolean,
+  strictNullHandling: boolean,
+  skipNulls: boolean,
+  encodeDotInKeys: boolean,
+  encoder: StringifyOptions['encoder'],
+  filter: StringifyOptions['filter'],
+  sort: StringifyOptions['sort'],
+  allowDots: StringifyOptions['allowDots'],
+  serializeDate: StringifyOptions['serializeDate'],
+  format: StringifyOptions['format'],
+  formatter: StringifyOptions['formatter'],
+  encodeValuesOnly: boolean,
+  charset: StringifyOptions['charset'],
+  sideChannel: WeakMap<any, any>,
+) {
+  let obj = object;
+
+  let tmp_sc = sideChannel;
+  let step = 0;
+  let find_flag = false;
+  while ((tmp_sc = tmp_sc.get(sentinel)) !== void undefined && !find_flag) {
+    // Where object last appeared in the ref tree
+    const pos = tmp_sc.get(object);
+    step += 1;
+    if (typeof pos !== 'undefined') {
+      if (pos === step) {
+        throw new RangeError('Cyclic object value');
+      } else {
+        find_flag = true; // Break while
+      }
+    }
+    if (typeof tmp_sc.get(sentinel) === 'undefined') {
+      step = 0;
+    }
+  }
+
+  if (typeof filter === 'function') {
+    obj = filter(prefix, obj);
+  } else if (obj instanceof Date) {
+    obj = serializeDate?.(obj);
+  } else if (generateArrayPrefix === 'comma' && isArray(obj)) {
+    obj = maybe_map(obj, function (value) {
+      if (value instanceof Date) {
+        return serializeDate?.(value);
+      }
+      return value;
+    });
+  }
+
+  if (obj === null) {
+    if (strictNullHandling) {
+      return encoder && !encodeValuesOnly ?
+          // @ts-expect-error
+          encoder(prefix, defaults.encoder, charset, 'key', format)
+        : prefix;
+    }
+
+    obj = '';
+  }
+
+  if (is_non_nullish_primitive(obj) || is_buffer(obj)) {
+    if (encoder) {
+      const key_value =
+        encodeValuesOnly ? prefix
+          // @ts-expect-error
+        : encoder(prefix, defaults.encoder, charset, 'key', format);
+      return [
+        formatter?.(key_value) +
+          '=' +
+          // @ts-expect-error
+          formatter?.(encoder(obj, defaults.encoder, charset, 'value', format)),
+      ];
+    }
+    return [formatter?.(prefix) + '=' + formatter?.(String(obj))];
+  }
+
+  const values: string[] = [];
+
+  if (typeof obj === 'undefined') {
+    return values;
+  }
+
+  let obj_keys;
+  if (generateArrayPrefix === 'comma' && isArray(obj)) {
+    // we need to join elements in
+    if (encodeValuesOnly && encoder) {
+      // @ts-expect-error values only
+      obj = maybe_map(obj, encoder);
+    }
+    obj_keys = [{ value: obj.length > 0 ? obj.join(',') || null : void undefined }];
+  } else if (isArray(filter)) {
+    obj_keys = filter;
+  } else {
+    const keys = Object.keys(obj);
+    obj_keys = sort ? keys.sort(sort) : keys;
+  }
+
+  const encoded_prefix = encodeDotInKeys ? String(prefix).replace(/\./g, '%2E') : String(prefix);
+
+  const adjusted_prefix =
+    commaRoundTrip && isArray(obj) && obj.length === 1 ? encoded_prefix + '[]' : encoded_prefix;
+
+  if (allowEmptyArrays && isArray(obj) && obj.length === 0) {
+    return adjusted_prefix + '[]';
+  }
+
+  for (let j = 0; j < obj_keys.length; ++j) {
+    const key = obj_keys[j];
+    const value =
+      // @ts-ignore
+      typeof key === 'object' && typeof key.value !== 'undefined' ? key.value : obj[key as any];
+
+    if (skipNulls && value === null) {
+      continue;
+    }
+
+    // @ts-ignore
+    const encoded_key = allowDots && encodeDotInKeys ? (key as any).replace(/\./g, '%2E') : key;
+    const key_prefix =
+      isArray(obj) ?
+        typeof generateArrayPrefix === 'function' ?
+          generateArrayPrefix(adjusted_prefix, encoded_key)
+        : adjusted_prefix
+      : adjusted_prefix + (allowDots ? '.' + encoded_key : '[' + encoded_key + ']');
+
+    sideChannel.set(object, step);
+    const valueSideChannel = new WeakMap();
+    valueSideChannel.set(sentinel, sideChannel);
+    push_to_array(
+      values,
+      inner_stringify(
+        value,
+        key_prefix,
+        generateArrayPrefix,
+        commaRoundTrip,
+        allowEmptyArrays,
+        strictNullHandling,
+        skipNulls,
+        encodeDotInKeys,
+        // @ts-ignore
+        generateArrayPrefix === 'comma' && encodeValuesOnly && isArray(obj) ? null : encoder,
+        filter,
+        sort,
+        allowDots,
+        serializeDate,
+        format,
+        formatter,
+        encodeValuesOnly,
+        charset,
+        valueSideChannel,
+      ),
+    );
+  }
+
+  return values;
+}
+
+function normalize_stringify_options(
+  opts: StringifyOptions = defaults,
+): NonNullableProperties<Omit<StringifyOptions, 'indices'>> & { indices?: boolean } {
+  if (typeof opts.allowEmptyArrays !== 'undefined' && typeof opts.allowEmptyArrays !== 'boolean') {
+    throw new TypeError('`allowEmptyArrays` option can only be `true` or `false`, when provided');
+  }
+
+  if (typeof opts.encodeDotInKeys !== 'undefined' && typeof opts.encodeDotInKeys !== 'boolean') {
+    throw new TypeError('`encodeDotInKeys` option can only be `true` or `false`, when provided');
+  }
+
+  if (opts.encoder !== null && typeof opts.encoder !== 'undefined' && typeof opts.encoder !== 'function') {
+    throw new TypeError('Encoder has to be a function.');
+  }
+
+  const charset = opts.charset || defaults.charset;
+  if (typeof opts.charset !== 'undefined' && opts.charset !== 'utf-8' && opts.charset !== 'iso-8859-1') {
+    throw new TypeError('The charset option must be either utf-8, iso-8859-1, or undefined');
+  }
+
+  let format = default_format;
+  if (typeof opts.format !== 'undefined') {
+    if (!has(formatters, opts.format)) {
+      throw new TypeError('Unknown format option provided.');
+    }
+    format = opts.format;
+  }
+  const formatter = formatters[format];
+
+  let filter = defaults.filter;
+  if (typeof opts.filter === 'function' || isArray(opts.filter)) {
+    filter = opts.filter;
+  }
+
+  let arrayFormat: StringifyOptions['arrayFormat'];
+  if (opts.arrayFormat && opts.arrayFormat in array_prefix_generators) {
+    arrayFormat = opts.arrayFormat;
+  } else if ('indices' in opts) {
+    arrayFormat = opts.indices ? 'indices' : 'repeat';
+  } else {
+    arrayFormat = defaults.arrayFormat;
+  }
+
+  if ('commaRoundTrip' in opts && typeof opts.commaRoundTrip !== 'boolean') {
+    throw new TypeError('`commaRoundTrip` must be a boolean, or absent');
+  }
+
+  const allowDots =
+    typeof opts.allowDots === 'undefined' ?
+      !!opts.encodeDotInKeys === true ?
+        true
+      : defaults.allowDots
+    : !!opts.allowDots;
+
+  return {
+    addQueryPrefix: typeof opts.addQueryPrefix === 'boolean' ? opts.addQueryPrefix : defaults.addQueryPrefix,
+    // @ts-ignore
+    allowDots: allowDots,
+    allowEmptyArrays:
+      typeof opts.allowEmptyArrays === 'boolean' ? !!opts.allowEmptyArrays : defaults.allowEmptyArrays,
+    arrayFormat: arrayFormat,
+    charset: charset,
+    charsetSentinel:
+      typeof opts.charsetSentinel === 'boolean' ? opts.charsetSentinel : defaults.charsetSentinel,
+    commaRoundTrip: !!opts.commaRoundTrip,
+    delimiter: typeof opts.delimiter === 'undefined' ? defaults.delimiter : opts.delimiter,
+    encode: typeof opts.encode === 'boolean' ? opts.encode : defaults.encode,
+    encodeDotInKeys:
+      typeof opts.encodeDotInKeys === 'boolean' ? opts.encodeDotInKeys : defaults.encodeDotInKeys,
+    encoder: typeof opts.encoder === 'function' ? opts.encoder : defaults.encoder,
+    encodeValuesOnly:
+      typeof opts.encodeValuesOnly === 'boolean' ? opts.encodeValuesOnly : defaults.encodeValuesOnly,
+    filter: filter,
+    format: format,
+    formatter: formatter,
+    serializeDate: typeof opts.serializeDate === 'function' ? opts.serializeDate : defaults.serializeDate,
+    skipNulls: typeof opts.skipNulls === 'boolean' ? opts.skipNulls : defaults.skipNulls,
+    // @ts-ignore
+    sort: typeof opts.sort === 'function' ? opts.sort : null,
+    strictNullHandling:
+      typeof opts.strictNullHandling === 'boolean' ? opts.strictNullHandling : defaults.strictNullHandling,
+  };
+}
+
+export function stringify(object: any, opts: StringifyOptions = {}) {
+  let obj = object;
+  const options = normalize_stringify_options(opts);
+
+  let obj_keys: PropertyKey[] | undefined;
+  let filter;
+
+  if (typeof options.filter === 'function') {
+    filter = options.filter;
+    obj = filter('', obj);
+  } else if (isArray(options.filter)) {
+    filter = options.filter;
+    obj_keys = filter;
+  }
+
+  const keys: string[] = [];
+
+  if (typeof obj !== 'object' || obj === null) {
+    return '';
+  }
+
+  const generateArrayPrefix = array_prefix_generators[options.arrayFormat];
+  const commaRoundTrip = generateArrayPrefix === 'comma' && options.commaRoundTrip;
+
+  if (!obj_keys) {
+    obj_keys = Object.keys(obj);
+  }
+
+  if (options.sort) {
+    obj_keys.sort(options.sort);
+  }
+
+  const sideChannel = new WeakMap();
+  for (let i = 0; i < obj_keys.length; ++i) {
+    const key = obj_keys[i]!;
+
+    if (options.skipNulls && obj[key] === null) {
+      continue;
+    }
+    push_to_array(
+      keys,
+      inner_stringify(
+        obj[key],
+        key,
+        // @ts-expect-error
+        generateArrayPrefix,
+        commaRoundTrip,
+        options.allowEmptyArrays,
+        options.strictNullHandling,
+        options.skipNulls,
+        options.encodeDotInKeys,
+        options.encode ? options.encoder : null,
+        options.filter,
+        options.sort,
+        options.allowDots,
+        options.serializeDate,
+        options.format,
+        options.formatter,
+        options.encodeValuesOnly,
+        options.charset,
+        sideChannel,
+      ),
+    );
+  }
+
+  const joined = keys.join(options.delimiter);
+  let prefix = options.addQueryPrefix === true ? '?' : '';
+
+  if (options.charsetSentinel) {
+    if (options.charset === 'iso-8859-1') {
+      // encodeURIComponent('&#10003;'), the "numeric entity" representation of a checkmark
+      prefix += 'utf8=%26%2310003%3B&';
+    } else {
+      // encodeURIComponent('✓')
+      prefix += 'utf8=%E2%9C%93&';
+    }
+  }
+
+  return joined.length > 0 ? prefix + joined : '';
+}