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

package/src/resources/v1/events/beta/customers/entities.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';
 
@@ -24,8 +25,17 @@ export class Entities extends APIResource {
     params: EntityRetrieveParams,
     options?: RequestOptions,
   ): APIPromise<EntityRetrieveResponse> {
-    const { id } = params;
-    return this._client.get(path`/api/v1-beta/customers/${id}/entities/${entityID}`, options);
+    const { id, 'X-ACCOUNT-ID': xAccountID, 'X-ENVIRONMENT-ID': xEnvironmentID } = params;
+    return this._client.get(path`/api/v1-beta/customers/${id}/entities/${entityID}`, {
+      ...options,
+      headers: buildHeaders([
+        {
+          ...(xAccountID != null ? { 'X-ACCOUNT-ID': xAccountID } : undefined),
+          ...(xEnvironmentID != null ? { 'X-ENVIRONMENT-ID': xEnvironmentID } : undefined),
+        },
+        options?.headers,
+      ]),
+    });
   }
 
   /**
@@ -43,13 +53,24 @@ export class Entities extends APIResource {
    */
   list(
     id: string,
-    query: EntityListParams | null | undefined = {},
+    params: EntityListParams | null | undefined = {},
     options?: RequestOptions,
   ): PagePromise<EntityListResponsesMyCursorIDPage, EntityListResponse> {
+    const { 'X-ACCOUNT-ID': xAccountID, 'X-ENVIRONMENT-ID': xEnvironmentID, ...query } = params ?? {};
     return this._client.getAPIList(
       path`/api/v1-beta/customers/${id}/entities`,
       MyCursorIDPage<EntityListResponse>,
-      { query, ...options },
+      {
+        query,
+        ...options,
+        headers: buildHeaders([
+          {
+            ...(xAccountID != null ? { 'X-ACCOUNT-ID': xAccountID } : undefined),
+            ...(xEnvironmentID != null ? { 'X-ENVIRONMENT-ID': xEnvironmentID } : undefined),
+          },
+          options?.headers,
+        ]),
+      },
     );
   }
 
@@ -67,10 +88,21 @@ export class Entities extends APIResource {
    */
   archive(
     id: string,
-    body: EntityArchiveParams,
+    params: EntityArchiveParams,
     options?: RequestOptions,
   ): APIPromise<EntityArchiveResponse> {
-    return this._client.post(path`/api/v1-beta/customers/${id}/entities/archive`, { body, ...options });
+    const { 'X-ACCOUNT-ID': xAccountID, 'X-ENVIRONMENT-ID': xEnvironmentID, ...body } = params;
+    return this._client.post(path`/api/v1-beta/customers/${id}/entities/archive`, {
+      body,
+      ...options,
+      headers: buildHeaders([
+        {
+          ...(xAccountID != null ? { 'X-ACCOUNT-ID': xAccountID } : undefined),
+          ...(xEnvironmentID != null ? { 'X-ENVIRONMENT-ID': xEnvironmentID } : undefined),
+        },
+        options?.headers,
+      ]),
+    });
   }
 
   /**
@@ -87,10 +119,21 @@ export class Entities extends APIResource {
    */
   unarchive(
     id: string,
-    body: EntityUnarchiveParams,
+    params: EntityUnarchiveParams,
     options?: RequestOptions,
   ): APIPromise<EntityUnarchiveResponse> {
-    return this._client.post(path`/api/v1-beta/customers/${id}/entities/unarchive`, { body, ...options });
+    const { 'X-ACCOUNT-ID': xAccountID, 'X-ENVIRONMENT-ID': xEnvironmentID, ...body } = params;
+    return this._client.post(path`/api/v1-beta/customers/${id}/entities/unarchive`, {
+      body,
+      ...options,
+      headers: buildHeaders([
+        {
+          ...(xAccountID != null ? { 'X-ACCOUNT-ID': xAccountID } : undefined),
+          ...(xEnvironmentID != null ? { 'X-ENVIRONMENT-ID': xEnvironmentID } : undefined),
+        },
+        options?.headers,
+      ]),
+    });
   }
 
   /**
@@ -122,8 +165,19 @@ export class Entities extends APIResource {
    *   );
    * ```
    */
-  upsert(id: string, body: EntityUpsertParams, options?: RequestOptions): APIPromise<EntityUpsertResponse> {
-    return this._client.put(path`/api/v1-beta/customers/${id}/entities`, { body, ...options });
+  upsert(id: string, params: EntityUpsertParams, options?: RequestOptions): APIPromise<EntityUpsertResponse> {
+    const { 'X-ACCOUNT-ID': xAccountID, 'X-ENVIRONMENT-ID': xEnvironmentID, ...body } = params;
+    return this._client.put(path`/api/v1-beta/customers/${id}/entities`, {
+      body,
+      ...options,
+      headers: buildHeaders([
+        {
+          ...(xAccountID != null ? { 'X-ACCOUNT-ID': xAccountID } : undefined),
+          ...(xEnvironmentID != null ? { 'X-ENVIRONMENT-ID': xEnvironmentID } : undefined),
+        },
+        options?.headers,
+      ]),
+    });
   }
 }
 
@@ -301,42 +355,108 @@ export namespace EntityUpsertResponse {
 
 export interface EntityRetrieveParams {
   /**
-   * The customer identifier (owner) the entity belongs to
+   * Path param: The customer identifier (owner) the entity belongs to
    */
   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 EntityListParams extends MyCursorIDPageParams {
   /**
-   * Whether to include archived entities. One of: true, false
+   * Query param: Whether to include archived entities. One of: true, false
    */
   includeArchived?: 'true' | 'false';
 
   /**
-   * Filter results to entities of a specific entity type, by the type's refId
+   * Query param: Filter results to entities of a specific entity type, by the type's
+   * refId
    */
   typeRefId?: 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 EntityArchiveParams {
   /**
-   * Entity identifiers to act on
+   * Body param: Entity identifiers to act on
    */
   ids: Array<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 EntityUnarchiveParams {
   /**
-   * Entity identifiers to act on
+   * Body param: Entity identifiers to act on
    */
   ids: Array<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 EntityUpsertParams {
   /**
-   * List of entities to create or update (1-100 entries)
+   * Body param: List of entities to create or update (1-100 entries)
    */
   entities: Array<EntityUpsertParams.Entity>;
+
+  /**
+   * 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 EntityUpsertParams {

package/src/resources/v1/events/beta/customers/entitlements.ts

@@ -2,6 +2,7 @@
 
 import { APIResource } from '../../../../../core/resource';
 import { APIPromise } from '../../../../../core/api-promise';
+import { buildHeaders } from '../../../../../internal/headers';
 import { RequestOptions } from '../../../../../internal/request-options';
 import { path } from '../../../../../internal/utils/path';
 
@@ -21,10 +22,21 @@ export class Entitlements extends APIResource {
    */
   check(
     id: string,
-    query: EntitlementCheckParams | null | undefined = {},
+    params: EntitlementCheckParams | null | undefined = {},
     options?: RequestOptions,
   ): APIPromise<EntitlementCheckResponse> {
-    return this._client.get(path`/api/v1-beta/customers/${id}/entitlements/check`, { query, ...options });
+    const { 'X-ACCOUNT-ID': xAccountID, 'X-ENVIRONMENT-ID': xEnvironmentID, ...query } = params ?? {};
+    return this._client.get(path`/api/v1-beta/customers/${id}/entitlements/check`, {
+      query,
+      ...options,
+      headers: buildHeaders([
+        {
+          ...(xAccountID != null ? { 'X-ACCOUNT-ID': xAccountID } : undefined),
+          ...(xEnvironmentID != null ? { 'X-ENVIRONMENT-ID': xEnvironmentID } : undefined),
+        },
+        options?.headers,
+      ]),
+    });
   }
 }
 
@@ -286,37 +298,52 @@ export namespace EntitlementCheckResponse {
 
 export interface EntitlementCheckParams {
   /**
-   * Currency ID (refId) to check for credit entitlements. Mutually exclusive with
-   * `featureId`.
+   * Query param: Currency ID (refId) to check for credit entitlements. Mutually
+   * exclusive with `featureId`.
    */
   currencyId?: string;
 
   /**
-   * Optional attribution map (e.g. `dimensions[userId]=u1`). When provided, the
-   * response includes a `chains` array with per-entity governance limits.
+   * Query param: Optional attribution map (e.g. `dimensions[userId]=u1`). When
+   * provided, the response includes a `chains` array with per-entity governance
+   * limits.
    */
   dimensions?: { [key: string]: string };
 
   /**
-   * Feature ID (refId) to check. Mutually exclusive with `currencyId`.
+   * Query param: Feature ID (refId) to check. Mutually exclusive with `currencyId`.
    */
   featureId?: string;
 
   /**
-   * Requested usage amount to evaluate against the entitlement limit (numeric
-   * features only)
+   * Query param: Requested usage amount to evaluate against the entitlement limit
+   * (numeric features only)
    */
   requestedUsage?: number;
 
   /**
-   * Requested values to evaluate against allowed values (enum features only)
+   * Query param: Requested values to evaluate against allowed values (enum features
+   * only)
    */
   requestedValues?: Array<string>;
 
   /**
-   * Resource ID to scope the entitlement check to a specific resource
+   * Query param: Resource ID to scope the entitlement check to a specific resource
    */
   resourceId?: 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 Entitlements {

package/src/resources/v1/events/beta/entity-types.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';
 
 export class EntityTypes extends APIResource {
@@ -20,12 +21,20 @@ export class EntityTypes extends APIResource {
    * ```
    */
   list(
-    query: EntityTypeListParams | null | undefined = {},
+    params: EntityTypeListParams | null | undefined = {},
     options?: RequestOptions,
   ): PagePromise<EntityTypeListResponsesMyCursorIDPage, EntityTypeListResponse> {
+    const { 'X-ACCOUNT-ID': xAccountID, 'X-ENVIRONMENT-ID': xEnvironmentID, ...query } = params ?? {};
     return this._client.getAPIList('/api/v1-beta/entity-types', MyCursorIDPage<EntityTypeListResponse>, {
       query,
       ...options,
+      headers: buildHeaders([
+        {
+          ...(xAccountID != null ? { 'X-ACCOUNT-ID': xAccountID } : undefined),
+          ...(xEnvironmentID != null ? { 'X-ENVIRONMENT-ID': xEnvironmentID } : undefined),
+        },
+        options?.headers,
+      ]),
     });
   }
 
@@ -53,8 +62,19 @@ export class EntityTypes extends APIResource {
    *   });
    * ```
    */
-  upsert(body: EntityTypeUpsertParams, options?: RequestOptions): APIPromise<EntityTypeUpsertResponse> {
-    return this._client.put('/api/v1-beta/entity-types', { body, ...options });
+  upsert(params: EntityTypeUpsertParams, options?: RequestOptions): APIPromise<EntityTypeUpsertResponse> {
+    const { 'X-ACCOUNT-ID': xAccountID, 'X-ENVIRONMENT-ID': xEnvironmentID, ...body } = params;
+    return this._client.put('/api/v1-beta/entity-types', {
+      body,
+      ...options,
+      headers: buildHeaders([
+        {
+          ...(xAccountID != null ? { 'X-ACCOUNT-ID': xAccountID } : undefined),
+          ...(xEnvironmentID != null ? { 'X-ENVIRONMENT-ID': xEnvironmentID } : undefined),
+        },
+        options?.headers,
+      ]),
+    });
   }
 }
 
@@ -137,13 +157,39 @@ export namespace EntityTypeUpsertResponse {
   }
 }
 
-export interface EntityTypeListParams extends MyCursorIDPageParams {}
+export interface EntityTypeListParams extends MyCursorIDPageParams {
+  /**
+   * 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 EntityTypeUpsertParams {
   /**
-   * Entity types to upsert (1–100 per request)
+   * Body param: Entity types to upsert (1–100 per request)
    */
   types: Array<EntityTypeUpsertParams.Type>;
+
+  /**
+   * 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 EntityTypeUpsertParams {

package/src/resources/v1/events/events.ts

@@ -12,6 +12,7 @@ import {
   DataExportTriggerSyncResponse,
 } from './data-export/data-export';
 import { APIPromise } from '../../../core/api-promise';
+import { buildHeaders } from '../../../internal/headers';
 import { RequestOptions } from '../../../internal/request-options';
 
 /**
@@ -38,8 +39,19 @@ export class Events extends APIResource {
    * });
    * ```
    */
-  report(body: EventReportParams, options?: RequestOptions): APIPromise<EventReportResponse> {
-    return this._client.post('/api/v1/events', { body, ...options });
+  report(params: EventReportParams, options?: RequestOptions): APIPromise<EventReportResponse> {
+    const { 'X-ACCOUNT-ID': xAccountID, 'X-ENVIRONMENT-ID': xEnvironmentID, ...body } = params;
+    return this._client.post('/api/v1/events', {
+      body,
+      ...options,
+      headers: buildHeaders([
+        {
+          ...(xAccountID != null ? { 'X-ACCOUNT-ID': xAccountID } : undefined),
+          ...(xEnvironmentID != null ? { 'X-ENVIRONMENT-ID': xEnvironmentID } : undefined),
+        },
+        options?.headers,
+      ]),
+    });
   }
 }
 
@@ -56,9 +68,22 @@ export interface EventReportResponse {
 
 export interface EventReportParams {
   /**
-   * A list of usage events to report
+   * Body param: A list of usage events to report
    */
   events: Array<EventReportParams.Event>;
+
+  /**
+   * 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 EventReportParams {