@stigg/typescript 0.1.0-beta.20 → 0.1.0-beta.22

package/src/resources/v1/customers/index.ts

@@ -9,13 +9,16 @@ export {
   type CustomerImportResponse,
   type CustomerListResourcesResponse,
   type CustomerRetrieveEntitlementsResponse,
+  type CustomerRetrieveParams,
   type CustomerUpdateParams,
   type CustomerListParams,
+  type CustomerArchiveParams,
   type CustomerCheckEntitlementParams,
   type CustomerImportParams,
   type CustomerListResourcesParams,
   type CustomerProvisionParams,
   type CustomerRetrieveEntitlementsParams,
+  type CustomerUnarchiveParams,
   type CustomerListResponsesMyCursorIDPage,
   type CustomerListResourcesResponsesMyCursorIDPage,
 } from './customers';
@@ -29,7 +32,11 @@ export {
   type IntegrationUnlinkParams,
   type IntegrationListResponsesMyCursorIDPage,
 } from './integrations';
-export { PaymentMethod, type PaymentMethodAttachParams } from './payment-method';
+export {
+  PaymentMethod,
+  type PaymentMethodAttachParams,
+  type PaymentMethodDetachParams,
+} from './payment-method';
 export {
   PromotionalEntitlements,
   type PromotionalEntitlementCreateResponse,

package/src/resources/v1/customers/integrations.ts

@@ -4,123 +4,124 @@ import { APIResource } from '../../../core/resource';
 import * as CustomersAPI from './customers';
 import { APIPromise } from '../../../core/api-promise';
 import { MyCursorIDPage, type MyCursorIDPageParams, PagePromise } from '../../../core/pagination';
+import { buildHeaders } from '../../../internal/headers';
 import { RequestOptions } from '../../../internal/request-options';
 import { path } from '../../../internal/utils/path';
 
 export class Integrations extends APIResource {
   /**
    * Retrieves a specific integration for a customer by integration ID.
-   *
-   * @example
-   * ```ts
-   * const customerIntegrationResponse =
-   *   await client.v1.customers.integrations.retrieve(
-   *     'integrationId',
-   *     { id: 'id' },
-   *   );
-   * ```
    */
   retrieve(
     integrationID: string,
     params: IntegrationRetrieveParams,
     options?: RequestOptions,
   ): APIPromise<CustomersAPI.CustomerIntegrationResponse> {
-    const { id } = params;
-    return this._client.get(path`/api/v1/customers/${id}/integrations/${integrationID}`, options);
+    const { id, 'X-ACCOUNT-ID': xAccountID, 'X-ENVIRONMENT-ID': xEnvironmentID } = params;
+    return this._client.get(path`/api/v1/customers/${id}/integrations/${integrationID}`, {
+      ...options,
+      headers: buildHeaders([
+        {
+          ...(xAccountID != null ? { 'X-ACCOUNT-ID': xAccountID } : undefined),
+          ...(xEnvironmentID != null ? { 'X-ENVIRONMENT-ID': xEnvironmentID } : undefined),
+        },
+        options?.headers,
+      ]),
+    });
   }
 
   /**
    * Updates a customer's integration link, such as changing the synced external
    * entity ID.
-   *
-   * @example
-   * ```ts
-   * const customerIntegrationResponse =
-   *   await client.v1.customers.integrations.update(
-   *     'integrationId',
-   *     { id: 'id', syncedEntityId: 'syncedEntityId' },
-   *   );
-   * ```
    */
   update(
     integrationID: string,
     params: IntegrationUpdateParams,
     options?: RequestOptions,
   ): APIPromise<CustomersAPI.CustomerIntegrationResponse> {
-    const { id, ...body } = params;
+    const { id, 'X-ACCOUNT-ID': xAccountID, 'X-ENVIRONMENT-ID': xEnvironmentID, ...body } = params;
     return this._client.patch(path`/api/v1/customers/${id}/integrations/${integrationID}`, {
       body,
       ...options,
+      headers: buildHeaders([
+        {
+          ...(xAccountID != null ? { 'X-ACCOUNT-ID': xAccountID } : undefined),
+          ...(xEnvironmentID != null ? { 'X-ENVIRONMENT-ID': xEnvironmentID } : undefined),
+        },
+        options?.headers,
+      ]),
     });
   }
 
   /**
    * Retrieves a paginated list of a customer's external integrations (billing, CRM,
    * etc.).
-   *
-   * @example
-   * ```ts
-   * // Automatically fetches more pages as needed.
-   * for await (const integrationListResponse of client.v1.customers.integrations.list(
-   *   'x',
-   * )) {
-   *   // ...
-   * }
-   * ```
    */
   list(
     id: string,
-    query: IntegrationListParams | null | undefined = {},
+    params: IntegrationListParams | null | undefined = {},
     options?: RequestOptions,
   ): PagePromise<IntegrationListResponsesMyCursorIDPage, IntegrationListResponse> {
+    const { 'X-ACCOUNT-ID': xAccountID, 'X-ENVIRONMENT-ID': xEnvironmentID, ...query } = params ?? {};
     return this._client.getAPIList(
       path`/api/v1/customers/${id}/integrations`,
       MyCursorIDPage<IntegrationListResponse>,
-      { query, ...options },
+      {
+        query,
+        ...options,
+        headers: buildHeaders([
+          {
+            ...(xAccountID != null ? { 'X-ACCOUNT-ID': xAccountID } : undefined),
+            ...(xEnvironmentID != null ? { 'X-ENVIRONMENT-ID': xEnvironmentID } : undefined),
+          },
+          options?.headers,
+        ]),
+      },
     );
   }
 
   /**
    * Links a customer to an external integration by specifying the vendor and
    * external entity ID.
-   *
-   * @example
-   * ```ts
-   * const customerIntegrationResponse =
-   *   await client.v1.customers.integrations.link('x', {
-   *     id: 'id',
-   *     syncedEntityId: 'syncedEntityId',
-   *     vendorIdentifier: 'AUTH0',
-   *   });
-   * ```
    */
   link(
     id: string,
-    body: IntegrationLinkParams,
+    params: IntegrationLinkParams,
     options?: RequestOptions,
   ): APIPromise<CustomersAPI.CustomerIntegrationResponse> {
-    return this._client.post(path`/api/v1/customers/${id}/integrations`, { body, ...options });
+    const { 'X-ACCOUNT-ID': xAccountID, 'X-ENVIRONMENT-ID': xEnvironmentID, ...body } = params;
+    return this._client.post(path`/api/v1/customers/${id}/integrations`, {
+      body,
+      ...options,
+      headers: buildHeaders([
+        {
+          ...(xAccountID != null ? { 'X-ACCOUNT-ID': xAccountID } : undefined),
+          ...(xEnvironmentID != null ? { 'X-ENVIRONMENT-ID': xEnvironmentID } : undefined),
+        },
+        options?.headers,
+      ]),
+    });
   }
 
   /**
    * Removes the link between a customer and an external integration.
-   *
-   * @example
-   * ```ts
-   * const customerIntegrationResponse =
-   *   await client.v1.customers.integrations.unlink(
-   *     'integrationId',
-   *     { id: 'id' },
-   *   );
-   * ```
    */
   unlink(
     integrationID: string,
     params: IntegrationUnlinkParams,
     options?: RequestOptions,
   ): APIPromise<CustomersAPI.CustomerIntegrationResponse> {
-    const { id } = params;
-    return this._client.delete(path`/api/v1/customers/${id}/integrations/${integrationID}`, options);
+    const { id, 'X-ACCOUNT-ID': xAccountID, 'X-ENVIRONMENT-ID': xEnvironmentID } = params;
+    return this._client.delete(path`/api/v1/customers/${id}/integrations/${integrationID}`, {
+      ...options,
+      headers: buildHeaders([
+        {
+          ...(xAccountID != null ? { 'X-ACCOUNT-ID': xAccountID } : undefined),
+          ...(xEnvironmentID != null ? { 'X-ENVIRONMENT-ID': xEnvironmentID } : undefined),
+        },
+        options?.headers,
+      ]),
+    });
   }
 }
 
@@ -218,9 +219,22 @@ export namespace IntegrationListResponse {
 
 export interface IntegrationRetrieveParams {
   /**
-   * Customer slug
+   * Path param: Customer slug
    */
   id: string;
+
+  /**
+   * Header param: Account ID — optional when authenticating with a user JWT (Bearer
+   * token); falls back to the user's first membership. Ignored for API-key auth.
+   */
+  'X-ACCOUNT-ID'?: string;
+
+  /**
+   * Header param: Environment ID — required when authenticating with a user JWT
+   * (Bearer token) on environment-scoped endpoints. Ignored for API-key auth (env is
+   * intrinsic to the key).
+   */
+  'X-ENVIRONMENT-ID'?: string;
 }
 
 export interface IntegrationUpdateParams {
@@ -233,12 +247,25 @@ export interface IntegrationUpdateParams {
    * Body param: Synced entity id
    */
   syncedEntityId: string | null;
+
+  /**
+   * Header param: Account ID — optional when authenticating with a user JWT (Bearer
+   * token); falls back to the user's first membership. Ignored for API-key auth.
+   */
+  'X-ACCOUNT-ID'?: string;
+
+  /**
+   * Header param: Environment ID — required when authenticating with a user JWT
+   * (Bearer token) on environment-scoped endpoints. Ignored for API-key auth (env is
+   * intrinsic to the key).
+   */
+  'X-ENVIRONMENT-ID'?: string;
 }
 
 export interface IntegrationListParams extends MyCursorIDPageParams {
   /**
-   * Filter by vendor identifier. Supports comma-separated values for multiple
-   * vendors (e.g., STRIPE,HUBSPOT)
+   * Query param: Filter by vendor identifier. Supports comma-separated values for
+   * multiple vendors (e.g., STRIPE,HUBSPOT)
    */
   vendorIdentifier?: Array<
     | 'AUTH0'
@@ -254,21 +281,34 @@ export interface IntegrationListParams extends MyCursorIDPageParams {
     | 'RECEIVED'
     | 'PREQUEL'
   >;
+
+  /**
+   * Header param: Account ID — optional when authenticating with a user JWT (Bearer
+   * token); falls back to the user's first membership. Ignored for API-key auth.
+   */
+  'X-ACCOUNT-ID'?: string;
+
+  /**
+   * Header param: Environment ID — required when authenticating with a user JWT
+   * (Bearer token) on environment-scoped endpoints. Ignored for API-key auth (env is
+   * intrinsic to the key).
+   */
+  'X-ENVIRONMENT-ID'?: string;
 }
 
 export interface IntegrationLinkParams {
   /**
-   * Integration details
+   * Body param: Integration details
    */
   id: string;
 
   /**
-   * Synced entity id
+   * Body param: Synced entity id
    */
   syncedEntityId: string;
 
   /**
-   * The vendor identifier of integration
+   * Body param: The vendor identifier of integration
    */
   vendorIdentifier:
     | 'AUTH0'
@@ -283,13 +323,39 @@ export interface IntegrationLinkParams {
     | 'APP_STORE'
     | 'RECEIVED'
     | 'PREQUEL';
+
+  /**
+   * Header param: Account ID — optional when authenticating with a user JWT (Bearer
+   * token); falls back to the user's first membership. Ignored for API-key auth.
+   */
+  'X-ACCOUNT-ID'?: string;
+
+  /**
+   * Header param: Environment ID — required when authenticating with a user JWT
+   * (Bearer token) on environment-scoped endpoints. Ignored for API-key auth (env is
+   * intrinsic to the key).
+   */
+  'X-ENVIRONMENT-ID'?: string;
 }
 
 export interface IntegrationUnlinkParams {
   /**
-   * Customer slug
+   * Path param: Customer slug
    */
   id: string;
+
+  /**
+   * Header param: Account ID — optional when authenticating with a user JWT (Bearer
+   * token); falls back to the user's first membership. Ignored for API-key auth.
+   */
+  'X-ACCOUNT-ID'?: string;
+
+  /**
+   * Header param: Environment ID — required when authenticating with a user JWT
+   * (Bearer token) on environment-scoped endpoints. Ignored for API-key auth (env is
+   * intrinsic to the key).
+   */
+  'X-ENVIRONMENT-ID'?: string;
 }
 
 export declare namespace Integrations {

package/src/resources/v1/customers/payment-method.ts

@@ -3,6 +3,7 @@
 import { APIResource } from '../../../core/resource';
 import * as CustomersAPI from './customers';
 import { APIPromise } from '../../../core/api-promise';
+import { buildHeaders } from '../../../internal/headers';
 import { RequestOptions } from '../../../internal/request-options';
 import { path } from '../../../internal/utils/path';
 
@@ -13,53 +14,62 @@ export class PaymentMethod extends APIResource {
   /**
    * Attaches a payment method to a customer for billing. Required for paid
    * subscriptions when integrated with a billing provider.
-   *
-   * @example
-   * ```ts
-   * const customerResponse =
-   *   await client.v1.customers.paymentMethod.attach('x', {
-   *     integrationId: 'integrationId',
-   *     paymentMethodId: 'paymentMethodId',
-   *     vendorIdentifier: 'AUTH0',
-   *   });
-   * ```
    */
   attach(
     id: string,
-    body: PaymentMethodAttachParams,
+    params: PaymentMethodAttachParams,
     options?: RequestOptions,
   ): APIPromise<CustomersAPI.CustomerResponse> {
-    return this._client.post(path`/api/v1/customers/${id}/payment-method`, { body, ...options });
+    const { 'X-ACCOUNT-ID': xAccountID, 'X-ENVIRONMENT-ID': xEnvironmentID, ...body } = params;
+    return this._client.post(path`/api/v1/customers/${id}/payment-method`, {
+      body,
+      ...options,
+      headers: buildHeaders([
+        {
+          ...(xAccountID != null ? { 'X-ACCOUNT-ID': xAccountID } : undefined),
+          ...(xEnvironmentID != null ? { 'X-ENVIRONMENT-ID': xEnvironmentID } : undefined),
+        },
+        options?.headers,
+      ]),
+    });
   }
 
   /**
    * Removes the payment method from a customer. Ensure active paid subscriptions
    * have an alternative payment method.
-   *
-   * @example
-   * ```ts
-   * const customerResponse =
-   *   await client.v1.customers.paymentMethod.detach('x');
-   * ```
    */
-  detach(id: string, options?: RequestOptions): APIPromise<CustomersAPI.CustomerResponse> {
-    return this._client.delete(path`/api/v1/customers/${id}/payment-method`, options);
+  detach(
+    id: string,
+    params: PaymentMethodDetachParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<CustomersAPI.CustomerResponse> {
+    const { 'X-ACCOUNT-ID': xAccountID, 'X-ENVIRONMENT-ID': xEnvironmentID } = params ?? {};
+    return this._client.delete(path`/api/v1/customers/${id}/payment-method`, {
+      ...options,
+      headers: buildHeaders([
+        {
+          ...(xAccountID != null ? { 'X-ACCOUNT-ID': xAccountID } : undefined),
+          ...(xEnvironmentID != null ? { 'X-ENVIRONMENT-ID': xEnvironmentID } : undefined),
+        },
+        options?.headers,
+      ]),
+    });
   }
 }
 
 export interface PaymentMethodAttachParams {
   /**
-   * Integration details
+   * Body param: Integration details
    */
   integrationId: string;
 
   /**
-   * Billing provider payment method id
+   * Body param: Billing provider payment method id
    */
   paymentMethodId: string;
 
   /**
-   * The vendor identifier of integration
+   * Body param: The vendor identifier of integration
    */
   vendorIdentifier:
     | 'AUTH0'
@@ -76,7 +86,7 @@ export interface PaymentMethodAttachParams {
     | 'PREQUEL';
 
   /**
-   * Customers selected currency
+   * Body param: Customers selected currency
    */
   billingCurrency?:
     | 'usd'
@@ -196,8 +206,39 @@ export interface PaymentMethodAttachParams {
     | 'xof'
     | 'xpf'
     | null;
+
+  /**
+   * Header param: Account ID — optional when authenticating with a user JWT (Bearer
+   * token); falls back to the user's first membership. Ignored for API-key auth.
+   */
+  'X-ACCOUNT-ID'?: string;
+
+  /**
+   * Header param: Environment ID — required when authenticating with a user JWT
+   * (Bearer token) on environment-scoped endpoints. Ignored for API-key auth (env is
+   * intrinsic to the key).
+   */
+  'X-ENVIRONMENT-ID'?: string;
+}
+
+export interface PaymentMethodDetachParams {
+  /**
+   * Account ID — optional when authenticating with a user JWT (Bearer token); falls
+   * back to the user's first membership. Ignored for API-key auth.
+   */
+  'X-ACCOUNT-ID'?: string;
+
+  /**
+   * Environment ID — required when authenticating with a user JWT (Bearer token) on
+   * environment-scoped endpoints. Ignored for API-key auth (env is intrinsic to the
+   * key).
+   */
+  'X-ENVIRONMENT-ID'?: string;
 }
 
 export declare namespace PaymentMethod {
-  export { type PaymentMethodAttachParams as PaymentMethodAttachParams };
+  export {
+    type PaymentMethodAttachParams as PaymentMethodAttachParams,
+    type PaymentMethodDetachParams as PaymentMethodDetachParams,
+  };
 }

package/src/resources/v1/customers/promotional-entitlements.ts

@@ -3,6 +3,7 @@
 import { APIResource } from '../../../core/resource';
 import { APIPromise } from '../../../core/api-promise';
 import { MyCursorIDPage, type MyCursorIDPageParams, PagePromise } from '../../../core/pagination';
+import { buildHeaders } from '../../../internal/headers';
 import { RequestOptions } from '../../../internal/request-options';
 import { path } from '../../../internal/utils/path';
 
@@ -13,92 +14,72 @@ export class PromotionalEntitlements extends APIResource {
   /**
    * Grants promotional entitlements to a customer, providing feature access outside
    * their subscription. Entitlements can be time-limited or permanent.
-   *
-   * @example
-   * ```ts
-   * const promotionalEntitlement =
-   *   await client.v1.customers.promotionalEntitlements.create(
-   *     'x',
-   *     {
-   *       promotionalEntitlements: [
-   *         {
-   *           customEndDate: '2019-12-27T18:11:19.117Z',
-   *           enumValues: ['string'],
-   *           featureId: 'featureId',
-   *           hasSoftLimit: true,
-   *           hasUnlimitedUsage: true,
-   *           isVisible: true,
-   *           monthlyResetPeriodConfiguration: {
-   *             accordingTo: 'SubscriptionStart',
-   *           },
-   *           period: '1 week',
-   *           resetPeriod: 'YEAR',
-   *           usageLimit: -9007199254740991,
-   *           weeklyResetPeriodConfiguration: {
-   *             accordingTo: 'SubscriptionStart',
-   *           },
-   *           yearlyResetPeriodConfiguration: {
-   *             accordingTo: 'SubscriptionStart',
-   *           },
-   *         },
-   *       ],
-   *     },
-   *   );
-   * ```
    */
   create(
     id: string,
-    body: PromotionalEntitlementCreateParams,
+    params: PromotionalEntitlementCreateParams,
     options?: RequestOptions,
   ): APIPromise<PromotionalEntitlementCreateResponse> {
-    return this._client.post(path`/api/v1/customers/${id}/promotional-entitlements`, { body, ...options });
+    const { 'X-ACCOUNT-ID': xAccountID, 'X-ENVIRONMENT-ID': xEnvironmentID, ...body } = params;
+    return this._client.post(path`/api/v1/customers/${id}/promotional-entitlements`, {
+      body,
+      ...options,
+      headers: buildHeaders([
+        {
+          ...(xAccountID != null ? { 'X-ACCOUNT-ID': xAccountID } : undefined),
+          ...(xEnvironmentID != null ? { 'X-ENVIRONMENT-ID': xEnvironmentID } : undefined),
+        },
+        options?.headers,
+      ]),
+    });
   }
 
   /**
    * Retrieves a paginated list of a customer's promotional entitlements.
-   *
-   * @example
-   * ```ts
-   * // Automatically fetches more pages as needed.
-   * for await (const promotionalEntitlementListResponse of client.v1.customers.promotionalEntitlements.list(
-   *   'x',
-   * )) {
-   *   // ...
-   * }
-   * ```
    */
   list(
     id: string,
-    query: PromotionalEntitlementListParams | null | undefined = {},
+    params: PromotionalEntitlementListParams | null | undefined = {},
     options?: RequestOptions,
   ): PagePromise<PromotionalEntitlementListResponsesMyCursorIDPage, PromotionalEntitlementListResponse> {
+    const { 'X-ACCOUNT-ID': xAccountID, 'X-ENVIRONMENT-ID': xEnvironmentID, ...query } = params ?? {};
     return this._client.getAPIList(
       path`/api/v1/customers/${id}/promotional-entitlements`,
       MyCursorIDPage<PromotionalEntitlementListResponse>,
-      { query, ...options },
+      {
+        query,
+        ...options,
+        headers: buildHeaders([
+          {
+            ...(xAccountID != null ? { 'X-ACCOUNT-ID': xAccountID } : undefined),
+            ...(xEnvironmentID != null ? { 'X-ENVIRONMENT-ID': xEnvironmentID } : undefined),
+          },
+          options?.headers,
+        ]),
+      },
     );
   }
 
   /**
    * Revokes a previously granted promotional entitlement from a customer for a
    * specific feature.
-   *
-   * @example
-   * ```ts
-   * const response =
-   *   await client.v1.customers.promotionalEntitlements.revoke(
-   *     'featureId',
-   *     { id: 'id' },
-   *   );
-   * ```
    */
   revoke(
     featureID: string,
     params: PromotionalEntitlementRevokeParams,
     options?: RequestOptions,
   ): APIPromise<PromotionalEntitlementRevokeResponse> {
-    const { id } = params;
-    return this._client.delete(path`/api/v1/customers/${id}/promotional-entitlements/${featureID}`, options);
+    const { id, 'X-ACCOUNT-ID': xAccountID, 'X-ENVIRONMENT-ID': xEnvironmentID } = params;
+    return this._client.delete(path`/api/v1/customers/${id}/promotional-entitlements/${featureID}`, {
+      ...options,
+      headers: buildHeaders([
+        {
+          ...(xAccountID != null ? { 'X-ACCOUNT-ID': xAccountID } : undefined),
+          ...(xEnvironmentID != null ? { 'X-ENVIRONMENT-ID': xEnvironmentID } : undefined),
+        },
+        options?.headers,
+      ]),
+    });
   }
 }
 
@@ -545,9 +526,22 @@ export namespace PromotionalEntitlementRevokeResponse {
 
 export interface PromotionalEntitlementCreateParams {
   /**
-   * Promotional entitlements to grant
+   * Body param: Promotional entitlements to grant
    */
   promotionalEntitlements: Array<PromotionalEntitlementCreateParams.PromotionalEntitlement>;
+
+  /**
+   * Header param: Account ID — optional when authenticating with a user JWT (Bearer
+   * token); falls back to the user's first membership. Ignored for API-key auth.
+   */
+  'X-ACCOUNT-ID'?: string;
+
+  /**
+   * Header param: Environment ID — required when authenticating with a user JWT
+   * (Bearer token) on environment-scoped endpoints. Ignored for API-key auth (env is
+   * intrinsic to the key).
+   */
+  'X-ENVIRONMENT-ID'?: string;
 }
 
 export namespace PromotionalEntitlementCreateParams {
@@ -665,15 +659,28 @@ export namespace PromotionalEntitlementCreateParams {
 
 export interface PromotionalEntitlementListParams extends MyCursorIDPageParams {
   /**
-   * Filter by creation date using range operators: gt, gte, lt, lte
+   * Query param: Filter by creation date using range operators: gt, gte, lt, lte
    */
   createdAt?: PromotionalEntitlementListParams.CreatedAt;
 
   /**
-   * Filter by promotional entitlement status. Supports comma-separated values for
-   * multiple statuses
+   * Query param: Filter by promotional entitlement status. Supports comma-separated
+   * values for multiple statuses
    */
   status?: Array<'Active' | 'Expired' | 'Paused'>;
+
+  /**
+   * Header param: Account ID — optional when authenticating with a user JWT (Bearer
+   * token); falls back to the user's first membership. Ignored for API-key auth.
+   */
+  'X-ACCOUNT-ID'?: string;
+
+  /**
+   * Header param: Environment ID — required when authenticating with a user JWT
+   * (Bearer token) on environment-scoped endpoints. Ignored for API-key auth (env is
+   * intrinsic to the key).
+   */
+  'X-ENVIRONMENT-ID'?: string;
 }
 
 export namespace PromotionalEntitlementListParams {
@@ -705,9 +712,22 @@ export namespace PromotionalEntitlementListParams {
 
 export interface PromotionalEntitlementRevokeParams {
   /**
-   * The unique identifier of the customer
+   * Path param: The unique identifier of the customer
    */
   id: string;
+
+  /**
+   * Header param: Account ID — optional when authenticating with a user JWT (Bearer
+   * token); falls back to the user's first membership. Ignored for API-key auth.
+   */
+  'X-ACCOUNT-ID'?: string;
+
+  /**
+   * Header param: Environment ID — required when authenticating with a user JWT
+   * (Bearer token) on environment-scoped endpoints. Ignored for API-key auth (env is
+   * intrinsic to the key).
+   */
+  'X-ENVIRONMENT-ID'?: string;
 }
 
 export declare namespace PromotionalEntitlements {