@sentry/api 0.444.0 → 0.446.0

package/dist/api-client/transport.d.ts

@@ -0,0 +1,156 @@
+/**
+ * Authenticated fetch for Sentry API requests, shared by the CLI and MCP.
+ * Standard Web APIs only, so it runs in Node and Cloudflare Workers.
+ *
+ * Per request it sets the Authorization header, refreshes the credential once
+ * after a 401 (any method), times out each attempt, retries through
+ * `retry`, replays request bodies, optionally follows redirects only to
+ * trusted origins, and serves and invalidates cached GETs through an injected
+ * cache. The host supplies credentials, header rules, error classes, logging,
+ * and spans.
+ */
+import { type RetryPolicy } from "./retry.js";
+import type { CacheLookup } from "./response-cache/policy.js";
+type FetchInput = Request | string | URL;
+/** The fields the transport reads; hosts extend it with their own. */
+export type TransportCredential = {
+    token: string;
+    /** Stable hash of the login, for cache scoping; never a raw token. */
+    identity: string;
+};
+export type CredentialProvider<C extends TransportCredential> = {
+    /** The credential for a new request, before any refresh. Cache lookups use it. */
+    current(): C | Promise<C>;
+    /** Called after a cache miss, before the first attempt, to refresh ahead of expiry. */
+    prepare?(credential: C): Promise<C>;
+    /** After a 401: the refreshed credential, or undefined when it cannot refresh. */
+    refresh?(credential: C): Promise<C | undefined>;
+    /** The Authorization value. Throws for a malformed token. */
+    authorization?(credential: C): string;
+};
+/** How the caller reads a successful body; see {@link ApiTransportRequestOptions.responseBody}. */
+export type ResponseBodyMode = "auto" | "buffer" | "stream";
+/** The GET cache, keyed by the host. `CacheLookup` comes from `response-cache`. */
+export type TransportCache = {
+    lookup(request: CachedRequest): Promise<CacheLookup | undefined>;
+    /** Store a successful GET; `response` is a clone the cache may consume. */
+    store(request: CachedRequest, response: Response): Promise<void>;
+    /** Drop entries a successful write to `url` made stale. */
+    invalidate(url: string, identity: string): Promise<void>;
+};
+export type CachedRequest = {
+    url: string;
+    /** For `Vary` matching. */
+    requestHeaders: Record<string, string>;
+    identity: string;
+};
+type TransportLogger = {
+    debug(message: string, ...args: unknown[]): void;
+};
+export type ApiTransportOptions<C extends TransportCredential> = {
+    /**
+     * Without credentials the transport leaves Authorization to the request,
+     * does not refresh, and does not cache, since entries are scoped to the
+     * credential's identity.
+     */
+    credentials?: CredentialProvider<C>;
+    retry: RetryPolicy;
+    /** Per-attempt timeout, or a function of the request URL. Default: none. */
+    timeoutMs?: number | ((url: string) => number);
+    /** Underlying fetch, read on each call. Defaults to `globalThis.fetch`. */
+    fetch?: (input: FetchInput, init?: RequestInit) => Promise<Response>;
+    /** Sent when the request sets no `User-Agent`. */
+    userAgent?: string;
+    /**
+     * Add host headers, such as tracing or proxy headers, before Authorization
+     * is set. Throw to reject the request, for example for an untrusted host.
+     */
+    prepareHeaders?(headers: Headers, request: {
+        input: FetchInput;
+        credential: C;
+    }): void;
+    /** Writes the host knows are safe to replay, such as a catalog of idempotent operations. */
+    isIdempotent?(method: string, url: string): boolean;
+    /** Set to `1` on the request replayed after a credential refresh. */
+    refreshedRequestHeader?: string;
+    /** Which origins may receive the credential when following redirects. */
+    origins?: {
+        trusts(url: URL, credential: C): boolean;
+        /** The error for an untrusted or unusable redirect destination. */
+        reject(destination: string, credential: C): Error;
+    };
+    /** Host error classes. Without them the transport throws its own. */
+    errors?: {
+        /**
+         * The final attempt timed out. `idempotent` is false when a write may
+         * have been applied.
+         */
+        timeout?(info: {
+            timeoutMs: number;
+            idempotent: boolean;
+        }): Error;
+        /** A fetch error to throw at once, without retrying, such as a TLS failure. */
+        fatal?(error: unknown): Error | undefined;
+        /** A 429 that is not retried. Undefined returns the response. */
+        rateLimited?(response: Response, info: {
+            path: string;
+            retryAfterMs: number | undefined;
+        }): Promise<Error | undefined>;
+    };
+    cache?: TransportCache;
+    /**
+     * Whether the current scope skips cache reads, such as a tool call with
+     * `fresh: true`. Hosts back it with request-scoped state like
+     * `AsyncLocalStorage`. The response is still stored, replacing the entry.
+     */
+    fresh?(): boolean;
+    logger?: TransportLogger;
+    /** Wrap each request, including cache lookups, in a host span. */
+    span?(request: {
+        method: string;
+        path: string;
+    }, run: () => Promise<Response>): Promise<Response>;
+};
+export type ApiTransportRequestOptions = {
+    /**
+     * Replaying the request is harmless, so 5xx, timeouts, and network errors
+     * retry for any method. For writes the server dedupes, such as
+     * content-addressed chunk uploads.
+     */
+    idempotent?: boolean;
+    /**
+     * `buffer` reads a successful body within the attempt's timeout and retry
+     * budget; `auto` does so only when it has a `Content-Type`, as the
+     * `@sentry/api` auto parser returns a stream otherwise. Default `stream`.
+     */
+    responseBody?: ResponseBodyMode;
+    /**
+     * Follow redirects manually, checking each destination with `origins`
+     * and recording where the response came from; see
+     * {@link getValidatedResponseSource}. Skips the cache.
+     */
+    validateRedirects?: boolean;
+};
+export type ApiTransport = {
+    request(input: FetchInput, init?: RequestInit, options?: ApiTransportRequestOptions): Promise<Response>;
+};
+/** The request's last attempt hit the transport's own timeout. */
+export declare class ApiTimeoutError extends Error {
+    readonly timeoutMs: number;
+    readonly idempotent: boolean;
+    constructor(timeoutMs: number, idempotent: boolean);
+}
+/** Where a response fetched with `validateRedirects` came from. */
+export type ValidatedResponseSource = {
+    origin: string;
+    identity: string;
+};
+/** The final origin and credential identity of a `validateRedirects` response. */
+export declare function getValidatedResponseSource(response: Response): ValidatedResponseSource | undefined;
+/** Extract the full URL from a fetch input; `String(request)` is not its URL. */
+export declare function extractInputUrl(input: FetchInput): string;
+/** The URL pathname for logs and spans, or the raw input when it does not parse. */
+export declare function extractUrlPath(input: FetchInput): string;
+/** Create a transport; see {@link ApiTransportOptions}. */
+export declare function createApiTransport<C extends TransportCredential>(config: ApiTransportOptions<C>): ApiTransport;
+export {};

package/dist/api-client/validate.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Response validation through the Standard Schema interface, so the shared
+ * client works with any validator that implements it. The MCP passes Zod
+ * schemas and the CLI valibot ones; this module depends on neither.
+ */
+import type { StandardSchemaV1 } from "./standard-schema.js";
+/** A schema the host supplies to check a response body. */
+export type ResponseSchema<Output = unknown> = StandardSchemaV1<unknown, Output>;
+/** A response did not match the schema the caller validated it with. */
+export declare class ApiResponseValidationError extends Error {
+    readonly issues: readonly StandardSchemaV1.Issue[];
+    constructor(issues: readonly StandardSchemaV1.Issue[]);
+}
+/**
+ * Validate `data` with `schema` and return the schema's output.
+ *
+ * Responses are validated synchronously, as every caller does today, so a
+ * schema with async refinements is rejected rather than awaited.
+ *
+ * @throws {ApiResponseValidationError} When `data` does not match
+ */
+export declare function validateResponse<Schema extends StandardSchemaV1>(schema: Schema, data: unknown): StandardSchemaV1.InferOutput<Schema>;

package/dist/client/index.d.ts

@@ -3,6 +3,7 @@ export type { QuerySerializerOptions } from '../core/bodySerializer.gen';
 export { formDataBodySerializer, jsonBodySerializer, urlSearchParamsBodySerializer, } from '../core/bodySerializer.gen';
 export { buildClientParams } from '../core/params.gen';
 export { serializeQueryKeyValue } from '../core/queryKeySerializer.gen';
+export type { ServerSentEventsResult } from '../core/serverSentEvents.gen';
 export { createClient } from './client.gen';
 export type { PreparedClient } from './client.gen';
 export type { Client, ClientOptions, Config, CreateClientConfig, Options, RequestOptions, RequestResult, ResolvedRequestOptions, ResponseStyle, TDataShape, } from './types.gen';

package/dist/client/types.gen.d.ts

@@ -48,7 +48,7 @@ export interface Config<T extends ClientOptions = ClientOptions> extends Omit<Re
 export interface RequestOptions<TData = unknown, TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends Config<{
     responseStyle: TResponseStyle;
     throwOnError: ThrowOnError;
-}>, Pick<ServerSentEventsOptions<TData>, 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
+}>, Pick<ServerSentEventsOptions<TData>, 'onRequest' | 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
     /**
      * Any body that you want to add to your request.
      *
@@ -64,6 +64,7 @@ export interface RequestOptions<TData = unknown, TResponseStyle extends Response
     url: Url;
 }
 export interface ResolvedRequestOptions<TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> {
+    headers: Headers;
     serializedBody?: string;
 }
 export type RequestResult<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle = 'fields'> = Promise<ThrowOnError extends true ? {
@@ -77,7 +78,7 @@ export interface ClientOptions {
     throwOnError?: boolean;
 }
 type MethodFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: (Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) & RequireThrowOnError<ThrowOnError>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
-type SseFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
+type SseFn = <TData = unknown, _TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData>>;
 type RequestFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: (Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'> & Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, 'method'>) & RequireThrowOnError<ThrowOnError>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
 type BuildUrlFn = <TData extends {
     body?: unknown;

package/dist/client/utils.gen.d.ts

@@ -1,17 +1,19 @@
 import type { QuerySerializerOptions } from '../core/bodySerializer.gen';
 import type { Client, ClientOptions, Config, RequestOptions } from './types.gen';
-export declare const createQuerySerializer: <T = unknown>({ parameters, ...args }?: QuerySerializerOptions) => (queryParams: T) => string;
+export declare const createQuerySerializer: <T = unknown>({ parameters, ...args }?: QuerySerializerOptions) => ((queryParams: T) => string);
 /**
  * Infers parseAs value from provided Content-Type header.
  */
 export declare const getParseAs: (contentType: string | null) => Exclude<Config["parseAs"], "auto">;
-export declare const setAuthParams: ({ security, ...options }: Pick<Required<RequestOptions>, "security"> & Pick<RequestOptions, "auth" | "query"> & {
+export declare function setAuthParams(options: Pick<RequestOptions, 'auth' | 'query' | 'security'> & {
     headers: Headers;
-}) => Promise<void>;
+}): Promise<void>;
 export declare const buildUrl: Client['buildUrl'];
 export declare const mergeConfigs: (a: Config, b: Config) => Config;
 export declare const mergeHeaders: (...headers: Array<Required<Config>["headers"] | undefined>) => Headers;
-type ErrInterceptor<Err, Res, Req, Options> = (error: Err, response: Res | undefined, request: Req, options: Options) => Err | Promise<Err>;
+type ErrInterceptor<Err, Res, Req, Options> = (error: Err, 
+/** response may be undefined due to a network error where no response object is produced */
+response: Res | undefined, request: Req, options: Options) => Err | Promise<Err>;
 type ReqInterceptor<Req, Options> = (request: Req, options: Options) => Req | Promise<Req>;
 type ResInterceptor<Res, Req, Options> = (response: Res, request: Req, options: Options) => Res | Promise<Res>;
 declare class Interceptors<Interceptor> {

package/dist/core/auth.gen.d.ts

@@ -6,6 +6,13 @@ export interface Auth {
      * @default 'header'
      */
     in?: 'header' | 'query' | 'cookie';
+    /**
+     * A unique identifier for the security scheme.
+     *
+     * Defined only when there are multiple security schemes whose `Auth`
+     * shape would otherwise be identical.
+     */
+    key?: string;
     /**
      * Header or query parameter name.
      *

package/dist/core/bodySerializer.gen.d.ts

@@ -1,6 +1,6 @@
 import type { ArrayStyle, ObjectStyle, SerializerOptions } from './pathSerializer.gen';
 export type QuerySerializer = (query: Record<string, unknown>) => string;
-export type BodySerializer = (body: any) => any;
+export type BodySerializer = (body: unknown) => unknown;
 type QuerySerializerOptionsObject = {
     allowReserved?: boolean;
     array?: Partial<SerializerOptions<ArrayStyle>>;
@@ -14,12 +14,12 @@ export type QuerySerializerOptions = QuerySerializerOptionsObject & {
     parameters?: Record<string, QuerySerializerOptionsObject>;
 };
 export declare const formDataBodySerializer: {
-    bodySerializer: <T extends Record<string, any> | Array<Record<string, any>>>(body: T) => FormData;
+    bodySerializer: (body: unknown) => FormData;
 };
 export declare const jsonBodySerializer: {
-    bodySerializer: <T>(body: T) => string;
+    bodySerializer: (body: unknown) => string;
 };
 export declare const urlSearchParamsBodySerializer: {
-    bodySerializer: <T extends Record<string, any> | Array<Record<string, any>>>(body: T) => string;
+    bodySerializer: (body: unknown) => string;
 };
 export {};

package/dist/core/params.gen.d.ts

@@ -39,5 +39,5 @@ interface Params {
     path: Record<string, unknown>;
     query: Record<string, unknown>;
 }
-export declare const buildClientParams: (args: ReadonlyArray<unknown>, fields: FieldsConfig) => Params;
+export declare function buildClientParams(args: ReadonlyArray<unknown>, fields: FieldsConfig): Params;
 export {};

package/dist/core/queryKeySerializer.gen.d.ts

@@ -7,7 +7,7 @@ export type JsonValue = null | string | number | boolean | JsonValue[] | {
 /**
  * Replacer that converts non-JSON values (bigint, Date, etc.) to safe substitutes.
  */
-export declare const queryKeyJsonReplacer: (_key: string, value: unknown) => {} | null | undefined;
+export declare const queryKeyJsonReplacer: (_key: string, value: unknown) => unknown | undefined;
 /**
  * Safely stringifies a value and parses it back into a JsonValue.
  */

package/dist/core/serverSentEvents.gen.d.ts

@@ -68,4 +68,4 @@ export interface StreamEvent<TData = unknown> {
 export type ServerSentEventsResult<TData = unknown, TReturn = void, TNext = unknown> = {
     stream: AsyncGenerator<TData extends Record<string, unknown> ? TData[keyof TData] : TData, TReturn, TNext>;
 };
-export declare const createSseClient: <TData = unknown>({ onRequest, onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }: ServerSentEventsOptions) => ServerSentEventsResult<TData>;
+export declare function createSseClient<TData = unknown>({ onRequest, onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }: ServerSentEventsOptions): ServerSentEventsResult<TData>;

package/dist/core/types.gen.d.ts

@@ -61,7 +61,7 @@ export interface Config {
     requestValidator?: (data: unknown) => Promise<unknown>;
     /**
      * A function transforming response data before it's returned. This is useful
-     * for post-processing data, e.g. converting ISO strings into Date objects.
+     * for post-processing data, e.g., converting ISO strings into Date objects.
      */
     responseTransformer?: (data: unknown) => Promise<unknown>;
     /**

package/dist/index.js

@@ -75,7 +75,7 @@ var callWithTypedErrors = async (call, documentedStatuses) => {
 };
 
 // src/core/serverSentEvents.gen.ts
-var createSseClient = ({
+function createSseClient({
   onRequest,
   onSseError,
   onSseEvent,
@@ -87,7 +87,7 @@ var createSseClient = ({
   sseSleepFn,
   url,
   ...options
-}) => {
+}) {
   let lastEventId;
   const sleep = sseSleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
   const createStream = async function* () {
@@ -134,8 +134,7 @@ var createSseClient = ({
             if (done)
               break;
             buffer += value;
-            buffer = buffer.replace(/\r\n/g, `
-`).replace(/\r/g, `
+            buffer = buffer.replace(/\r\n?/g, `
 `);
             const chunks = buffer.split(`
 
@@ -208,7 +207,7 @@ var createSseClient = ({
   };
   const stream = createStream();
   return { stream };
-};
+}
 
 // src/core/pathSerializer.gen.ts
 var separatorArrayExplode = (style) => {
@@ -527,11 +526,8 @@ var checkForExistence = (options, name) => {
   }
   return false;
 };
-var setAuthParams = async ({
-  security,
-  ...options
-}) => {
-  for (const auth of security) {
+async function setAuthParams(options) {
+  for (const auth of options.security ?? []) {
     if (checkForExistence(options, auth.name)) {
       continue;
     }
@@ -556,7 +552,7 @@ var setAuthParams = async ({
         break;
     }
   }
-};
+}
 var buildUrl = (options) => getUrl({
   baseUrl: options.baseUrl,
   path: options.path,
@@ -688,10 +684,7 @@ var createClient = (config = {}) => {
       serializedBody: undefined
     };
     if (opts.security) {
-      await setAuthParams({
-        ...opts,
-        security: opts.security
-      });
+      await setAuthParams(opts);
     }
     if (opts.requestValidator) {
       await opts.requestValidator(opts);
@@ -702,8 +695,9 @@ var createClient = (config = {}) => {
     if (opts.body === undefined || opts.serializedBody === "") {
       opts.headers.delete("Content-Type");
     }
-    const url = buildUrl(opts);
-    return { opts, url };
+    const resolvedOpts = opts;
+    const url = buildUrl(resolvedOpts);
+    return { opts: resolvedOpts, url };
   };
   const prepare = async (options) => {
     const { opts, url } = await beforeRequest(options);
@@ -731,13 +725,11 @@ var createClient = (config = {}) => {
     } catch (error) {
       let finalError2 = error;
       for (const fn of interceptors.error.fns) {
-        if (fn) {
+        if (fn)
           finalError2 = await fn(finalError2, undefined, request2, opts);
-        }
       }
-      if (opts.throwOnError) {
+      if (opts.throwOnError)
         throw finalError2;
-      }
       return { error: finalError2, request: request2, response: undefined };
     }
     for (const fn of interceptors.response.fns) {
@@ -805,13 +797,11 @@ var createClient = (config = {}) => {
     } catch {}
     let finalError = new SentryApiError(response.status, body, response, false, undefined, { request: request2, rawBody: textError });
     for (const fn of interceptors.error.fns) {
-      if (fn) {
+      if (fn)
         finalError = await fn(finalError, response, request2, opts);
-      }
     }
-    if (opts.throwOnError) {
+    if (opts.throwOnError)
       throw finalError;
-    }
     return { error: finalError, ...result };
   };
   const makeMethodFn = (method) => (options) => request({ ...options, method });
@@ -820,7 +810,6 @@ var createClient = (config = {}) => {
     return createSseClient({
       ...opts,
       body: opts.body,
-      headers: opts.headers,
       method,
       onRequest: async (url2, init) => {
         let request2 = new Request(url2, init);
@@ -835,8 +824,9 @@ var createClient = (config = {}) => {
       url
     });
   };
+  const _buildUrl = (options) => buildUrl({ ..._config, ...options });
   return {
-    buildUrl,
+    buildUrl: _buildUrl,
     connect: makeMethodFn("CONNECT"),
     delete: makeMethodFn("DELETE"),
     get: makeMethodFn("GET"),

package/dist/operations.js

@@ -3504,24 +3504,24 @@ Requires profiling to be enabled for the organization.`,
         description: "The end of the period of time for the query, expected in ISO-8601 format. For example, `2001-12-14T12:34:56.7890`.",
         type: "string"
       },
+      {
+        name: "fingerprint",
+        required: false,
+        description: "A UInt32 function fingerprint. Only valid when `dataSource=functions`.",
+        type: "integer"
+      },
       {
         name: "dataSource",
         required: false,
-        description: "Source dataset to build the flamegraph from. Defaults to `functions` when `fingerprint` is set and `transactions` otherwise.",
+        description: "Source dataset to build the flamegraph from. Defaults to `functions` when `fingerprint` is set and `transactions` otherwise.\n\n* `transactions`\n* `profiles`\n* `functions`\n* `spans`",
         type: "string",
         enum: [
-          "functions",
+          "transactions",
           "profiles",
-          "spans",
-          "transactions"
+          "functions",
+          "spans"
         ]
       },
-      {
-        name: "fingerprint",
-        required: false,
-        description: "A UInt32 function fingerprint. Only valid when `dataSource=functions`.",
-        type: "integer"
-      },
       {
         name: "query",
         required: false,
@@ -5891,16 +5891,6 @@ time range.`,
         description: "The end of the period of time for the query, expected in ISO-8601 format. For example, `2001-12-14T12:34:56.7890`.",
         type: "string"
       },
-      {
-        name: "itemType",
-        required: false,
-        description: "The trace item dataset to compute statistics for. Defaults to `spans`.",
-        type: "string",
-        enum: [
-          "occurrences",
-          "spans"
-        ]
-      },
       {
         name: "query",
         required: false,
@@ -5919,6 +5909,16 @@ time range.`,
         description: "Maximum number of trace items to sample when computing statistics. Defaults to `1000`, which is also the maximum.",
         type: "integer"
       },
+      {
+        name: "itemType",
+        required: false,
+        description: "The trace item dataset to compute statistics for. Defaults to `spans`.\n\n* `spans`\n* `occurrences`",
+        type: "string",
+        enum: [
+          "spans",
+          "occurrences"
+        ]
+      },
       {
         name: "cursor",
         required: false,
@@ -7556,8 +7556,12 @@ whether an update is available.`,
       {
         name: "platform",
         required: true,
-        description: 'Platform: "apple" or "android".',
-        type: "string"
+        description: 'Platform: "apple" or "android".\n\n* `apple` - Apple\n* `android` - Android',
+        type: "string",
+        enum: [
+          "apple",
+          "android"
+        ]
       },
       {
         name: "buildVersion",

package/dist/query-enums.gen.d.ts

@@ -1,4 +1,4 @@
-import type { DeleteOrganizationIssuesData, GetOrganizationIssueAutofixStateData, GetOrganizationIssueData, GetOrganizationIssueEventData, GetOrganizationIssueIntegrationData, GetOrganizationProfilingFlamegraphData, GetOrganizationReleaseData, GetOrganizationReplayCountData, GetOrganizationReplayData, GetOrganizationStatsSummaryData, GetOrganizationTraceData, GetOrganizationTraceMetaData, GetProjectEventData, ListOrganizationDashboardsData, ListOrganizationEnvironmentsData, ListOrganizationEventsData, ListOrganizationEventsDroppedData, ListOrganizationEventsTimeseriesData, ListOrganizationFlagLogsData, ListOrganizationIssueTagValuesData, ListOrganizationIssueViewsData, ListOrganizationIssuesData, ListOrganizationProjectKeysData, ListOrganizationReplaysData, ListOrganizationReposData, ListOrganizationStatsV2Data, ListOrganizationTagsData, ListOrganizationTraceItemAttributesData, ListOrganizationTraceItemsStatsData, ListOrganizationTraceMetricsData, ListProjectCodeOwnersData, ListProjectEnvironmentsData, ListProjectIssuesData, ListProjectSeerRepositoriesData, ListProjectStatsData, ResolveOrganizationShortIdData, RetrieveOrganizationAiConversationData, UpdateOrganizationIssuesData } from './types.gen';
+import type { DeleteOrganizationIssuesData, GetOrganizationIssueAutofixStateData, GetOrganizationIssueData, GetOrganizationIssueEventData, GetOrganizationIssueIntegrationData, GetOrganizationProfilingFlamegraphData, GetOrganizationReleaseData, GetOrganizationReplayCountData, GetOrganizationReplayData, GetOrganizationStatsSummaryData, GetOrganizationTraceData, GetOrganizationTraceMetaData, GetProjectEventData, GetProjectInstallableBuildLatestData, ListOrganizationDashboardsData, ListOrganizationEnvironmentsData, ListOrganizationEventsData, ListOrganizationEventsDroppedData, ListOrganizationEventsTimeseriesData, ListOrganizationFlagLogsData, ListOrganizationIssueTagValuesData, ListOrganizationIssueViewsData, ListOrganizationIssuesData, ListOrganizationProjectKeysData, ListOrganizationReplaysData, ListOrganizationReposData, ListOrganizationStatsV2Data, ListOrganizationTagsData, ListOrganizationTraceItemAttributesData, ListOrganizationTraceItemsStatsData, ListOrganizationTraceMetricsData, ListProjectCodeOwnersData, ListProjectEnvironmentsData, ListProjectIssuesData, ListProjectSeerRepositoriesData, ListProjectStatsData, ResolveOrganizationShortIdData, RetrieveOrganizationAiConversationData, UpdateOrganizationIssuesData } from './types.gen';
 /** A value of the `sort` query parameter of `deleteOrganizationIssues`. */
 export type DeleteOrganizationIssuesQuerySort = NonNullable<NonNullable<DeleteOrganizationIssuesData['query']>["sort"]>;
 /** A value of the `llmFormat` query parameter of `getOrganizationIssueAutofixState`. */
@@ -41,6 +41,8 @@ export type GetOrganizationTraceMetaQueryIncludeUptime = NonNullable<NonNullable
 export type GetOrganizationTraceQueryIncludeUptime = NonNullable<NonNullable<GetOrganizationTraceData['query']>["include_uptime"]>;
 /** A value of the `collapse` query parameter of `getProjectEvent`. */
 export type GetProjectEventQueryCollapse = NonNullable<NonNullable<GetProjectEventData['query']>["collapse"]>[number];
+/** A value of the `platform` query parameter of `getProjectInstallableBuildLatest`. */
+export type GetProjectInstallableBuildLatestQueryPlatform = NonNullable<NonNullable<GetProjectInstallableBuildLatestData['query']>["platform"]>;
 /** A value of the `filter` query parameter of `listOrganizationDashboards`. */
 export type ListOrganizationDashboardsQueryFilter = NonNullable<NonNullable<ListOrganizationDashboardsData['query']>["filter"]>[number];
 /** A value of the `pin` query parameter of `listOrganizationDashboards`. */