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

package/src/resources/v1-beta/customers/assignments.ts

@@ -0,0 +1,328 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+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';
+
+export class Assignments extends APIResource {
+  /**
+   * Returns a cursor-paginated list of capability assignments for the given
+   * customer. An assignment ties an entity to a capability with a usage limit and
+   * reset cadence.
+   *
+   * @example
+   * ```ts
+   * // Automatically fetches more pages as needed.
+   * for await (const assignmentListResponse of client.v1Beta.customers.assignments.list(
+   *   'id',
+   * )) {
+   *   // ...
+   * }
+   * ```
+   */
+  list(
+    id: string,
+    params: AssignmentListParams | null | undefined = {},
+    options?: RequestOptions,
+  ): PagePromise<AssignmentListResponsesMyCursorIDPage, AssignmentListResponse> {
+    const { 'X-ACCOUNT-ID': xAccountID, 'X-ENVIRONMENT-ID': xEnvironmentID, ...query } = params ?? {};
+    return this._client.getAPIList(
+      path`/api/v1-beta/customers/${id}/assignments`,
+      MyCursorIDPage<AssignmentListResponse>,
+      {
+        query,
+        ...options,
+        headers: buildHeaders([
+          {
+            ...(xAccountID != null ? { 'X-ACCOUNT-ID': xAccountID } : undefined),
+            ...(xEnvironmentID != null ? { 'X-ENVIRONMENT-ID': xEnvironmentID } : undefined),
+          },
+          options?.headers,
+        ]),
+      },
+    );
+  }
+
+  /**
+   * Batched create-or-update of capability assignments. Existing assignments matched
+   * by (entityId, capabilityId) are updated; new pairs are created. On update,
+   * omitted fields (usageLimit, cadence) are preserved; on create both are required
+   * by the governance service.
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.v1Beta.customers.assignments.upsert('id', {
+   *     assignments: [
+   *       {
+   *         entityId: 'workspace-001',
+   *         featureId: 'compute-minutes',
+   *         usageLimit: 1000,
+   *         cadence: 'MONTH',
+   *       },
+   *       {
+   *         entityId: 'workspace-002',
+   *         currencyId: 'cred-type-tokens',
+   *         usageLimit: 2000,
+   *         cadence: 'MONTH',
+   *         parentId: 'workspace-001',
+   *         scopeEntityIds: ['user-1'],
+   *       },
+   *     ],
+   *   });
+   * ```
+   */
+  upsert(
+    id: string,
+    params: AssignmentUpsertParams,
+    options?: RequestOptions,
+  ): APIPromise<AssignmentUpsertResponse> {
+    const { 'X-ACCOUNT-ID': xAccountID, 'X-ENVIRONMENT-ID': xEnvironmentID, ...body } = params;
+    return this._client.put(path`/api/v1-beta/customers/${id}/assignments`, {
+      body,
+      ...options,
+      headers: buildHeaders([
+        {
+          ...(xAccountID != null ? { 'X-ACCOUNT-ID': xAccountID } : undefined),
+          ...(xEnvironmentID != null ? { 'X-ENVIRONMENT-ID': xEnvironmentID } : undefined),
+        },
+        options?.headers,
+      ]),
+    });
+  }
+}
+
+export type AssignmentListResponsesMyCursorIDPage = MyCursorIDPage<AssignmentListResponse>;
+
+/**
+ * A capability assignment for an entity belonging to a customer. Defines how much
+ * of the capability the entity may consume (`usageLimit`) and how often the
+ * counter resets (`cadence`).
+ */
+export interface AssignmentListResponse {
+  /**
+   * Synthetic UUID identifier — also the cursor anchor for paginated lists
+   */
+  id: string;
+
+  /**
+   * Usage-reset cadence. Currently only `MONTH` is supported
+   */
+  cadence: 'MONTH';
+
+  /**
+   * Timestamp of when the record was created
+   */
+  createdAt: string;
+
+  /**
+   * The entity refId this assignment is attached to
+   */
+  entityId: string;
+
+  /**
+   * Parent entity refId in the hierarchy, or `null` for a root.
+   */
+  parentId: string | null;
+
+  /**
+   * Dimension-scoped sub-budget key: the set of entity refIds this budget applies
+   * to. Empty is the node-wide budget that always matches; a non-empty set only
+   * applies when every listed entity is present in the resolved set
+   * (order-insensitive).
+   */
+  scopeEntityIds: Array<string>;
+
+  /**
+   * Timestamp of when the record was last updated
+   */
+  updatedAt: string;
+
+  /**
+   * Maximum usage allowed within one cadence window
+   */
+  usageLimit: number;
+
+  /**
+   * Currency refId this assignment grants (present for credit capabilities).
+   */
+  currencyId?: string;
+
+  /**
+   * Feature refId this assignment grants (present for feature capabilities).
+   */
+  featureId?: string;
+}
+
+/**
+ * Assignments after upsert.
+ */
+export interface AssignmentUpsertResponse {
+  data: Array<AssignmentUpsertResponse.Data>;
+}
+
+export namespace AssignmentUpsertResponse {
+  /**
+   * A capability assignment for an entity belonging to a customer. Defines how much
+   * of the capability the entity may consume (`usageLimit`) and how often the
+   * counter resets (`cadence`).
+   */
+  export interface Data {
+    /**
+     * Synthetic UUID identifier — also the cursor anchor for paginated lists
+     */
+    id: string;
+
+    /**
+     * Usage-reset cadence. Currently only `MONTH` is supported
+     */
+    cadence: 'MONTH';
+
+    /**
+     * Timestamp of when the record was created
+     */
+    createdAt: string;
+
+    /**
+     * The entity refId this assignment is attached to
+     */
+    entityId: string;
+
+    /**
+     * Parent entity refId in the hierarchy, or `null` for a root.
+     */
+    parentId: string | null;
+
+    /**
+     * Dimension-scoped sub-budget key: the set of entity refIds this budget applies
+     * to. Empty is the node-wide budget that always matches; a non-empty set only
+     * applies when every listed entity is present in the resolved set
+     * (order-insensitive).
+     */
+    scopeEntityIds: Array<string>;
+
+    /**
+     * Timestamp of when the record was last updated
+     */
+    updatedAt: string;
+
+    /**
+     * Maximum usage allowed within one cadence window
+     */
+    usageLimit: number;
+
+    /**
+     * Currency refId this assignment grants (present for credit capabilities).
+     */
+    currencyId?: string;
+
+    /**
+     * Feature refId this assignment grants (present for feature capabilities).
+     */
+    featureId?: string;
+  }
+}
+
+export interface AssignmentListParams extends MyCursorIDPageParams {
+  /**
+   * Query param: Filter assignments to a specific capability refId
+   */
+  capabilityId?: string;
+
+  /**
+   * Query param: Filter assignments to a specific entity refId
+   */
+  entityId?: 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 AssignmentUpsertParams {
+  /**
+   * Body param: Assignments to upsert (1–100 per request)
+   */
+  assignments: Array<AssignmentUpsertParams.Assignment>;
+
+  /**
+   * 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 AssignmentUpsertParams {
+  /**
+   * A single assignment to create or update. Identify the capability with exactly
+   * one of `featureId` or `currencyId`. The natural key is the
+   * `(entityId, capability, scopeEntityIds)` triple. On create both `usageLimit` and
+   * `cadence` are required; on update they may be omitted individually to preserve
+   * the existing value.
+   */
+  export interface Assignment {
+    /**
+     * The entity refId this assignment is attached to
+     */
+    entityId: string;
+
+    /**
+     * Usage-reset cadence (required on create). Currently only `MONTH` is supported
+     */
+    cadence?: 'MONTH';
+
+    /**
+     * Currency refId this assignment grants (credit budgets). Mutually exclusive with
+     * `featureId`.
+     */
+    currencyId?: string;
+
+    /**
+     * Feature refId this assignment grants. Mutually exclusive with `currencyId`.
+     */
+    featureId?: string;
+
+    /**
+     * Parent entity refId in the hierarchy. Omit to leave the current parent untouched
+     * (a new node defaults to a root); `null` detaches to a root; a refId sets or
+     * changes the parent. Reparenting an existing node is leaf-only.
+     */
+    parentId?: string | null;
+
+    scopeEntityIds?: Array<string>;
+
+    /**
+     * Maximum usage allowed within one cadence window (required on create)
+     */
+    usageLimit?: number;
+  }
+}
+
+export declare namespace Assignments {
+  export {
+    type AssignmentListResponse as AssignmentListResponse,
+    type AssignmentUpsertResponse as AssignmentUpsertResponse,
+    type AssignmentListResponsesMyCursorIDPage as AssignmentListResponsesMyCursorIDPage,
+    type AssignmentListParams as AssignmentListParams,
+    type AssignmentUpsertParams as AssignmentUpsertParams,
+  };
+}

package/src/resources/{v1/events/beta → v1-beta}/customers/customers.ts

@@ -1,6 +1,6 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { APIResource } from '../../../../../core/resource';
+import { APIResource } from '../../../core/resource';
 import * as AssignmentsAPI from './assignments';
 import {
   AssignmentListParams,

package/src/resources/{v1/events/beta → v1-beta}/customers/entities.ts

@@ -1,10 +1,11 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { APIResource } from '../../../../../core/resource';
-import { APIPromise } from '../../../../../core/api-promise';
-import { MyCursorIDPage, type MyCursorIDPageParams, PagePromise } from '../../../../../core/pagination';
-import { RequestOptions } from '../../../../../internal/request-options';
-import { path } from '../../../../../internal/utils/path';
+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';
 
 export class Entities extends APIResource {
   /**
@@ -13,10 +14,9 @@ export class Entities extends APIResource {
    * @example
    * ```ts
    * const entity =
-   *   await client.v1.events.beta.customers.entities.retrieve(
-   *     'x',
-   *     { id: 'id' },
-   *   );
+   *   await client.v1Beta.customers.entities.retrieve('x', {
+   *     id: 'id',
+   *   });
    * ```
    */
   retrieve(
@@ -24,8 +24,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,
+      ]),
+    });
   }
 
   /**
@@ -34,7 +43,7 @@ export class Entities extends APIResource {
    * @example
    * ```ts
    * // Automatically fetches more pages as needed.
-   * for await (const entityListResponse of client.v1.events.beta.customers.entities.list(
+   * for await (const entityListResponse of client.v1Beta.customers.entities.list(
    *   'id',
    * )) {
    *   // ...
@@ -43,13 +52,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,
+        ]),
+      },
     );
   }
 
@@ -59,18 +79,28 @@ export class Entities extends APIResource {
    * @example
    * ```ts
    * const response =
-   *   await client.v1.events.beta.customers.entities.archive(
-   *     'id',
-   *     { ids: ['user-7f3a0c1d', 'user-c4d1b2e9'] },
-   *   );
+   *   await client.v1Beta.customers.entities.archive('id', {
+   *     ids: ['user-7f3a0c1d', 'user-c4d1b2e9'],
+   *   });
    * ```
    */
   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,
+      ]),
+    });
   }
 
   /**
@@ -79,18 +109,28 @@ export class Entities extends APIResource {
    * @example
    * ```ts
    * const response =
-   *   await client.v1.events.beta.customers.entities.unarchive(
-   *     'id',
-   *     { ids: ['user-7f3a0c1d', 'user-c4d1b2e9'] },
-   *   );
+   *   await client.v1Beta.customers.entities.unarchive('id', {
+   *     ids: ['user-7f3a0c1d', 'user-c4d1b2e9'],
+   *   });
    * ```
    */
   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,
+      ]),
+    });
   }
 
   /**
@@ -100,30 +140,35 @@ export class Entities extends APIResource {
    * @example
    * ```ts
    * const response =
-   *   await client.v1.events.beta.customers.entities.upsert(
-   *     'id',
-   *     {
-   *       entities: [
-   *         {
-   *           id: 'user-7f3a0c1d',
-   *           typeRefId: 'user',
-   *           metadata: {
-   *             email: 'jane@acme.com',
-   *             role: 'admin',
-   *           },
-   *         },
-   *         {
-   *           id: 'user-c4d1b2e9',
-   *           typeRefId: 'user',
-   *           metadata: { email: 'john@acme.com' },
-   *         },
-   *       ],
-   *     },
-   *   );
+   *   await client.v1Beta.customers.entities.upsert('id', {
+   *     entities: [
+   *       {
+   *         id: 'user-7f3a0c1d',
+   *         typeRefId: 'user',
+   *         metadata: { email: 'jane@acme.com', role: 'admin' },
+   *       },
+   *       {
+   *         id: 'user-c4d1b2e9',
+   *         typeRefId: 'user',
+   *         metadata: { email: 'john@acme.com' },
+   *       },
+   *     ],
+   *   });
    * ```
    */
-  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 +346,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 {