@avallon-labs/sdk 54.3.0 → 54.4.0-staging.1249

package/dist/index.d.ts

@@ -13843,9 +13843,9 @@ type WorkerListToolsParams = {
     sort_order?: WorkerListToolsSortOrder;
 };
 
-type AwaitedInput$v<T> = PromiseLike<T> | T;
-type Awaited$v<O> = O extends AwaitedInput$v<infer T> ? T : never;
-type SecondParameter$v<T extends (...args: never) => unknown> = Parameters<T>[1];
+type AwaitedInput$u<T> = PromiseLike<T> | T;
+type Awaited$u<O> = O extends AwaitedInput$u<infer T> ? T : never;
+type SecondParameter$u<T extends (...args: never) => unknown> = Parameters<T>[1];
 declare const getGetAccessUrl: (entityType: AccessEntityType, entityId: string) => string;
 /**
  * List who an entity is shared with. Admins see every entity through their role, whether or not they are listed. Requires `workers:write` on a worker.
@@ -13853,16 +13853,16 @@ declare const getGetAccessUrl: (entityType: AccessEntityType, entityId: string)
  */
 declare const getAccess: (entityType: AccessEntityType, entityId: string, options?: Parameters<typeof customFetch>[1]) => Promise<GetAccessEnvelope>;
 declare const getGetAccessKey: (entityType: AccessEntityType, entityId: string) => readonly [`/v1/access/worker/${string}`];
-type GetAccessQueryResult = NonNullable<Awaited$v<ReturnType<typeof getAccess>>>;
+type GetAccessQueryResult = NonNullable<Awaited$u<ReturnType<typeof getAccess>>>;
 /**
  * @summary Get access
  */
 declare const useGetAccess: <TError = ErrorType<ErrorResponse>>(entityType: AccessEntityType, entityId: string, options?: {
-    swr?: SWRConfiguration<Awaited$v<ReturnType<typeof getAccess>>, TError> & {
+    swr?: SWRConfiguration<Awaited$u<ReturnType<typeof getAccess>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$v<typeof customFetch>;
+    request?: SecondParameter$u<typeof customFetch>;
 }) => {
     data: GetAccessEnvelope | undefined;
     error: TError | undefined;
@@ -13877,19 +13877,19 @@ declare const getUpdateAccessUrl: (entityType: AccessEntityType, entityId: strin
  * @summary Update access
  */
 declare const updateAccess: (entityType: AccessEntityType, entityId: string, updateAccessBody?: UpdateAccessBody, options?: Parameters<typeof customFetch>[1]) => Promise<UpdateAccessEnvelope>;
-declare const getUpdateAccessMutationFetcher: (entityType: AccessEntityType, entityId: string, options?: SecondParameter$v<typeof customFetch>) => (_: Key, { arg }: {
+declare const getUpdateAccessMutationFetcher: (entityType: AccessEntityType, entityId: string, options?: SecondParameter$u<typeof customFetch>) => (_: Key, { arg }: {
     arg: UpdateAccessBody | undefined;
 }) => Promise<UpdateAccessEnvelope>;
 declare const getUpdateAccessMutationKey: (entityType: AccessEntityType, entityId: string) => readonly [`/v1/access/worker/${string}`];
-type UpdateAccessMutationResult = NonNullable<Awaited$v<ReturnType<typeof updateAccess>>>;
+type UpdateAccessMutationResult = NonNullable<Awaited$u<ReturnType<typeof updateAccess>>>;
 /**
  * @summary Update access
  */
 declare const useUpdateAccess: <TError = ErrorType<ErrorResponse>>(entityType: AccessEntityType, entityId: string, options?: {
-    swr?: SWRMutationConfiguration<Awaited$v<ReturnType<typeof updateAccess>>, TError, Key, UpdateAccessBody | undefined, Awaited$v<ReturnType<typeof updateAccess>>> & {
+    swr?: SWRMutationConfiguration<Awaited$u<ReturnType<typeof updateAccess>>, TError, Key, UpdateAccessBody | undefined, Awaited$u<ReturnType<typeof updateAccess>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$v<typeof customFetch>;
+    request?: SecondParameter$u<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<UpdateAccessEnvelope, TError, string | readonly [`/v1/access/worker/${string}`], UpdateAccessBody | undefined>;
@@ -13905,16 +13905,16 @@ declare const getGetMyAccessUrl: (entityType: AccessEntityType, entityId: string
  */
 declare const getMyAccess: (entityType: AccessEntityType, entityId: string, options?: Parameters<typeof customFetch>[1]) => Promise<GetMyAccessEnvelope>;
 declare const getGetMyAccessKey: (entityType: AccessEntityType, entityId: string) => readonly [`/v1/access/worker/${string}/me`];
-type GetMyAccessQueryResult = NonNullable<Awaited$v<ReturnType<typeof getMyAccess>>>;
+type GetMyAccessQueryResult = NonNullable<Awaited$u<ReturnType<typeof getMyAccess>>>;
 /**
  * @summary Get my access
  */
 declare const useGetMyAccess: <TError = ErrorType<ErrorResponse>>(entityType: AccessEntityType, entityId: string, options?: {
-    swr?: SWRConfiguration<Awaited$v<ReturnType<typeof getMyAccess>>, TError> & {
+    swr?: SWRConfiguration<Awaited$u<ReturnType<typeof getMyAccess>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$v<typeof customFetch>;
+    request?: SecondParameter$u<typeof customFetch>;
 }) => {
     data: GetMyAccessEnvelope | undefined;
     error: TError | undefined;
@@ -13924,9 +13924,9 @@ declare const useGetMyAccess: <TError = ErrorType<ErrorResponse>>(entityType: Ac
     swrKey: string | false | readonly [any, ...unknown[]] | Record<any, any> | (() => swr.Arguments);
 };
 
-type AwaitedInput$u<T> = PromiseLike<T> | T;
-type Awaited$u<O> = O extends AwaitedInput$u<infer T> ? T : never;
-type SecondParameter$u<T extends (...args: never) => unknown> = Parameters<T>[1];
+type AwaitedInput$t<T> = PromiseLike<T> | T;
+type Awaited$t<O> = O extends AwaitedInput$t<infer T> ? T : never;
+type SecondParameter$t<T extends (...args: never) => unknown> = Parameters<T>[1];
 declare const getGetAnalyticsTimeSeriesUrl: (params: GetAnalyticsTimeSeriesParams) => string;
 /**
  * Retrieve a tenant-scoped time series for a single metric.
@@ -13944,16 +13944,16 @@ declare const getGetAnalyticsTimeSeriesUrl: (params: GetAnalyticsTimeSeriesParam
  */
 declare const getAnalyticsTimeSeries: (params: GetAnalyticsTimeSeriesParams, options?: Parameters<typeof customFetch>[1]) => Promise<GetAnalyticsTimeSeriesEnvelope>;
 declare const getGetAnalyticsTimeSeriesKey: (params: GetAnalyticsTimeSeriesParams) => readonly ["/v1/analytics/timeseries", ...GetAnalyticsTimeSeriesParams[]];
-type GetAnalyticsTimeSeriesQueryResult = NonNullable<Awaited$u<ReturnType<typeof getAnalyticsTimeSeries>>>;
+type GetAnalyticsTimeSeriesQueryResult = NonNullable<Awaited$t<ReturnType<typeof getAnalyticsTimeSeries>>>;
 /**
  * @summary Get analytics time series
  */
 declare const useGetAnalyticsTimeSeries: <TError = ErrorType<ErrorResponse>>(params: GetAnalyticsTimeSeriesParams, options?: {
-    swr?: SWRConfiguration<Awaited$u<ReturnType<typeof getAnalyticsTimeSeries>>, TError> & {
+    swr?: SWRConfiguration<Awaited$t<ReturnType<typeof getAnalyticsTimeSeries>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$u<typeof customFetch>;
+    request?: SecondParameter$t<typeof customFetch>;
 }) => {
     data: GetAnalyticsTimeSeriesEnvelope | undefined;
     error: TError | undefined;
@@ -13963,9 +13963,9 @@ declare const useGetAnalyticsTimeSeries: <TError = ErrorType<ErrorResponse>>(par
     swrKey: string | false | readonly [any, ...unknown[]] | Record<any, any> | (() => swr.Arguments);
 };
 
-type AwaitedInput$t<T> = PromiseLike<T> | T;
-type Awaited$t<O> = O extends AwaitedInput$t<infer T> ? T : never;
-type SecondParameter$t<T extends (...args: never) => unknown> = Parameters<T>[1];
+type AwaitedInput$s<T> = PromiseLike<T> | T;
+type Awaited$s<O> = O extends AwaitedInput$s<infer T> ? T : never;
+type SecondParameter$s<T extends (...args: never) => unknown> = Parameters<T>[1];
 declare const getListApiKeysUrl: (params?: ListApiKeysParams) => string;
 /**
  * List all API keys for your tenant.
@@ -13977,16 +13977,16 @@ declare const getListApiKeysUrl: (params?: ListApiKeysParams) => string;
  */
 declare const listApiKeys: (params?: ListApiKeysParams, options?: Parameters<typeof customFetch>[1]) => Promise<ListApiKeysEnvelope>;
 declare const getListApiKeysKey: (params?: ListApiKeysParams) => readonly ["/platform/api-keys", ...ListApiKeysParams[]];
-type ListApiKeysQueryResult = NonNullable<Awaited$t<ReturnType<typeof listApiKeys>>>;
+type ListApiKeysQueryResult = NonNullable<Awaited$s<ReturnType<typeof listApiKeys>>>;
 /**
  * @summary List API keys
  */
 declare const useListApiKeys: <TError = ErrorType<ErrorResponse>>(params?: ListApiKeysParams, options?: {
-    swr?: SWRConfiguration<Awaited$t<ReturnType<typeof listApiKeys>>, TError> & {
+    swr?: SWRConfiguration<Awaited$s<ReturnType<typeof listApiKeys>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$t<typeof customFetch>;
+    request?: SecondParameter$s<typeof customFetch>;
 }) => {
     data: ListApiKeysEnvelope | undefined;
     error: TError | undefined;
@@ -14005,19 +14005,19 @@ declare const getCreateApiKeyUrl: () => string;
  * @summary Create an API key
  */
 declare const createApiKey: (createApiKeyBody?: CreateApiKeyBody, options?: Parameters<typeof customFetch>[1]) => Promise<CreateApiKeyEnvelope>;
-declare const getCreateApiKeyMutationFetcher: (options?: SecondParameter$t<typeof customFetch>) => (_: Key, { arg }: {
+declare const getCreateApiKeyMutationFetcher: (options?: SecondParameter$s<typeof customFetch>) => (_: Key, { arg }: {
     arg: CreateApiKeyBody | undefined;
 }) => Promise<CreateApiKeyEnvelope>;
 declare const getCreateApiKeyMutationKey: () => readonly ["/platform/api-keys"];
-type CreateApiKeyMutationResult = NonNullable<Awaited$t<ReturnType<typeof createApiKey>>>;
+type CreateApiKeyMutationResult = NonNullable<Awaited$s<ReturnType<typeof createApiKey>>>;
 /**
  * @summary Create an API key
  */
 declare const useCreateApiKey: <TError = ErrorType<ErrorResponse>>(options?: {
-    swr?: SWRMutationConfiguration<Awaited$t<ReturnType<typeof createApiKey>>, TError, Key, CreateApiKeyBody | undefined, Awaited$t<ReturnType<typeof createApiKey>>> & {
+    swr?: SWRMutationConfiguration<Awaited$s<ReturnType<typeof createApiKey>>, TError, Key, CreateApiKeyBody | undefined, Awaited$s<ReturnType<typeof createApiKey>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$t<typeof customFetch>;
+    request?: SecondParameter$s<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<CreateApiKeyEnvelope, TError, string | readonly ["/platform/api-keys"], CreateApiKeyBody | undefined>;
@@ -14036,19 +14036,19 @@ declare const getRevokeApiKeyUrl: (id: string) => string;
  * @summary Revoke an API key
  */
 declare const revokeApiKey: (id: string, options?: Parameters<typeof customFetch>[1]) => Promise<RevokeApiKeyEnvelope>;
-declare const getRevokeApiKeyMutationFetcher: (id: string, options?: SecondParameter$t<typeof customFetch>) => (_: Key, __: {
+declare const getRevokeApiKeyMutationFetcher: (id: string, options?: SecondParameter$s<typeof customFetch>) => (_: Key, __: {
     arg: Arguments;
 }) => Promise<RevokeApiKeyEnvelope>;
 declare const getRevokeApiKeyMutationKey: (id: string) => readonly [`/platform/api-keys/${string}/revoke`];
-type RevokeApiKeyMutationResult = NonNullable<Awaited$t<ReturnType<typeof revokeApiKey>>>;
+type RevokeApiKeyMutationResult = NonNullable<Awaited$s<ReturnType<typeof revokeApiKey>>>;
 /**
  * @summary Revoke an API key
  */
 declare const useRevokeApiKey: <TError = ErrorType<ErrorResponse>>(id: string, options?: {
-    swr?: SWRMutationConfiguration<Awaited$t<ReturnType<typeof revokeApiKey>>, TError, Key, Arguments, Awaited$t<ReturnType<typeof revokeApiKey>>> & {
+    swr?: SWRMutationConfiguration<Awaited$s<ReturnType<typeof revokeApiKey>>, TError, Key, Arguments, Awaited$s<ReturnType<typeof revokeApiKey>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$t<typeof customFetch>;
+    request?: SecondParameter$s<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<RevokeApiKeyEnvelope, TError, string | readonly [`/platform/api-keys/${string}/revoke`], Arguments>;
@@ -14065,19 +14065,19 @@ declare const getUpdateApiKeyUrl: (id: string) => string;
  * @summary Update API key
  */
 declare const updateApiKey: (id: string, updateApiKeyBody?: UpdateApiKeyBody, options?: Parameters<typeof customFetch>[1]) => Promise<UpdateApiKeyEnvelope>;
-declare const getUpdateApiKeyMutationFetcher: (id: string, options?: SecondParameter$t<typeof customFetch>) => (_: Key, { arg }: {
+declare const getUpdateApiKeyMutationFetcher: (id: string, options?: SecondParameter$s<typeof customFetch>) => (_: Key, { arg }: {
     arg: UpdateApiKeyBody | undefined;
 }) => Promise<UpdateApiKeyEnvelope>;
 declare const getUpdateApiKeyMutationKey: (id: string) => readonly [`/platform/api-keys/${string}`];
-type UpdateApiKeyMutationResult = NonNullable<Awaited$t<ReturnType<typeof updateApiKey>>>;
+type UpdateApiKeyMutationResult = NonNullable<Awaited$s<ReturnType<typeof updateApiKey>>>;
 /**
  * @summary Update API key
  */
 declare const useUpdateApiKey: <TError = ErrorType<ErrorResponse>>(id: string, options?: {
-    swr?: SWRMutationConfiguration<Awaited$t<ReturnType<typeof updateApiKey>>, TError, Key, UpdateApiKeyBody | undefined, Awaited$t<ReturnType<typeof updateApiKey>>> & {
+    swr?: SWRMutationConfiguration<Awaited$s<ReturnType<typeof updateApiKey>>, TError, Key, UpdateApiKeyBody | undefined, Awaited$s<ReturnType<typeof updateApiKey>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$t<typeof customFetch>;
+    request?: SecondParameter$s<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<UpdateApiKeyEnvelope, TError, string | readonly [`/platform/api-keys/${string}`], UpdateApiKeyBody | undefined>;
@@ -14087,9 +14087,9 @@ declare const useUpdateApiKey: <TError = ErrorType<ErrorResponse>>(id: string, o
     swrKey: string | readonly [`/platform/api-keys/${string}`];
 };
 
-type AwaitedInput$s<T> = PromiseLike<T> | T;
-type Awaited$s<O> = O extends AwaitedInput$s<infer T> ? T : never;
-type SecondParameter$s<T extends (...args: never) => unknown> = Parameters<T>[1];
+type AwaitedInput$r<T> = PromiseLike<T> | T;
+type Awaited$r<O> = O extends AwaitedInput$r<infer T> ? T : never;
+type SecondParameter$r<T extends (...args: never) => unknown> = Parameters<T>[1];
 declare const getCreateArtifactUrl: () => string;
 /**
  * Upload a document as a base64-encoded artifact for processing.
@@ -14105,19 +14105,19 @@ declare const getCreateArtifactUrl: () => string;
  * @summary Create artifact
  */
 declare const createArtifact: (createArtifactBody?: CreateArtifactBody, options?: Parameters<typeof customFetch>[1]) => Promise<CreateArtifactEnvelope>;
-declare const getCreateArtifactMutationFetcher: (options?: SecondParameter$s<typeof customFetch>) => (_: Key, { arg }: {
+declare const getCreateArtifactMutationFetcher: (options?: SecondParameter$r<typeof customFetch>) => (_: Key, { arg }: {
     arg: CreateArtifactBody | undefined;
 }) => Promise<CreateArtifactEnvelope>;
 declare const getCreateArtifactMutationKey: () => readonly ["/v1/artifacts"];
-type CreateArtifactMutationResult = NonNullable<Awaited$s<ReturnType<typeof createArtifact>>>;
+type CreateArtifactMutationResult = NonNullable<Awaited$r<ReturnType<typeof createArtifact>>>;
 /**
  * @summary Create artifact
  */
 declare const useCreateArtifact: <TError = ErrorType<ErrorResponse>>(options?: {
-    swr?: SWRMutationConfiguration<Awaited$s<ReturnType<typeof createArtifact>>, TError, Key, CreateArtifactBody | undefined, Awaited$s<ReturnType<typeof createArtifact>>> & {
+    swr?: SWRMutationConfiguration<Awaited$r<ReturnType<typeof createArtifact>>, TError, Key, CreateArtifactBody | undefined, Awaited$r<ReturnType<typeof createArtifact>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$s<typeof customFetch>;
+    request?: SecondParameter$r<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<CreateArtifactEnvelope, TError, string | readonly ["/v1/artifacts"], CreateArtifactBody | undefined>;
@@ -14147,16 +14147,16 @@ declare const getListArtifactsUrl: (params?: ListArtifactsParams) => string;
  */
 declare const listArtifacts: (params?: ListArtifactsParams, options?: Parameters<typeof customFetch>[1]) => Promise<ListArtifactsEnvelope>;
 declare const getListArtifactsKey: (params?: ListArtifactsParams) => readonly ["/v1/artifacts", ...ListArtifactsParams[]];
-type ListArtifactsQueryResult = NonNullable<Awaited$s<ReturnType<typeof listArtifacts>>>;
+type ListArtifactsQueryResult = NonNullable<Awaited$r<ReturnType<typeof listArtifacts>>>;
 /**
  * @summary List artifacts
  */
 declare const useListArtifacts: <TError = ErrorType<ErrorResponse>>(params?: ListArtifactsParams, options?: {
-    swr?: SWRConfiguration<Awaited$s<ReturnType<typeof listArtifacts>>, TError> & {
+    swr?: SWRConfiguration<Awaited$r<ReturnType<typeof listArtifacts>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$s<typeof customFetch>;
+    request?: SecondParameter$r<typeof customFetch>;
 }) => {
     data: ListArtifactsEnvelope | undefined;
     error: TError | undefined;
@@ -14174,16 +14174,16 @@ declare const getGetArtifactUrl: (id: string) => string;
  */
 declare const getArtifact: (id: string, options?: Parameters<typeof customFetch>[1]) => Promise<GetArtifactEnvelope>;
 declare const getGetArtifactKey: (id: string) => readonly [`/v1/artifacts/${string}`];
-type GetArtifactQueryResult = NonNullable<Awaited$s<ReturnType<typeof getArtifact>>>;
+type GetArtifactQueryResult = NonNullable<Awaited$r<ReturnType<typeof getArtifact>>>;
 /**
  * @summary Get artifact
  */
 declare const useGetArtifact: <TError = ErrorType<ErrorResponse>>(id: string, options?: {
-    swr?: SWRConfiguration<Awaited$s<ReturnType<typeof getArtifact>>, TError> & {
+    swr?: SWRConfiguration<Awaited$r<ReturnType<typeof getArtifact>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$s<typeof customFetch>;
+    request?: SecondParameter$r<typeof customFetch>;
 }) => {
     data: GetArtifactEnvelope | undefined;
     error: TError | undefined;
@@ -14198,19 +14198,19 @@ declare const getDeleteArtifactUrl: (id: string) => string;
  * @summary Delete artifact
  */
 declare const deleteArtifact: (id: string, options?: Parameters<typeof customFetch>[1]) => Promise<DeleteArtifactEnvelope>;
-declare const getDeleteArtifactMutationFetcher: (id: string, options?: SecondParameter$s<typeof customFetch>) => (_: Key, __: {
+declare const getDeleteArtifactMutationFetcher: (id: string, options?: SecondParameter$r<typeof customFetch>) => (_: Key, __: {
     arg: Arguments;
 }) => Promise<DeleteArtifactEnvelope>;
 declare const getDeleteArtifactMutationKey: (id: string) => readonly [`/v1/artifacts/${string}`];
-type DeleteArtifactMutationResult = NonNullable<Awaited$s<ReturnType<typeof deleteArtifact>>>;
+type DeleteArtifactMutationResult = NonNullable<Awaited$r<ReturnType<typeof deleteArtifact>>>;
 /**
  * @summary Delete artifact
  */
 declare const useDeleteArtifact: <TError = ErrorType<ErrorResponse>>(id: string, options?: {
-    swr?: SWRMutationConfiguration<Awaited$s<ReturnType<typeof deleteArtifact>>, TError, Key, Arguments, Awaited$s<ReturnType<typeof deleteArtifact>>> & {
+    swr?: SWRMutationConfiguration<Awaited$r<ReturnType<typeof deleteArtifact>>, TError, Key, Arguments, Awaited$r<ReturnType<typeof deleteArtifact>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$s<typeof customFetch>;
+    request?: SecondParameter$r<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<DeleteArtifactEnvelope, TError, string | readonly [`/v1/artifacts/${string}`], Arguments>;
@@ -14226,16 +14226,16 @@ declare const getGetArtifactMetadataKeysUrl: (params?: GetArtifactMetadataKeysPa
  */
 declare const getArtifactMetadataKeys: (params?: GetArtifactMetadataKeysParams, options?: Parameters<typeof customFetch>[1]) => Promise<GetArtifactMetadataKeysEnvelope>;
 declare const getGetArtifactMetadataKeysKey: (params?: GetArtifactMetadataKeysParams) => readonly ["/v1/artifacts/metadata/keys", ...GetArtifactMetadataKeysParams[]];
-type GetArtifactMetadataKeysQueryResult = NonNullable<Awaited$s<ReturnType<typeof getArtifactMetadataKeys>>>;
+type GetArtifactMetadataKeysQueryResult = NonNullable<Awaited$r<ReturnType<typeof getArtifactMetadataKeys>>>;
 /**
  * @summary Get artifact metadata keys
  */
 declare const useGetArtifactMetadataKeys: <TError = ErrorType<ErrorResponse>>(params?: GetArtifactMetadataKeysParams, options?: {
-    swr?: SWRConfiguration<Awaited$s<ReturnType<typeof getArtifactMetadataKeys>>, TError> & {
+    swr?: SWRConfiguration<Awaited$r<ReturnType<typeof getArtifactMetadataKeys>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$s<typeof customFetch>;
+    request?: SecondParameter$r<typeof customFetch>;
 }) => {
     data: GetArtifactMetadataKeysEnvelope | undefined;
     error: TError | undefined;
@@ -14253,16 +14253,16 @@ declare const getGetArtifactStatusSummaryUrl: (params: GetArtifactStatusSummaryP
  */
 declare const getArtifactStatusSummary: (params: GetArtifactStatusSummaryParams, options?: Parameters<typeof customFetch>[1]) => Promise<GetArtifactStatusSummaryEnvelope>;
 declare const getGetArtifactStatusSummaryKey: (params: GetArtifactStatusSummaryParams) => readonly ["/v1/artifacts/status-summary", ...GetArtifactStatusSummaryParams[]];
-type GetArtifactStatusSummaryQueryResult = NonNullable<Awaited$s<ReturnType<typeof getArtifactStatusSummary>>>;
+type GetArtifactStatusSummaryQueryResult = NonNullable<Awaited$r<ReturnType<typeof getArtifactStatusSummary>>>;
 /**
  * @summary Get artifact status summary
  */
 declare const useGetArtifactStatusSummary: <TError = ErrorType<ErrorResponse>>(params: GetArtifactStatusSummaryParams, options?: {
-    swr?: SWRConfiguration<Awaited$s<ReturnType<typeof getArtifactStatusSummary>>, TError> & {
+    swr?: SWRConfiguration<Awaited$r<ReturnType<typeof getArtifactStatusSummary>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$s<typeof customFetch>;
+    request?: SecondParameter$r<typeof customFetch>;
 }) => {
     data: GetArtifactStatusSummaryEnvelope | undefined;
     error: TError | undefined;
@@ -14277,19 +14277,19 @@ declare const getGetArtifactUploadUrlUrl: () => string;
  * @summary Request a pre-signed URL for direct large file upload
  */
 declare const getArtifactUploadUrl: (getArtifactUploadUrlBody?: GetArtifactUploadUrlBody, options?: Parameters<typeof customFetch>[1]) => Promise<GetArtifactUploadUrlEnvelope>;
-declare const getGetArtifactUploadUrlMutationFetcher: (options?: SecondParameter$s<typeof customFetch>) => (_: Key, { arg }: {
+declare const getGetArtifactUploadUrlMutationFetcher: (options?: SecondParameter$r<typeof customFetch>) => (_: Key, { arg }: {
     arg: GetArtifactUploadUrlBody | undefined;
 }) => Promise<GetArtifactUploadUrlEnvelope>;
 declare const getGetArtifactUploadUrlMutationKey: () => readonly ["/v1/artifacts/get-upload-url"];
-type GetArtifactUploadUrlMutationResult = NonNullable<Awaited$s<ReturnType<typeof getArtifactUploadUrl>>>;
+type GetArtifactUploadUrlMutationResult = NonNullable<Awaited$r<ReturnType<typeof getArtifactUploadUrl>>>;
 /**
  * @summary Request a pre-signed URL for direct large file upload
  */
 declare const useGetArtifactUploadUrl: <TError = ErrorType<ErrorResponse>>(options?: {
-    swr?: SWRMutationConfiguration<Awaited$s<ReturnType<typeof getArtifactUploadUrl>>, TError, Key, GetArtifactUploadUrlBody | undefined, Awaited$s<ReturnType<typeof getArtifactUploadUrl>>> & {
+    swr?: SWRMutationConfiguration<Awaited$r<ReturnType<typeof getArtifactUploadUrl>>, TError, Key, GetArtifactUploadUrlBody | undefined, Awaited$r<ReturnType<typeof getArtifactUploadUrl>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$s<typeof customFetch>;
+    request?: SecondParameter$r<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<GetArtifactUploadUrlEnvelope, TError, string | readonly ["/v1/artifacts/get-upload-url"], GetArtifactUploadUrlBody | undefined>;
@@ -14304,19 +14304,19 @@ declare const getUpdateArtifactMetadataUrl: (id: string) => string;
  * @summary Update artifact metadata
  */
 declare const updateArtifactMetadata: (id: string, updateArtifactMetadataBody?: UpdateArtifactMetadataBody, options?: Parameters<typeof customFetch>[1]) => Promise<UpdateArtifactMetadataEnvelope>;
-declare const getUpdateArtifactMetadataMutationFetcher: (id: string, options?: SecondParameter$s<typeof customFetch>) => (_: Key, { arg }: {
+declare const getUpdateArtifactMetadataMutationFetcher: (id: string, options?: SecondParameter$r<typeof customFetch>) => (_: Key, { arg }: {
     arg: UpdateArtifactMetadataBody | undefined;
 }) => Promise<UpdateArtifactMetadataEnvelope>;
 declare const getUpdateArtifactMetadataMutationKey: (id: string) => readonly [`/v1/artifacts/${string}/metadata`];
-type UpdateArtifactMetadataMutationResult = NonNullable<Awaited$s<ReturnType<typeof updateArtifactMetadata>>>;
+type UpdateArtifactMetadataMutationResult = NonNullable<Awaited$r<ReturnType<typeof updateArtifactMetadata>>>;
 /**
  * @summary Update artifact metadata
  */
 declare const useUpdateArtifactMetadata: <TError = ErrorType<ErrorResponse>>(id: string, options?: {
-    swr?: SWRMutationConfiguration<Awaited$s<ReturnType<typeof updateArtifactMetadata>>, TError, Key, UpdateArtifactMetadataBody | undefined, Awaited$s<ReturnType<typeof updateArtifactMetadata>>> & {
+    swr?: SWRMutationConfiguration<Awaited$r<ReturnType<typeof updateArtifactMetadata>>, TError, Key, UpdateArtifactMetadataBody | undefined, Awaited$r<ReturnType<typeof updateArtifactMetadata>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$s<typeof customFetch>;
+    request?: SecondParameter$r<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<UpdateArtifactMetadataEnvelope, TError, string | readonly [`/v1/artifacts/${string}/metadata`], UpdateArtifactMetadataBody | undefined>;
@@ -14333,19 +14333,19 @@ declare const getUploadFileUrl: () => string;
  * @summary Upload a file for processing
  */
 declare const uploadFile: (uploadFileBody?: UploadFileBody, options?: Parameters<typeof customFetch>[1]) => Promise<UploadFileEnvelope>;
-declare const getUploadFileMutationFetcher: (options?: SecondParameter$s<typeof customFetch>) => (_: Key, { arg }: {
+declare const getUploadFileMutationFetcher: (options?: SecondParameter$r<typeof customFetch>) => (_: Key, { arg }: {
     arg: UploadFileBody | undefined;
 }) => Promise<UploadFileEnvelope>;
 declare const getUploadFileMutationKey: () => readonly ["/v1/upload-file"];
-type UploadFileMutationResult = NonNullable<Awaited$s<ReturnType<typeof uploadFile>>>;
+type UploadFileMutationResult = NonNullable<Awaited$r<ReturnType<typeof uploadFile>>>;
 /**
  * @summary Upload a file for processing
  */
 declare const useUploadFile: <TError = ErrorType<ErrorResponse>>(options?: {
-    swr?: SWRMutationConfiguration<Awaited$s<ReturnType<typeof uploadFile>>, TError, Key, UploadFileBody | undefined, Awaited$s<ReturnType<typeof uploadFile>>> & {
+    swr?: SWRMutationConfiguration<Awaited$r<ReturnType<typeof uploadFile>>, TError, Key, UploadFileBody | undefined, Awaited$r<ReturnType<typeof uploadFile>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$s<typeof customFetch>;
+    request?: SecondParameter$r<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<UploadFileEnvelope, TError, string | readonly ["/v1/upload-file"], UploadFileBody | undefined>;
@@ -14355,28 +14355,28 @@ declare const useUploadFile: <TError = ErrorType<ErrorResponse>>(options?: {
     swrKey: string | readonly ["/v1/upload-file"];
 };
 
-type AwaitedInput$r<T> = PromiseLike<T> | T;
-type Awaited$r<O> = O extends AwaitedInput$r<infer T> ? T : never;
-type SecondParameter$r<T extends (...args: never) => unknown> = Parameters<T>[1];
+type AwaitedInput$q<T> = PromiseLike<T> | T;
+type Awaited$q<O> = O extends AwaitedInput$q<infer T> ? T : never;
+type SecondParameter$q<T extends (...args: never) => unknown> = Parameters<T>[1];
 declare const getSignUpUrl: () => string;
 /**
  * Create a new user account with email and password. When the response includes a pending_authentication_token, the account requires email verification: complete it via sign-in (type: email_otp) with the emailed one-time password and this token.
  * @summary Sign up
  */
 declare const signUp: (signUpBody?: SignUpBody, options?: Parameters<typeof customFetchNoAuth>[1]) => Promise<SignUpEnvelope>;
-declare const getSignUpMutationFetcher: (options?: SecondParameter$r<typeof customFetchNoAuth>) => (_: Key, { arg }: {
+declare const getSignUpMutationFetcher: (options?: SecondParameter$q<typeof customFetchNoAuth>) => (_: Key, { arg }: {
     arg: SignUpBody | undefined;
 }) => Promise<SignUpEnvelope>;
 declare const getSignUpMutationKey: () => readonly ["/v1/auth/sign-up"];
-type SignUpMutationResult = NonNullable<Awaited$r<ReturnType<typeof signUp>>>;
+type SignUpMutationResult = NonNullable<Awaited$q<ReturnType<typeof signUp>>>;
 /**
  * @summary Sign up
  */
 declare const useSignUp: <TError = ErrorType<ErrorResponse>>(options?: {
-    swr?: SWRMutationConfiguration<Awaited$r<ReturnType<typeof signUp>>, TError, Key, SignUpBody | undefined, Awaited$r<ReturnType<typeof signUp>>> & {
+    swr?: SWRMutationConfiguration<Awaited$q<ReturnType<typeof signUp>>, TError, Key, SignUpBody | undefined, Awaited$q<ReturnType<typeof signUp>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$r<typeof customFetchNoAuth>;
+    request?: SecondParameter$q<typeof customFetchNoAuth>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<SignUpEnvelope, TError, string | readonly ["/v1/auth/sign-up"], SignUpBody | undefined>;
@@ -14395,19 +14395,19 @@ declare const getSignInUrl: () => string;
  * @summary Sign in
  */
 declare const signIn: (signInBody?: SignInBody, options?: Parameters<typeof customFetchNoAuth>[1]) => Promise<SignInEnvelope>;
-declare const getSignInMutationFetcher: (options?: SecondParameter$r<typeof customFetchNoAuth>) => (_: Key, { arg }: {
+declare const getSignInMutationFetcher: (options?: SecondParameter$q<typeof customFetchNoAuth>) => (_: Key, { arg }: {
     arg: SignInBody | undefined;
 }) => Promise<SignInEnvelope>;
 declare const getSignInMutationKey: () => readonly ["/v1/auth/sign-in"];
-type SignInMutationResult = NonNullable<Awaited$r<ReturnType<typeof signIn>>>;
+type SignInMutationResult = NonNullable<Awaited$q<ReturnType<typeof signIn>>>;
 /**
  * @summary Sign in
  */
 declare const useSignIn: <TError = ErrorType<ErrorResponse>>(options?: {
-    swr?: SWRMutationConfiguration<Awaited$r<ReturnType<typeof signIn>>, TError, Key, SignInBody | undefined, Awaited$r<ReturnType<typeof signIn>>> & {
+    swr?: SWRMutationConfiguration<Awaited$q<ReturnType<typeof signIn>>, TError, Key, SignInBody | undefined, Awaited$q<ReturnType<typeof signIn>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$r<typeof customFetchNoAuth>;
+    request?: SecondParameter$q<typeof customFetchNoAuth>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<SignInEnvelope, TError, string | readonly ["/v1/auth/sign-in"], SignInBody | undefined>;
@@ -14422,19 +14422,19 @@ declare const getRequestPasswordResetUrl: () => string;
  * @summary Request password reset
  */
 declare const requestPasswordReset: (requestPasswordResetBody?: RequestPasswordResetBody, options?: Parameters<typeof customFetchNoAuth>[1]) => Promise<RequestPasswordResetEnvelope>;
-declare const getRequestPasswordResetMutationFetcher: (options?: SecondParameter$r<typeof customFetchNoAuth>) => (_: Key, { arg }: {
+declare const getRequestPasswordResetMutationFetcher: (options?: SecondParameter$q<typeof customFetchNoAuth>) => (_: Key, { arg }: {
     arg: RequestPasswordResetBody | undefined;
 }) => Promise<RequestPasswordResetEnvelope>;
 declare const getRequestPasswordResetMutationKey: () => readonly ["/v1/auth/request-password-reset"];
-type RequestPasswordResetMutationResult = NonNullable<Awaited$r<ReturnType<typeof requestPasswordReset>>>;
+type RequestPasswordResetMutationResult = NonNullable<Awaited$q<ReturnType<typeof requestPasswordReset>>>;
 /**
  * @summary Request password reset
  */
 declare const useRequestPasswordReset: <TError = ErrorType<ErrorResponse>>(options?: {
-    swr?: SWRMutationConfiguration<Awaited$r<ReturnType<typeof requestPasswordReset>>, TError, Key, RequestPasswordResetBody | undefined, Awaited$r<ReturnType<typeof requestPasswordReset>>> & {
+    swr?: SWRMutationConfiguration<Awaited$q<ReturnType<typeof requestPasswordReset>>, TError, Key, RequestPasswordResetBody | undefined, Awaited$q<ReturnType<typeof requestPasswordReset>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$r<typeof customFetchNoAuth>;
+    request?: SecondParameter$q<typeof customFetchNoAuth>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<RequestPasswordResetEnvelope, TError, string | readonly ["/v1/auth/request-password-reset"], RequestPasswordResetBody | undefined>;
@@ -14449,19 +14449,19 @@ declare const getResetPasswordUrl: () => string;
  * @summary Reset password
  */
 declare const resetPassword: (resetPasswordBody?: ResetPasswordBody, options?: Parameters<typeof customFetchNoAuth>[1]) => Promise<ResetPasswordEnvelope>;
-declare const getResetPasswordMutationFetcher: (options?: SecondParameter$r<typeof customFetchNoAuth>) => (_: Key, { arg }: {
+declare const getResetPasswordMutationFetcher: (options?: SecondParameter$q<typeof customFetchNoAuth>) => (_: Key, { arg }: {
     arg: ResetPasswordBody | undefined;
 }) => Promise<ResetPasswordEnvelope>;
 declare const getResetPasswordMutationKey: () => readonly ["/v1/auth/reset-password"];
-type ResetPasswordMutationResult = NonNullable<Awaited$r<ReturnType<typeof resetPassword>>>;
+type ResetPasswordMutationResult = NonNullable<Awaited$q<ReturnType<typeof resetPassword>>>;
 /**
  * @summary Reset password
  */
 declare const useResetPassword: <TError = ErrorType<ErrorResponse>>(options?: {
-    swr?: SWRMutationConfiguration<Awaited$r<ReturnType<typeof resetPassword>>, TError, Key, ResetPasswordBody | undefined, Awaited$r<ReturnType<typeof resetPassword>>> & {
+    swr?: SWRMutationConfiguration<Awaited$q<ReturnType<typeof resetPassword>>, TError, Key, ResetPasswordBody | undefined, Awaited$q<ReturnType<typeof resetPassword>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$r<typeof customFetchNoAuth>;
+    request?: SecondParameter$q<typeof customFetchNoAuth>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<ResetPasswordEnvelope, TError, string | readonly ["/v1/auth/reset-password"], ResetPasswordBody | undefined>;
@@ -14476,19 +14476,19 @@ declare const getRefreshTokenUrl: () => string;
  * @summary Refresh authentication token
  */
 declare const refreshToken: (refreshTokenBody?: RefreshTokenBody, options?: Parameters<typeof customFetchNoAuth>[1]) => Promise<RefreshTokenEnvelope>;
-declare const getRefreshTokenMutationFetcher: (options?: SecondParameter$r<typeof customFetchNoAuth>) => (_: Key, { arg }: {
+declare const getRefreshTokenMutationFetcher: (options?: SecondParameter$q<typeof customFetchNoAuth>) => (_: Key, { arg }: {
     arg: RefreshTokenBody | undefined;
 }) => Promise<RefreshTokenEnvelope>;
 declare const getRefreshTokenMutationKey: () => readonly ["/v1/auth/refresh-token"];
-type RefreshTokenMutationResult = NonNullable<Awaited$r<ReturnType<typeof refreshToken>>>;
+type RefreshTokenMutationResult = NonNullable<Awaited$q<ReturnType<typeof refreshToken>>>;
 /**
  * @summary Refresh authentication token
  */
 declare const useRefreshToken: <TError = ErrorType<ErrorResponse>>(options?: {
-    swr?: SWRMutationConfiguration<Awaited$r<ReturnType<typeof refreshToken>>, TError, Key, RefreshTokenBody | undefined, Awaited$r<ReturnType<typeof refreshToken>>> & {
+    swr?: SWRMutationConfiguration<Awaited$q<ReturnType<typeof refreshToken>>, TError, Key, RefreshTokenBody | undefined, Awaited$q<ReturnType<typeof refreshToken>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$r<typeof customFetchNoAuth>;
+    request?: SecondParameter$q<typeof customFetchNoAuth>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<RefreshTokenEnvelope, TError, string | readonly ["/v1/auth/refresh-token"], RefreshTokenBody | undefined>;
@@ -14497,6 +14497,35 @@ declare const useRefreshToken: <TError = ErrorType<ErrorResponse>>(options?: {
     data: RefreshTokenEnvelope | undefined;
     swrKey: string | readonly ["/v1/auth/refresh-token"];
 };
+declare const getRefreshSessionUrl: () => string;
+/**
+ * Rotate the refresh token and return a new access token for `tenant_id`. Call it with a different `tenant_id` to switch tenants.
+ *
+ * Send the current access token as `Authorization: Bearer`. It may be expired: it only identifies the user, and the refresh token must belong to that same user. The identity provider decides whether the session is still valid. The user must be a member of `tenant_id` (404 otherwise).
+ * @summary Refresh session
+ */
+declare const refreshSession: (refreshSessionBody?: RefreshSessionBody, options?: Parameters<typeof customFetchNoAuth>[1]) => Promise<RefreshSessionEnvelope>;
+declare const getRefreshSessionMutationFetcher: (options?: SecondParameter$q<typeof customFetchNoAuth>) => (_: Key, { arg }: {
+    arg: RefreshSessionBody | undefined;
+}) => Promise<RefreshSessionEnvelope>;
+declare const getRefreshSessionMutationKey: () => readonly ["/v1/auth/session/refresh"];
+type RefreshSessionMutationResult = NonNullable<Awaited$q<ReturnType<typeof refreshSession>>>;
+/**
+ * @summary Refresh session
+ */
+declare const useRefreshSession: <TError = ErrorType<ErrorResponse>>(options?: {
+    swr?: SWRMutationConfiguration<Awaited$q<ReturnType<typeof refreshSession>>, TError, Key, RefreshSessionBody | undefined, Awaited$q<ReturnType<typeof refreshSession>>> & {
+        swrKey?: string;
+    };
+    request?: SecondParameter$q<typeof customFetchNoAuth>;
+}) => {
+    isMutating: boolean;
+    trigger: swr_mutation.TriggerWithOptionsArgs<RefreshSessionEnvelope, TError, string | readonly ["/v1/auth/session/refresh"], RefreshSessionBody | undefined>;
+    reset: () => void;
+    error: TError | undefined;
+    data: RefreshSessionEnvelope | undefined;
+    swrKey: string | readonly ["/v1/auth/session/refresh"];
+};
 declare const getGetOAuthUrlUrl: (params: GetOAuthUrlParams) => string;
 /**
  * Generate an OAuth authorization URL for a given provider.
@@ -14508,16 +14537,16 @@ declare const getGetOAuthUrlUrl: (params: GetOAuthUrlParams) => string;
  */
 declare const getOAuthUrl: (params: GetOAuthUrlParams, options?: Parameters<typeof customFetchNoAuth>[1]) => Promise<GetOAuthUrlEnvelope>;
 declare const getGetOAuthUrlKey: (params: GetOAuthUrlParams) => readonly ["/v1/auth/oauth-url", ...GetOAuthUrlParams[]];
-type GetOAuthUrlQueryResult = NonNullable<Awaited$r<ReturnType<typeof getOAuthUrl>>>;
+type GetOAuthUrlQueryResult = NonNullable<Awaited$q<ReturnType<typeof getOAuthUrl>>>;
 /**
  * @summary Get OAuth sign-in URL
  */
 declare const useGetOAuthUrl: <TError = ErrorType<ErrorResponse>>(params: GetOAuthUrlParams, options?: {
-    swr?: SWRConfiguration<Awaited$r<ReturnType<typeof getOAuthUrl>>, TError> & {
+    swr?: SWRConfiguration<Awaited$q<ReturnType<typeof getOAuthUrl>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$r<typeof customFetchNoAuth>;
+    request?: SecondParameter$q<typeof customFetchNoAuth>;
 }) => {
     data: GetOAuthUrlEnvelope | undefined;
     error: TError | undefined;
@@ -14536,19 +14565,19 @@ declare const getGetSessionTokenUrl: () => string;
  * @summary Create or switch tenant session
  */
 declare const getSessionToken: (getSessionTokenBody?: GetSessionTokenBody, options?: Parameters<typeof customFetchNoAuth>[1]) => Promise<GetSessionTokenEnvelope>;
-declare const getGetSessionTokenMutationFetcher: (options?: SecondParameter$r<typeof customFetchNoAuth>) => (_: Key, { arg }: {
+declare const getGetSessionTokenMutationFetcher: (options?: SecondParameter$q<typeof customFetchNoAuth>) => (_: Key, { arg }: {
     arg: GetSessionTokenBody | undefined;
 }) => Promise<GetSessionTokenEnvelope>;
 declare const getGetSessionTokenMutationKey: () => readonly ["/v1/auth/session"];
-type GetSessionTokenMutationResult = NonNullable<Awaited$r<ReturnType<typeof getSessionToken>>>;
+type GetSessionTokenMutationResult = NonNullable<Awaited$q<ReturnType<typeof getSessionToken>>>;
 /**
  * @summary Create or switch tenant session
  */
 declare const useGetSessionToken: <TError = ErrorType<ErrorResponse>>(options?: {
-    swr?: SWRMutationConfiguration<Awaited$r<ReturnType<typeof getSessionToken>>, TError, Key, GetSessionTokenBody | undefined, Awaited$r<ReturnType<typeof getSessionToken>>> & {
+    swr?: SWRMutationConfiguration<Awaited$q<ReturnType<typeof getSessionToken>>, TError, Key, GetSessionTokenBody | undefined, Awaited$q<ReturnType<typeof getSessionToken>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$r<typeof customFetchNoAuth>;
+    request?: SecondParameter$q<typeof customFetchNoAuth>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<GetSessionTokenEnvelope, TError, string | readonly ["/v1/auth/session"], GetSessionTokenBody | undefined>;
@@ -14564,16 +14593,16 @@ declare const getGetPartnerJwksUrl: (partner: string) => string;
  */
 declare const getPartnerJwks: (partner: string, options?: Parameters<typeof customFetchNoAuth>[1]) => Promise<PartnerJwks>;
 declare const getGetPartnerJwksKey: (partner: string) => readonly [`/.well-known/partners/${string}/jwks.json`];
-type GetPartnerJwksQueryResult = NonNullable<Awaited$r<ReturnType<typeof getPartnerJwks>>>;
+type GetPartnerJwksQueryResult = NonNullable<Awaited$q<ReturnType<typeof getPartnerJwks>>>;
 /**
  * @summary Get partner JWKS
  */
 declare const useGetPartnerJwks: <TError = ErrorType<ErrorResponse>>(partner: string, options?: {
-    swr?: SWRConfiguration<Awaited$r<ReturnType<typeof getPartnerJwks>>, TError> & {
+    swr?: SWRConfiguration<Awaited$q<ReturnType<typeof getPartnerJwks>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$r<typeof customFetchNoAuth>;
+    request?: SecondParameter$q<typeof customFetchNoAuth>;
 }) => {
     data: PartnerJwks | undefined;
     error: TError | undefined;
@@ -14588,19 +14617,19 @@ declare const getPartnerLaunchUrl: (params?: PartnerLaunchParams) => string;
  * @summary Partner launch (SSO)
  */
 declare const partnerLaunch: (params?: PartnerLaunchParams, options?: Parameters<typeof customFetchNoAuth>[1]) => Promise<unknown>;
-declare const getPartnerLaunchMutationFetcher: (params?: PartnerLaunchParams, options?: SecondParameter$r<typeof customFetchNoAuth>) => (_: Key, __: {
+declare const getPartnerLaunchMutationFetcher: (params?: PartnerLaunchParams, options?: SecondParameter$q<typeof customFetchNoAuth>) => (_: Key, __: {
     arg: Arguments;
 }) => Promise<unknown>;
 declare const getPartnerLaunchMutationKey: (params?: PartnerLaunchParams) => readonly ["/v1/auth/partner-launch", ...PartnerLaunchParams[]];
-type PartnerLaunchMutationResult = NonNullable<Awaited$r<ReturnType<typeof partnerLaunch>>>;
+type PartnerLaunchMutationResult = NonNullable<Awaited$q<ReturnType<typeof partnerLaunch>>>;
 /**
  * @summary Partner launch (SSO)
  */
 declare const usePartnerLaunch: <TError = ErrorType<PartnerLaunchEnvelope | ErrorResponse>>(params?: PartnerLaunchParams, options?: {
-    swr?: SWRMutationConfiguration<Awaited$r<ReturnType<typeof partnerLaunch>>, TError, Key, Arguments, Awaited$r<ReturnType<typeof partnerLaunch>>> & {
+    swr?: SWRMutationConfiguration<Awaited$q<ReturnType<typeof partnerLaunch>>, TError, Key, Arguments, Awaited$q<ReturnType<typeof partnerLaunch>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$r<typeof customFetchNoAuth>;
+    request?: SecondParameter$q<typeof customFetchNoAuth>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<unknown, TError, string | readonly ["/v1/auth/partner-launch", ...PartnerLaunchParams[]], Arguments>;
@@ -14615,19 +14644,19 @@ declare const getExchangeExternalIdentityTokenUrl: () => string;
  * @summary Exchange an external identity token
  */
 declare const exchangeExternalIdentityToken: (exchangeExternalIdentityTokenBody?: ExchangeExternalIdentityTokenBody, options?: Parameters<typeof customFetchNoAuth>[1]) => Promise<ExchangeExternalIdentityTokenEnvelope>;
-declare const getExchangeExternalIdentityTokenMutationFetcher: (options?: SecondParameter$r<typeof customFetchNoAuth>) => (_: Key, { arg }: {
+declare const getExchangeExternalIdentityTokenMutationFetcher: (options?: SecondParameter$q<typeof customFetchNoAuth>) => (_: Key, { arg }: {
     arg: ExchangeExternalIdentityTokenBody | undefined;
 }) => Promise<ExchangeExternalIdentityTokenEnvelope>;
 declare const getExchangeExternalIdentityTokenMutationKey: () => readonly ["/public/v1/identity/token"];
-type ExchangeExternalIdentityTokenMutationResult = NonNullable<Awaited$r<ReturnType<typeof exchangeExternalIdentityToken>>>;
+type ExchangeExternalIdentityTokenMutationResult = NonNullable<Awaited$q<ReturnType<typeof exchangeExternalIdentityToken>>>;
 /**
  * @summary Exchange an external identity token
  */
 declare const useExchangeExternalIdentityToken: <TError = ErrorType<ErrorResponse>>(options?: {
-    swr?: SWRMutationConfiguration<Awaited$r<ReturnType<typeof exchangeExternalIdentityToken>>, TError, Key, ExchangeExternalIdentityTokenBody | undefined, Awaited$r<ReturnType<typeof exchangeExternalIdentityToken>>> & {
+    swr?: SWRMutationConfiguration<Awaited$q<ReturnType<typeof exchangeExternalIdentityToken>>, TError, Key, ExchangeExternalIdentityTokenBody | undefined, Awaited$q<ReturnType<typeof exchangeExternalIdentityToken>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$r<typeof customFetchNoAuth>;
+    request?: SecondParameter$q<typeof customFetchNoAuth>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<ExchangeExternalIdentityTokenEnvelope, TError, string | readonly ["/public/v1/identity/token"], ExchangeExternalIdentityTokenBody | undefined>;
@@ -14637,28 +14666,28 @@ declare const useExchangeExternalIdentityToken: <TError = ErrorType<ErrorRespons
     swrKey: string | readonly ["/public/v1/identity/token"];
 };
 
-type AwaitedInput$q<T> = PromiseLike<T> | T;
-type Awaited$q<O> = O extends AwaitedInput$q<infer T> ? T : never;
-type SecondParameter$q<T extends (...args: never) => unknown> = Parameters<T>[1];
+type AwaitedInput$p<T> = PromiseLike<T> | T;
+type Awaited$p<O> = O extends AwaitedInput$p<infer T> ? T : never;
+type SecondParameter$p<T extends (...args: never) => unknown> = Parameters<T>[1];
 declare const getCreateCallFeedbackUrl: (id: string) => string;
 /**
  * Create feedback for a specific message in a call. Requires user (JWT) authentication; the author is derived from the authenticated user's profile and API-key callers are rejected.
  * @summary Create feedback on a call message
  */
 declare const createCallFeedback: (id: string, createFeedbackRequest?: CreateFeedbackRequest, options?: Parameters<typeof customFetch>[1]) => Promise<CreateCallFeedbackEnvelope>;
-declare const getCreateCallFeedbackMutationFetcher: (id: string, options?: SecondParameter$q<typeof customFetch>) => (_: Key, { arg }: {
+declare const getCreateCallFeedbackMutationFetcher: (id: string, options?: SecondParameter$p<typeof customFetch>) => (_: Key, { arg }: {
     arg: CreateFeedbackRequest | undefined;
 }) => Promise<CreateCallFeedbackEnvelope>;
 declare const getCreateCallFeedbackMutationKey: (id: string) => readonly [`/v1/calls/${string}/feedback`];
-type CreateCallFeedbackMutationResult = NonNullable<Awaited$q<ReturnType<typeof createCallFeedback>>>;
+type CreateCallFeedbackMutationResult = NonNullable<Awaited$p<ReturnType<typeof createCallFeedback>>>;
 /**
  * @summary Create feedback on a call message
  */
 declare const useCreateCallFeedback: <TError = ErrorType<ErrorResponse>>(id: string, options?: {
-    swr?: SWRMutationConfiguration<Awaited$q<ReturnType<typeof createCallFeedback>>, TError, Key, CreateFeedbackRequest | undefined, Awaited$q<ReturnType<typeof createCallFeedback>>> & {
+    swr?: SWRMutationConfiguration<Awaited$p<ReturnType<typeof createCallFeedback>>, TError, Key, CreateFeedbackRequest | undefined, Awaited$p<ReturnType<typeof createCallFeedback>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$q<typeof customFetch>;
+    request?: SecondParameter$p<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<CreateCallFeedbackEnvelope, TError, string | readonly [`/v1/calls/${string}/feedback`], CreateFeedbackRequest | undefined>;
@@ -14674,16 +14703,16 @@ declare const getListCallFeedbackUrl: (id: string, params?: ListCallFeedbackPara
  */
 declare const listCallFeedback: (id: string, params?: ListCallFeedbackParams, options?: Parameters<typeof customFetch>[1]) => Promise<ListCallFeedbackEnvelope>;
 declare const getListCallFeedbackKey: (id: string, params?: ListCallFeedbackParams) => readonly [`/v1/calls/${string}/feedback`, ...ListCallFeedbackParams[]];
-type ListCallFeedbackQueryResult = NonNullable<Awaited$q<ReturnType<typeof listCallFeedback>>>;
+type ListCallFeedbackQueryResult = NonNullable<Awaited$p<ReturnType<typeof listCallFeedback>>>;
 /**
  * @summary List feedback for a call
  */
 declare const useListCallFeedback: <TError = ErrorType<ErrorResponse>>(id: string, params?: ListCallFeedbackParams, options?: {
-    swr?: SWRConfiguration<Awaited$q<ReturnType<typeof listCallFeedback>>, TError> & {
+    swr?: SWRConfiguration<Awaited$p<ReturnType<typeof listCallFeedback>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$q<typeof customFetch>;
+    request?: SecondParameter$p<typeof customFetch>;
 }) => {
     data: ListCallFeedbackEnvelope | undefined;
     error: TError | undefined;
@@ -14698,19 +14727,19 @@ declare const getDeleteCallFeedbackUrl: (id: string, feedbackId: string) => stri
  * @summary Delete feedback
  */
 declare const deleteCallFeedback: (id: string, feedbackId: string, options?: Parameters<typeof customFetch>[1]) => Promise<DeleteCallFeedbackEnvelope>;
-declare const getDeleteCallFeedbackMutationFetcher: (id: string, feedbackId: string, options?: SecondParameter$q<typeof customFetch>) => (_: Key, __: {
+declare const getDeleteCallFeedbackMutationFetcher: (id: string, feedbackId: string, options?: SecondParameter$p<typeof customFetch>) => (_: Key, __: {
     arg: Arguments;
 }) => Promise<DeleteCallFeedbackEnvelope>;
 declare const getDeleteCallFeedbackMutationKey: (id: string, feedbackId: string) => readonly [`/v1/calls/${string}/feedback/${string}`];
-type DeleteCallFeedbackMutationResult = NonNullable<Awaited$q<ReturnType<typeof deleteCallFeedback>>>;
+type DeleteCallFeedbackMutationResult = NonNullable<Awaited$p<ReturnType<typeof deleteCallFeedback>>>;
 /**
  * @summary Delete feedback
  */
 declare const useDeleteCallFeedback: <TError = ErrorType<ErrorResponse>>(id: string, feedbackId: string, options?: {
-    swr?: SWRMutationConfiguration<Awaited$q<ReturnType<typeof deleteCallFeedback>>, TError, Key, Arguments, Awaited$q<ReturnType<typeof deleteCallFeedback>>> & {
+    swr?: SWRMutationConfiguration<Awaited$p<ReturnType<typeof deleteCallFeedback>>, TError, Key, Arguments, Awaited$p<ReturnType<typeof deleteCallFeedback>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$q<typeof customFetch>;
+    request?: SecondParameter$p<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<DeleteCallFeedbackEnvelope, TError, string | readonly [`/v1/calls/${string}/feedback/${string}`], Arguments>;
@@ -14720,9 +14749,9 @@ declare const useDeleteCallFeedback: <TError = ErrorType<ErrorResponse>>(id: str
     swrKey: string | readonly [`/v1/calls/${string}/feedback/${string}`];
 };
 
-type AwaitedInput$p<T> = PromiseLike<T> | T;
-type Awaited$p<O> = O extends AwaitedInput$p<infer T> ? T : never;
-type SecondParameter$p<T extends (...args: never) => unknown> = Parameters<T>[1];
+type AwaitedInput$o<T> = PromiseLike<T> | T;
+type Awaited$o<O> = O extends AwaitedInput$o<infer T> ? T : never;
+type SecondParameter$o<T extends (...args: never) => unknown> = Parameters<T>[1];
 declare const getListCallsUrl: (params?: ListCallsParams) => string;
 /**
  * List all calls, with pagination, filtering, and sorting.
@@ -14748,16 +14777,16 @@ declare const getListCallsUrl: (params?: ListCallsParams) => string;
  */
 declare const listCalls: (params?: ListCallsParams, options?: Parameters<typeof customFetch>[1]) => Promise<ListCallsEnvelope>;
 declare const getListCallsKey: (params?: ListCallsParams) => readonly ["/v1/calls", ...ListCallsParams[]];
-type ListCallsQueryResult = NonNullable<Awaited$p<ReturnType<typeof listCalls>>>;
+type ListCallsQueryResult = NonNullable<Awaited$o<ReturnType<typeof listCalls>>>;
 /**
  * @summary List calls
  */
 declare const useListCalls: <TError = ErrorType<ErrorResponse>>(params?: ListCallsParams, options?: {
-    swr?: SWRConfiguration<Awaited$p<ReturnType<typeof listCalls>>, TError> & {
+    swr?: SWRConfiguration<Awaited$o<ReturnType<typeof listCalls>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$p<typeof customFetch>;
+    request?: SecondParameter$o<typeof customFetch>;
 }) => {
     data: ListCallsEnvelope | undefined;
     error: TError | undefined;
@@ -14784,19 +14813,19 @@ declare const getCreateCallUrl: () => string;
  * @summary Create an outbound call
  */
 declare const createCall: (createCallBody?: CreateCallBody, options?: Parameters<typeof customFetch>[1]) => Promise<CreateCallEnvelope>;
-declare const getCreateCallMutationFetcher: (options?: SecondParameter$p<typeof customFetch>) => (_: Key, { arg }: {
+declare const getCreateCallMutationFetcher: (options?: SecondParameter$o<typeof customFetch>) => (_: Key, { arg }: {
     arg: CreateCallBody | undefined;
 }) => Promise<CreateCallEnvelope>;
 declare const getCreateCallMutationKey: () => readonly ["/v1/calls"];
-type CreateCallMutationResult = NonNullable<Awaited$p<ReturnType<typeof createCall>>>;
+type CreateCallMutationResult = NonNullable<Awaited$o<ReturnType<typeof createCall>>>;
 /**
  * @summary Create an outbound call
  */
 declare const useCreateCall: <TError = ErrorType<ErrorResponse>>(options?: {
-    swr?: SWRMutationConfiguration<Awaited$p<ReturnType<typeof createCall>>, TError, Key, CreateCallBody | undefined, Awaited$p<ReturnType<typeof createCall>>> & {
+    swr?: SWRMutationConfiguration<Awaited$o<ReturnType<typeof createCall>>, TError, Key, CreateCallBody | undefined, Awaited$o<ReturnType<typeof createCall>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$p<typeof customFetch>;
+    request?: SecondParameter$o<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<CreateCallEnvelope, TError, string | readonly ["/v1/calls"], CreateCallBody | undefined>;
@@ -14814,16 +14843,16 @@ declare const getGetCallUrl: (id: string, params?: GetCallParams) => string;
  */
 declare const getCall: (id: string, params?: GetCallParams, options?: Parameters<typeof customFetch>[1]) => Promise<GetCallEnvelope>;
 declare const getGetCallKey: (id: string, params?: GetCallParams) => readonly [`/v1/calls/${string}`, ...GetCallParams[]];
-type GetCallQueryResult = NonNullable<Awaited$p<ReturnType<typeof getCall>>>;
+type GetCallQueryResult = NonNullable<Awaited$o<ReturnType<typeof getCall>>>;
 /**
  * @summary Get call
  */
 declare const useGetCall: <TError = ErrorType<ErrorResponse>>(id: string, params?: GetCallParams, options?: {
-    swr?: SWRConfiguration<Awaited$p<ReturnType<typeof getCall>>, TError> & {
+    swr?: SWRConfiguration<Awaited$o<ReturnType<typeof getCall>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$p<typeof customFetch>;
+    request?: SecondParameter$o<typeof customFetch>;
 }) => {
     data: GetCallEnvelope | undefined;
     error: TError | undefined;
@@ -14838,19 +14867,19 @@ declare const getCancelCallUrl: (id: string) => string;
  * @summary Cancel a scheduled call
  */
 declare const cancelCall: (id: string, options?: Parameters<typeof customFetch>[1]) => Promise<CancelCallEnvelope>;
-declare const getCancelCallMutationFetcher: (id: string, options?: SecondParameter$p<typeof customFetch>) => (_: Key, __: {
+declare const getCancelCallMutationFetcher: (id: string, options?: SecondParameter$o<typeof customFetch>) => (_: Key, __: {
     arg: Arguments;
 }) => Promise<CancelCallEnvelope>;
 declare const getCancelCallMutationKey: (id: string) => readonly [`/v1/calls/${string}/cancel`];
-type CancelCallMutationResult = NonNullable<Awaited$p<ReturnType<typeof cancelCall>>>;
+type CancelCallMutationResult = NonNullable<Awaited$o<ReturnType<typeof cancelCall>>>;
 /**
  * @summary Cancel a scheduled call
  */
 declare const useCancelCall: <TError = ErrorType<ErrorResponse>>(id: string, options?: {
-    swr?: SWRMutationConfiguration<Awaited$p<ReturnType<typeof cancelCall>>, TError, Key, Arguments, Awaited$p<ReturnType<typeof cancelCall>>> & {
+    swr?: SWRMutationConfiguration<Awaited$o<ReturnType<typeof cancelCall>>, TError, Key, Arguments, Awaited$o<ReturnType<typeof cancelCall>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$p<typeof customFetch>;
+    request?: SecondParameter$o<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<CancelCallEnvelope, TError, string | readonly [`/v1/calls/${string}/cancel`], Arguments>;
@@ -14866,16 +14895,16 @@ declare const getGetCallEvaluationUrl: (id: string) => string;
  */
 declare const getCallEvaluation: (id: string, options?: Parameters<typeof customFetch>[1]) => Promise<GetCallEvaluationEnvelope>;
 declare const getGetCallEvaluationKey: (id: string) => readonly [`/v1/calls/${string}/evaluation`];
-type GetCallEvaluationQueryResult = NonNullable<Awaited$p<ReturnType<typeof getCallEvaluation>>>;
+type GetCallEvaluationQueryResult = NonNullable<Awaited$o<ReturnType<typeof getCallEvaluation>>>;
 /**
  * @summary Get call evaluation
  */
 declare const useGetCallEvaluation: <TError = ErrorType<ErrorResponse>>(id: string, options?: {
-    swr?: SWRConfiguration<Awaited$p<ReturnType<typeof getCallEvaluation>>, TError> & {
+    swr?: SWRConfiguration<Awaited$o<ReturnType<typeof getCallEvaluation>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$p<typeof customFetch>;
+    request?: SecondParameter$o<typeof customFetch>;
 }) => {
     data: GetCallEvaluationEnvelope | undefined;
     error: TError | undefined;
@@ -14893,16 +14922,16 @@ declare const getGetCallAnalyticsUrl: (params: GetCallAnalyticsParams) => string
  */
 declare const getCallAnalytics: (params: GetCallAnalyticsParams, options?: Parameters<typeof customFetch>[1]) => Promise<GetCallAnalyticsEnvelope>;
 declare const getGetCallAnalyticsKey: (params: GetCallAnalyticsParams) => readonly ["/v1/calls/analytics", ...GetCallAnalyticsParams[]];
-type GetCallAnalyticsQueryResult = NonNullable<Awaited$p<ReturnType<typeof getCallAnalytics>>>;
+type GetCallAnalyticsQueryResult = NonNullable<Awaited$o<ReturnType<typeof getCallAnalytics>>>;
 /**
  * @summary Get call analytics
  */
 declare const useGetCallAnalytics: <TError = ErrorType<ErrorResponse>>(params: GetCallAnalyticsParams, options?: {
-    swr?: SWRConfiguration<Awaited$p<ReturnType<typeof getCallAnalytics>>, TError> & {
+    swr?: SWRConfiguration<Awaited$o<ReturnType<typeof getCallAnalytics>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$p<typeof customFetch>;
+    request?: SecondParameter$o<typeof customFetch>;
 }) => {
     data: GetCallAnalyticsEnvelope | undefined;
     error: TError | undefined;
@@ -14912,9 +14941,9 @@ declare const useGetCallAnalytics: <TError = ErrorType<ErrorResponse>>(params: G
     swrKey: string | false | readonly [any, ...unknown[]] | Record<any, any> | (() => Arguments);
 };
 
-type AwaitedInput$o<T> = PromiseLike<T> | T;
-type Awaited$o<O> = O extends AwaitedInput$o<infer T> ? T : never;
-type SecondParameter$o<T extends (...args: never) => unknown> = Parameters<T>[1];
+type AwaitedInput$n<T> = PromiseLike<T> | T;
+type Awaited$n<O> = O extends AwaitedInput$n<infer T> ? T : never;
+type SecondParameter$n<T extends (...args: never) => unknown> = Parameters<T>[1];
 declare const getListCasesUrl: (params?: ListCasesParams) => string;
 /**
  * List all cases for the current tenant, paginated, filterable, and sortable.
@@ -14922,16 +14951,16 @@ declare const getListCasesUrl: (params?: ListCasesParams) => string;
  */
 declare const listCases: (params?: ListCasesParams, options?: Parameters<typeof customFetch>[1]) => Promise<ListCasesEnvelope>;
 declare const getListCasesKey: (params?: ListCasesParams) => readonly ["/v1/cases", ...ListCasesParams[]];
-type ListCasesQueryResult = NonNullable<Awaited$o<ReturnType<typeof listCases>>>;
+type ListCasesQueryResult = NonNullable<Awaited$n<ReturnType<typeof listCases>>>;
 /**
  * @summary List cases
  */
 declare const useListCases: <TError = ErrorType<ErrorResponse>>(params?: ListCasesParams, options?: {
-    swr?: SWRConfiguration<Awaited$o<ReturnType<typeof listCases>>, TError> & {
+    swr?: SWRConfiguration<Awaited$n<ReturnType<typeof listCases>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$o<typeof customFetch>;
+    request?: SecondParameter$n<typeof customFetch>;
 }) => {
     data: ListCasesEnvelope | undefined;
     error: TError | undefined;
@@ -14948,19 +14977,19 @@ declare const getCreateCaseUrl: () => string;
  * @summary Create case
  */
 declare const createCase: (createCaseBody?: CreateCaseBody, options?: Parameters<typeof customFetch>[1]) => Promise<CreateCaseEnvelope>;
-declare const getCreateCaseMutationFetcher: (options?: SecondParameter$o<typeof customFetch>) => (_: Key, { arg }: {
+declare const getCreateCaseMutationFetcher: (options?: SecondParameter$n<typeof customFetch>) => (_: Key, { arg }: {
     arg: CreateCaseBody | undefined;
 }) => Promise<CreateCaseEnvelope>;
 declare const getCreateCaseMutationKey: () => readonly ["/v1/cases"];
-type CreateCaseMutationResult = NonNullable<Awaited$o<ReturnType<typeof createCase>>>;
+type CreateCaseMutationResult = NonNullable<Awaited$n<ReturnType<typeof createCase>>>;
 /**
  * @summary Create case
  */
 declare const useCreateCase: <TError = ErrorType<ErrorResponse>>(options?: {
-    swr?: SWRMutationConfiguration<Awaited$o<ReturnType<typeof createCase>>, TError, Key, CreateCaseBody | undefined, Awaited$o<ReturnType<typeof createCase>>> & {
+    swr?: SWRMutationConfiguration<Awaited$n<ReturnType<typeof createCase>>, TError, Key, CreateCaseBody | undefined, Awaited$n<ReturnType<typeof createCase>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$o<typeof customFetch>;
+    request?: SecondParameter$n<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<CreateCaseEnvelope, TError, string | readonly ["/v1/cases"], CreateCaseBody | undefined>;
@@ -14976,16 +15005,16 @@ declare const getSearchCasesUrl: (params: SearchCasesParams) => string;
  */
 declare const searchCases: (params: SearchCasesParams, options?: Parameters<typeof customFetch>[1]) => Promise<SearchCasesEnvelope>;
 declare const getSearchCasesKey: (params: SearchCasesParams) => readonly ["/v1/cases/search", ...SearchCasesParams[]];
-type SearchCasesQueryResult = NonNullable<Awaited$o<ReturnType<typeof searchCases>>>;
+type SearchCasesQueryResult = NonNullable<Awaited$n<ReturnType<typeof searchCases>>>;
 /**
  * @summary Search cases
  */
 declare const useSearchCases: <TError = ErrorType<ErrorResponse>>(params: SearchCasesParams, options?: {
-    swr?: SWRConfiguration<Awaited$o<ReturnType<typeof searchCases>>, TError> & {
+    swr?: SWRConfiguration<Awaited$n<ReturnType<typeof searchCases>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$o<typeof customFetch>;
+    request?: SecondParameter$n<typeof customFetch>;
 }) => {
     data: SearchCasesEnvelope | undefined;
     error: TError | undefined;
@@ -15004,16 +15033,16 @@ declare const getGetCaseUrl: (id: string, params?: GetCaseParams) => string;
  */
 declare const getCase: (id: string, params?: GetCaseParams, options?: Parameters<typeof customFetch>[1]) => Promise<GetCaseEnvelope>;
 declare const getGetCaseKey: (id: string, params?: GetCaseParams) => readonly [`/v1/cases/${string}`, ...GetCaseParams[]];
-type GetCaseQueryResult = NonNullable<Awaited$o<ReturnType<typeof getCase>>>;
+type GetCaseQueryResult = NonNullable<Awaited$n<ReturnType<typeof getCase>>>;
 /**
  * @summary Get case
  */
 declare const useGetCase: <TError = ErrorType<ErrorResponse>>(id: string, params?: GetCaseParams, options?: {
-    swr?: SWRConfiguration<Awaited$o<ReturnType<typeof getCase>>, TError> & {
+    swr?: SWRConfiguration<Awaited$n<ReturnType<typeof getCase>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$o<typeof customFetch>;
+    request?: SecondParameter$n<typeof customFetch>;
 }) => {
     data: GetCaseEnvelope | undefined;
     error: TError | undefined;
@@ -15032,19 +15061,19 @@ declare const getDeleteCaseUrl: (id: string, params?: DeleteCaseParams) => strin
  * @summary Delete case
  */
 declare const deleteCase: (id: string, params?: DeleteCaseParams, options?: Parameters<typeof customFetch>[1]) => Promise<DeleteCaseEnvelope>;
-declare const getDeleteCaseMutationFetcher: (id: string, params?: DeleteCaseParams, options?: SecondParameter$o<typeof customFetch>) => (_: Key, __: {
+declare const getDeleteCaseMutationFetcher: (id: string, params?: DeleteCaseParams, options?: SecondParameter$n<typeof customFetch>) => (_: Key, __: {
     arg: Arguments;
 }) => Promise<DeleteCaseEnvelope>;
 declare const getDeleteCaseMutationKey: (id: string, params?: DeleteCaseParams) => readonly [`/v1/cases/${string}`, ...DeleteCaseParams[]];
-type DeleteCaseMutationResult = NonNullable<Awaited$o<ReturnType<typeof deleteCase>>>;
+type DeleteCaseMutationResult = NonNullable<Awaited$n<ReturnType<typeof deleteCase>>>;
 /**
  * @summary Delete case
  */
 declare const useDeleteCase: <TError = ErrorType<ErrorResponse>>(id: string, params?: DeleteCaseParams, options?: {
-    swr?: SWRMutationConfiguration<Awaited$o<ReturnType<typeof deleteCase>>, TError, Key, Arguments, Awaited$o<ReturnType<typeof deleteCase>>> & {
+    swr?: SWRMutationConfiguration<Awaited$n<ReturnType<typeof deleteCase>>, TError, Key, Arguments, Awaited$n<ReturnType<typeof deleteCase>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$o<typeof customFetch>;
+    request?: SecondParameter$n<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<DeleteCaseEnvelope, TError, string | readonly [`/v1/cases/${string}`, ...DeleteCaseParams[]], Arguments>;
@@ -15061,19 +15090,19 @@ declare const getAddCaseLinksUrl: (id: string, params?: AddCaseLinksParams) => s
  * @summary Add case links
  */
 declare const addCaseLinks: (id: string, addCaseLinksBody?: AddCaseLinksBody, params?: AddCaseLinksParams, options?: Parameters<typeof customFetch>[1]) => Promise<AddCaseLinksEnvelope>;
-declare const getAddCaseLinksMutationFetcher: (id: string, params?: AddCaseLinksParams, options?: SecondParameter$o<typeof customFetch>) => (_: Key, { arg }: {
+declare const getAddCaseLinksMutationFetcher: (id: string, params?: AddCaseLinksParams, options?: SecondParameter$n<typeof customFetch>) => (_: Key, { arg }: {
     arg: AddCaseLinksBody | undefined;
 }) => Promise<AddCaseLinksEnvelope>;
 declare const getAddCaseLinksMutationKey: (id: string, params?: AddCaseLinksParams) => readonly [`/v1/cases/${string}/links`, ...AddCaseLinksParams[]];
-type AddCaseLinksMutationResult = NonNullable<Awaited$o<ReturnType<typeof addCaseLinks>>>;
+type AddCaseLinksMutationResult = NonNullable<Awaited$n<ReturnType<typeof addCaseLinks>>>;
 /**
  * @summary Add case links
  */
 declare const useAddCaseLinks: <TError = ErrorType<ErrorResponse>>(id: string, params?: AddCaseLinksParams, options?: {
-    swr?: SWRMutationConfiguration<Awaited$o<ReturnType<typeof addCaseLinks>>, TError, Key, AddCaseLinksBody | undefined, Awaited$o<ReturnType<typeof addCaseLinks>>> & {
+    swr?: SWRMutationConfiguration<Awaited$n<ReturnType<typeof addCaseLinks>>, TError, Key, AddCaseLinksBody | undefined, Awaited$n<ReturnType<typeof addCaseLinks>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$o<typeof customFetch>;
+    request?: SecondParameter$n<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<AddCaseLinksEnvelope, TError, string | readonly [`/v1/cases/${string}/links`, ...AddCaseLinksParams[]], AddCaseLinksBody | undefined>;
@@ -15089,16 +15118,16 @@ declare const getListCaseLinksUrl: (id: string, params?: ListCaseLinksParams) =>
  */
 declare const listCaseLinks: (id: string, params?: ListCaseLinksParams, options?: Parameters<typeof customFetch>[1]) => Promise<ListCaseLinksEnvelope>;
 declare const getListCaseLinksKey: (id: string, params?: ListCaseLinksParams) => readonly [`/v1/cases/${string}/links`, ...ListCaseLinksParams[]];
-type ListCaseLinksQueryResult = NonNullable<Awaited$o<ReturnType<typeof listCaseLinks>>>;
+type ListCaseLinksQueryResult = NonNullable<Awaited$n<ReturnType<typeof listCaseLinks>>>;
 /**
  * @summary List case links
  */
 declare const useListCaseLinks: <TError = ErrorType<ErrorResponse>>(id: string, params?: ListCaseLinksParams, options?: {
-    swr?: SWRConfiguration<Awaited$o<ReturnType<typeof listCaseLinks>>, TError> & {
+    swr?: SWRConfiguration<Awaited$n<ReturnType<typeof listCaseLinks>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$o<typeof customFetch>;
+    request?: SecondParameter$n<typeof customFetch>;
 }) => {
     data: ListCaseLinksEnvelope | undefined;
     error: TError | undefined;
@@ -15113,19 +15142,19 @@ declare const getRemoveCaseLinkUrl: (id: string, entityType: "artifact" | "call"
  * @summary Remove case link
  */
 declare const removeCaseLink: (id: string, entityType: "artifact" | "call" | "chat" | "email" | "extract" | "information_request" | "schedule" | "worker_run", entityId: string, params?: RemoveCaseLinkParams, options?: Parameters<typeof customFetch>[1]) => Promise<RemoveCaseLinkEnvelope>;
-declare const getRemoveCaseLinkMutationFetcher: (id: string, entityType: "artifact" | "call" | "chat" | "email" | "extract" | "information_request" | "schedule" | "worker_run", entityId: string, params?: RemoveCaseLinkParams, options?: SecondParameter$o<typeof customFetch>) => (_: Key, __: {
+declare const getRemoveCaseLinkMutationFetcher: (id: string, entityType: "artifact" | "call" | "chat" | "email" | "extract" | "information_request" | "schedule" | "worker_run", entityId: string, params?: RemoveCaseLinkParams, options?: SecondParameter$n<typeof customFetch>) => (_: Key, __: {
     arg: Arguments;
 }) => Promise<RemoveCaseLinkEnvelope>;
 declare const getRemoveCaseLinkMutationKey: (id: string, entityType: "artifact" | "call" | "chat" | "email" | "extract" | "information_request" | "schedule" | "worker_run", entityId: string, params?: RemoveCaseLinkParams) => readonly [`/v1/cases/${string}/links/artifact/${string}` | `/v1/cases/${string}/links/call/${string}` | `/v1/cases/${string}/links/chat/${string}` | `/v1/cases/${string}/links/email/${string}` | `/v1/cases/${string}/links/extract/${string}` | `/v1/cases/${string}/links/information_request/${string}` | `/v1/cases/${string}/links/schedule/${string}` | `/v1/cases/${string}/links/worker_run/${string}`, ...RemoveCaseLinkParams[]];
-type RemoveCaseLinkMutationResult = NonNullable<Awaited$o<ReturnType<typeof removeCaseLink>>>;
+type RemoveCaseLinkMutationResult = NonNullable<Awaited$n<ReturnType<typeof removeCaseLink>>>;
 /**
  * @summary Remove case link
  */
 declare const useRemoveCaseLink: <TError = ErrorType<ErrorResponse>>(id: string, entityType: "artifact" | "call" | "chat" | "email" | "extract" | "information_request" | "schedule" | "worker_run", entityId: string, params?: RemoveCaseLinkParams, options?: {
-    swr?: SWRMutationConfiguration<Awaited$o<ReturnType<typeof removeCaseLink>>, TError, Key, Arguments, Awaited$o<ReturnType<typeof removeCaseLink>>> & {
+    swr?: SWRMutationConfiguration<Awaited$n<ReturnType<typeof removeCaseLink>>, TError, Key, Arguments, Awaited$n<ReturnType<typeof removeCaseLink>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$o<typeof customFetch>;
+    request?: SecondParameter$n<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<RemoveCaseLinkEnvelope, TError, string | readonly [`/v1/cases/${string}/links/artifact/${string}` | `/v1/cases/${string}/links/call/${string}` | `/v1/cases/${string}/links/chat/${string}` | `/v1/cases/${string}/links/email/${string}` | `/v1/cases/${string}/links/extract/${string}` | `/v1/cases/${string}/links/information_request/${string}` | `/v1/cases/${string}/links/schedule/${string}` | `/v1/cases/${string}/links/worker_run/${string}`, ...RemoveCaseLinkParams[]], Arguments>;
@@ -15135,28 +15164,28 @@ declare const useRemoveCaseLink: <TError = ErrorType<ErrorResponse>>(id: string,
     swrKey: string | readonly [`/v1/cases/${string}/links/artifact/${string}` | `/v1/cases/${string}/links/call/${string}` | `/v1/cases/${string}/links/chat/${string}` | `/v1/cases/${string}/links/email/${string}` | `/v1/cases/${string}/links/extract/${string}` | `/v1/cases/${string}/links/information_request/${string}` | `/v1/cases/${string}/links/schedule/${string}` | `/v1/cases/${string}/links/worker_run/${string}`, ...RemoveCaseLinkParams[]];
 };
 
-type AwaitedInput$n<T> = PromiseLike<T> | T;
-type Awaited$n<O> = O extends AwaitedInput$n<infer T> ? T : never;
-type SecondParameter$n<T extends (...args: never) => unknown> = Parameters<T>[1];
+type AwaitedInput$m<T> = PromiseLike<T> | T;
+type Awaited$m<O> = O extends AwaitedInput$m<infer T> ? T : never;
+type SecondParameter$m<T extends (...args: never) => unknown> = Parameters<T>[1];
 declare const getCreateChatAgentUrl: () => string;
 /**
  * Create a new chat agent with a name and prompt.
  * @summary Create chat agent
  */
 declare const createChatAgent: (createChatAgentBody?: CreateChatAgentBody, options?: Parameters<typeof customFetch>[1]) => Promise<CreateChatAgentEnvelope>;
-declare const getCreateChatAgentMutationFetcher: (options?: SecondParameter$n<typeof customFetch>) => (_: Key, { arg }: {
+declare const getCreateChatAgentMutationFetcher: (options?: SecondParameter$m<typeof customFetch>) => (_: Key, { arg }: {
     arg: CreateChatAgentBody | undefined;
 }) => Promise<CreateChatAgentEnvelope>;
 declare const getCreateChatAgentMutationKey: () => readonly ["/v1/chat-agents"];
-type CreateChatAgentMutationResult = NonNullable<Awaited$n<ReturnType<typeof createChatAgent>>>;
+type CreateChatAgentMutationResult = NonNullable<Awaited$m<ReturnType<typeof createChatAgent>>>;
 /**
  * @summary Create chat agent
  */
 declare const useCreateChatAgent: <TError = ErrorType<ErrorResponse>>(options?: {
-    swr?: SWRMutationConfiguration<Awaited$n<ReturnType<typeof createChatAgent>>, TError, Key, CreateChatAgentBody | undefined, Awaited$n<ReturnType<typeof createChatAgent>>> & {
+    swr?: SWRMutationConfiguration<Awaited$m<ReturnType<typeof createChatAgent>>, TError, Key, CreateChatAgentBody | undefined, Awaited$m<ReturnType<typeof createChatAgent>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$n<typeof customFetch>;
+    request?: SecondParameter$m<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<CreateChatAgentEnvelope, TError, string | readonly ["/v1/chat-agents"], CreateChatAgentBody | undefined>;
@@ -15172,16 +15201,16 @@ declare const getListChatAgentsUrl: (params?: ListChatAgentsParams) => string;
  */
 declare const listChatAgents: (params?: ListChatAgentsParams, options?: Parameters<typeof customFetch>[1]) => Promise<ListChatAgentsEnvelope>;
 declare const getListChatAgentsKey: (params?: ListChatAgentsParams) => readonly ["/v1/chat-agents", ...ListChatAgentsParams[]];
-type ListChatAgentsQueryResult = NonNullable<Awaited$n<ReturnType<typeof listChatAgents>>>;
+type ListChatAgentsQueryResult = NonNullable<Awaited$m<ReturnType<typeof listChatAgents>>>;
 /**
  * @summary List chat agents
  */
 declare const useListChatAgents: <TError = ErrorType<ErrorResponse>>(params?: ListChatAgentsParams, options?: {
-    swr?: SWRConfiguration<Awaited$n<ReturnType<typeof listChatAgents>>, TError> & {
+    swr?: SWRConfiguration<Awaited$m<ReturnType<typeof listChatAgents>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$n<typeof customFetch>;
+    request?: SecondParameter$m<typeof customFetch>;
 }) => {
     data: ListChatAgentsEnvelope | undefined;
     error: TError | undefined;
@@ -15197,16 +15226,16 @@ declare const getGetChatAgentUrl: (chatAgentId: string) => string;
  */
 declare const getChatAgent: (chatAgentId: string, options?: Parameters<typeof customFetch>[1]) => Promise<GetChatAgentEnvelope>;
 declare const getGetChatAgentKey: (chatAgentId: string) => readonly [`/v1/chat-agents/${string}`];
-type GetChatAgentQueryResult = NonNullable<Awaited$n<ReturnType<typeof getChatAgent>>>;
+type GetChatAgentQueryResult = NonNullable<Awaited$m<ReturnType<typeof getChatAgent>>>;
 /**
  * @summary Get chat agent
  */
 declare const useGetChatAgent: <TError = ErrorType<ErrorResponse>>(chatAgentId: string, options?: {
-    swr?: SWRConfiguration<Awaited$n<ReturnType<typeof getChatAgent>>, TError> & {
+    swr?: SWRConfiguration<Awaited$m<ReturnType<typeof getChatAgent>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$n<typeof customFetch>;
+    request?: SecondParameter$m<typeof customFetch>;
 }) => {
     data: GetChatAgentEnvelope | undefined;
     error: TError | undefined;
@@ -15221,19 +15250,19 @@ declare const getUpdateChatAgentUrl: (chatAgentId: string) => string;
  * @summary Update chat agent
  */
 declare const updateChatAgent: (chatAgentId: string, updateChatAgentRequest?: UpdateChatAgentRequest, options?: Parameters<typeof customFetch>[1]) => Promise<UpdateChatAgentEnvelope>;
-declare const getUpdateChatAgentMutationFetcher: (chatAgentId: string, options?: SecondParameter$n<typeof customFetch>) => (_: Key, { arg }: {
+declare const getUpdateChatAgentMutationFetcher: (chatAgentId: string, options?: SecondParameter$m<typeof customFetch>) => (_: Key, { arg }: {
     arg: UpdateChatAgentRequest | undefined;
 }) => Promise<UpdateChatAgentEnvelope>;
 declare const getUpdateChatAgentMutationKey: (chatAgentId: string) => readonly [`/v1/chat-agents/${string}`];
-type UpdateChatAgentMutationResult = NonNullable<Awaited$n<ReturnType<typeof updateChatAgent>>>;
+type UpdateChatAgentMutationResult = NonNullable<Awaited$m<ReturnType<typeof updateChatAgent>>>;
 /**
  * @summary Update chat agent
  */
 declare const useUpdateChatAgent: <TError = ErrorType<ErrorResponse>>(chatAgentId: string, options?: {
-    swr?: SWRMutationConfiguration<Awaited$n<ReturnType<typeof updateChatAgent>>, TError, Key, UpdateChatAgentRequest | undefined, Awaited$n<ReturnType<typeof updateChatAgent>>> & {
+    swr?: SWRMutationConfiguration<Awaited$m<ReturnType<typeof updateChatAgent>>, TError, Key, UpdateChatAgentRequest | undefined, Awaited$m<ReturnType<typeof updateChatAgent>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$n<typeof customFetch>;
+    request?: SecondParameter$m<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<UpdateChatAgentEnvelope, TError, string | readonly [`/v1/chat-agents/${string}`], UpdateChatAgentRequest | undefined>;
@@ -15248,19 +15277,19 @@ declare const getDeleteChatAgentUrl: (chatAgentId: string) => string;
  * @summary Delete chat agent
  */
 declare const deleteChatAgent: (chatAgentId: string, options?: Parameters<typeof customFetch>[1]) => Promise<DeleteChatAgentEnvelope>;
-declare const getDeleteChatAgentMutationFetcher: (chatAgentId: string, options?: SecondParameter$n<typeof customFetch>) => (_: Key, __: {
+declare const getDeleteChatAgentMutationFetcher: (chatAgentId: string, options?: SecondParameter$m<typeof customFetch>) => (_: Key, __: {
     arg: Arguments;
 }) => Promise<DeleteChatAgentEnvelope>;
 declare const getDeleteChatAgentMutationKey: (chatAgentId: string) => readonly [`/v1/chat-agents/${string}`];
-type DeleteChatAgentMutationResult = NonNullable<Awaited$n<ReturnType<typeof deleteChatAgent>>>;
+type DeleteChatAgentMutationResult = NonNullable<Awaited$m<ReturnType<typeof deleteChatAgent>>>;
 /**
  * @summary Delete chat agent
  */
 declare const useDeleteChatAgent: <TError = ErrorType<ErrorResponse>>(chatAgentId: string, options?: {
-    swr?: SWRMutationConfiguration<Awaited$n<ReturnType<typeof deleteChatAgent>>, TError, Key, Arguments, Awaited$n<ReturnType<typeof deleteChatAgent>>> & {
+    swr?: SWRMutationConfiguration<Awaited$m<ReturnType<typeof deleteChatAgent>>, TError, Key, Arguments, Awaited$m<ReturnType<typeof deleteChatAgent>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$n<typeof customFetch>;
+    request?: SecondParameter$m<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<DeleteChatAgentEnvelope, TError, string | readonly [`/v1/chat-agents/${string}`], Arguments>;
@@ -15276,16 +15305,16 @@ declare const getGetChatAgentPromptUrl: (chatAgentId: string) => string;
  */
 declare const getChatAgentPrompt: (chatAgentId: string, options?: Parameters<typeof customFetch>[1]) => Promise<GetChatAgentPromptEnvelope>;
 declare const getGetChatAgentPromptKey: (chatAgentId: string) => readonly [`/v1/chat-agents/${string}/prompt`];
-type GetChatAgentPromptQueryResult = NonNullable<Awaited$n<ReturnType<typeof getChatAgentPrompt>>>;
+type GetChatAgentPromptQueryResult = NonNullable<Awaited$m<ReturnType<typeof getChatAgentPrompt>>>;
 /**
  * @summary Get chat agent prompt
  */
 declare const useGetChatAgentPrompt: <TError = ErrorType<ErrorResponse>>(chatAgentId: string, options?: {
-    swr?: SWRConfiguration<Awaited$n<ReturnType<typeof getChatAgentPrompt>>, TError> & {
+    swr?: SWRConfiguration<Awaited$m<ReturnType<typeof getChatAgentPrompt>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$n<typeof customFetch>;
+    request?: SecondParameter$m<typeof customFetch>;
 }) => {
     data: GetChatAgentPromptEnvelope | undefined;
     error: TError | undefined;
@@ -15300,19 +15329,19 @@ declare const getUpdateChatAgentPromptUrl: (chatAgentId: string) => string;
  * @summary Update chat agent prompt
  */
 declare const updateChatAgentPrompt: (chatAgentId: string, updateChatAgentPromptBody?: UpdateChatAgentPromptBody, options?: Parameters<typeof customFetch>[1]) => Promise<UpdateChatAgentPromptEnvelope>;
-declare const getUpdateChatAgentPromptMutationFetcher: (chatAgentId: string, options?: SecondParameter$n<typeof customFetch>) => (_: Key, { arg }: {
+declare const getUpdateChatAgentPromptMutationFetcher: (chatAgentId: string, options?: SecondParameter$m<typeof customFetch>) => (_: Key, { arg }: {
     arg: UpdateChatAgentPromptBody | undefined;
 }) => Promise<UpdateChatAgentPromptEnvelope>;
 declare const getUpdateChatAgentPromptMutationKey: (chatAgentId: string) => readonly [`/v1/chat-agents/${string}/prompt`];
-type UpdateChatAgentPromptMutationResult = NonNullable<Awaited$n<ReturnType<typeof updateChatAgentPrompt>>>;
+type UpdateChatAgentPromptMutationResult = NonNullable<Awaited$m<ReturnType<typeof updateChatAgentPrompt>>>;
 /**
  * @summary Update chat agent prompt
  */
 declare const useUpdateChatAgentPrompt: <TError = ErrorType<ErrorResponse>>(chatAgentId: string, options?: {
-    swr?: SWRMutationConfiguration<Awaited$n<ReturnType<typeof updateChatAgentPrompt>>, TError, Key, UpdateChatAgentPromptBody | undefined, Awaited$n<ReturnType<typeof updateChatAgentPrompt>>> & {
+    swr?: SWRMutationConfiguration<Awaited$m<ReturnType<typeof updateChatAgentPrompt>>, TError, Key, UpdateChatAgentPromptBody | undefined, Awaited$m<ReturnType<typeof updateChatAgentPrompt>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$n<typeof customFetch>;
+    request?: SecondParameter$m<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<UpdateChatAgentPromptEnvelope, TError, string | readonly [`/v1/chat-agents/${string}/prompt`], UpdateChatAgentPromptBody | undefined>;
@@ -15322,28 +15351,28 @@ declare const useUpdateChatAgentPrompt: <TError = ErrorType<ErrorResponse>>(chat
     swrKey: string | readonly [`/v1/chat-agents/${string}/prompt`];
 };
 
-type AwaitedInput$m<T> = PromiseLike<T> | T;
-type Awaited$m<O> = O extends AwaitedInput$m<infer T> ? T : never;
-type SecondParameter$m<T extends (...args: never) => unknown> = Parameters<T>[1];
+type AwaitedInput$l<T> = PromiseLike<T> | T;
+type Awaited$l<O> = O extends AwaitedInput$l<infer T> ? T : never;
+type SecondParameter$l<T extends (...args: never) => unknown> = Parameters<T>[1];
 declare const getCreateChatUrl: () => string;
 /**
  * Create a new chat against an existing chat agent. The chat agent's tenant becomes the owner of the chat. If the agent requires authentication (`identity_provider_id` on the public chat agent), send the identity token from `POST /public/v1/identity/token` in the `X-External-Identity-Token` header; without a valid token the request fails with 401.
  * @summary Create a chat
  */
 declare const createChat: (createChatBody?: CreateChatBody, options?: Parameters<typeof customFetch>[1]) => Promise<CreateChatEnvelope>;
-declare const getCreateChatMutationFetcher: (options?: SecondParameter$m<typeof customFetch>) => (_: Key, { arg }: {
+declare const getCreateChatMutationFetcher: (options?: SecondParameter$l<typeof customFetch>) => (_: Key, { arg }: {
     arg: CreateChatBody | undefined;
 }) => Promise<CreateChatEnvelope>;
 declare const getCreateChatMutationKey: () => readonly ["/public/v1/chats"];
-type CreateChatMutationResult = NonNullable<Awaited$m<ReturnType<typeof createChat>>>;
+type CreateChatMutationResult = NonNullable<Awaited$l<ReturnType<typeof createChat>>>;
 /**
  * @summary Create a chat
  */
 declare const useCreateChat: <TError = ErrorType<ErrorResponse>>(options?: {
-    swr?: SWRMutationConfiguration<Awaited$m<ReturnType<typeof createChat>>, TError, Key, CreateChatBody | undefined, Awaited$m<ReturnType<typeof createChat>>> & {
+    swr?: SWRMutationConfiguration<Awaited$l<ReturnType<typeof createChat>>, TError, Key, CreateChatBody | undefined, Awaited$l<ReturnType<typeof createChat>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$m<typeof customFetch>;
+    request?: SecondParameter$l<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<CreateChatEnvelope, TError, string | readonly ["/public/v1/chats"], CreateChatBody | undefined>;
@@ -15362,16 +15391,16 @@ declare const getGetChatUrl: (chatId: string) => string;
  */
 declare const getChat: (chatId: string, options?: Parameters<typeof customFetch>[1]) => Promise<GetChatEnvelope>;
 declare const getGetChatKey: (chatId: string) => readonly [`/public/v1/chats/${string}`];
-type GetChatQueryResult = NonNullable<Awaited$m<ReturnType<typeof getChat>>>;
+type GetChatQueryResult = NonNullable<Awaited$l<ReturnType<typeof getChat>>>;
 /**
  * @summary Get a chat
  */
 declare const useGetChat: <TError = ErrorType<ErrorResponse>>(chatId: string, options?: {
-    swr?: SWRConfiguration<Awaited$m<ReturnType<typeof getChat>>, TError> & {
+    swr?: SWRConfiguration<Awaited$l<ReturnType<typeof getChat>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$m<typeof customFetch>;
+    request?: SecondParameter$l<typeof customFetch>;
 }) => {
     data: GetChatEnvelope | undefined;
     error: TError | undefined;
@@ -15387,16 +15416,16 @@ declare const getGetPublicChatAgentUrl: (chatAgentId: string) => string;
  */
 declare const getPublicChatAgent: (chatAgentId: string, options?: Parameters<typeof customFetch>[1]) => Promise<GetPublicChatAgentEnvelope>;
 declare const getGetPublicChatAgentKey: (chatAgentId: string) => readonly [`/public/v1/chat-agents/${string}`];
-type GetPublicChatAgentQueryResult = NonNullable<Awaited$m<ReturnType<typeof getPublicChatAgent>>>;
+type GetPublicChatAgentQueryResult = NonNullable<Awaited$l<ReturnType<typeof getPublicChatAgent>>>;
 /**
  * @summary Get a chat agent (public)
  */
 declare const useGetPublicChatAgent: <TError = ErrorType<ErrorResponse>>(chatAgentId: string, options?: {
-    swr?: SWRConfiguration<Awaited$m<ReturnType<typeof getPublicChatAgent>>, TError> & {
+    swr?: SWRConfiguration<Awaited$l<ReturnType<typeof getPublicChatAgent>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$m<typeof customFetch>;
+    request?: SecondParameter$l<typeof customFetch>;
 }) => {
     data: GetPublicChatAgentEnvelope | undefined;
     error: TError | undefined;
@@ -15414,19 +15443,19 @@ declare const getPostChatMessageUrl: (chatId: string) => string;
  * @summary Post a message to a chat
  */
 declare const postChatMessage: (chatId: string, postChatMessageBody?: PostChatMessageBody, options?: Parameters<typeof customFetch>[1]) => Promise<PostChatMessageEnvelope>;
-declare const getPostChatMessageMutationFetcher: (chatId: string, options?: SecondParameter$m<typeof customFetch>) => (_: Key, { arg }: {
+declare const getPostChatMessageMutationFetcher: (chatId: string, options?: SecondParameter$l<typeof customFetch>) => (_: Key, { arg }: {
     arg: PostChatMessageBody | undefined;
 }) => Promise<PostChatMessageEnvelope>;
 declare const getPostChatMessageMutationKey: (chatId: string) => readonly [`/public/v1/chats/${string}/messages`];
-type PostChatMessageMutationResult = NonNullable<Awaited$m<ReturnType<typeof postChatMessage>>>;
+type PostChatMessageMutationResult = NonNullable<Awaited$l<ReturnType<typeof postChatMessage>>>;
 /**
  * @summary Post a message to a chat
  */
 declare const usePostChatMessage: <TError = ErrorType<ErrorResponse>>(chatId: string, options?: {
-    swr?: SWRMutationConfiguration<Awaited$m<ReturnType<typeof postChatMessage>>, TError, Key, PostChatMessageBody | undefined, Awaited$m<ReturnType<typeof postChatMessage>>> & {
+    swr?: SWRMutationConfiguration<Awaited$l<ReturnType<typeof postChatMessage>>, TError, Key, PostChatMessageBody | undefined, Awaited$l<ReturnType<typeof postChatMessage>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$m<typeof customFetch>;
+    request?: SecondParameter$l<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<PostChatMessageEnvelope, TError, string | readonly [`/public/v1/chats/${string}/messages`], PostChatMessageBody | undefined>;
@@ -15442,16 +15471,16 @@ declare const getListChatsUrl: (params?: ListChatsParams) => string;
  */
 declare const listChats: (params?: ListChatsParams, options?: Parameters<typeof customFetch>[1]) => Promise<ListChatsEnvelope>;
 declare const getListChatsKey: (params?: ListChatsParams) => readonly ["/v1/chats", ...ListChatsParams[]];
-type ListChatsQueryResult = NonNullable<Awaited$m<ReturnType<typeof listChats>>>;
+type ListChatsQueryResult = NonNullable<Awaited$l<ReturnType<typeof listChats>>>;
 /**
  * @summary List chats
  */
 declare const useListChats: <TError = ErrorType<ErrorResponse>>(params?: ListChatsParams, options?: {
-    swr?: SWRConfiguration<Awaited$m<ReturnType<typeof listChats>>, TError> & {
+    swr?: SWRConfiguration<Awaited$l<ReturnType<typeof listChats>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$m<typeof customFetch>;
+    request?: SecondParameter$l<typeof customFetch>;
 }) => {
     data: ListChatsEnvelope | undefined;
     error: TError | undefined;
@@ -15467,16 +15496,16 @@ declare const getListChatMessagesUrl: (chatId: string, params?: ListChatMessages
  */
 declare const listChatMessages: (chatId: string, params?: ListChatMessagesParams, options?: Parameters<typeof customFetch>[1]) => Promise<ListChatMessagesEnvelope>;
 declare const getListChatMessagesKey: (chatId: string, params?: ListChatMessagesParams) => readonly [`/v1/chats/${string}/messages`, ...ListChatMessagesParams[]];
-type ListChatMessagesQueryResult = NonNullable<Awaited$m<ReturnType<typeof listChatMessages>>>;
+type ListChatMessagesQueryResult = NonNullable<Awaited$l<ReturnType<typeof listChatMessages>>>;
 /**
  * @summary List chat messages
  */
 declare const useListChatMessages: <TError = ErrorType<ErrorResponse>>(chatId: string, params?: ListChatMessagesParams, options?: {
-    swr?: SWRConfiguration<Awaited$m<ReturnType<typeof listChatMessages>>, TError> & {
+    swr?: SWRConfiguration<Awaited$l<ReturnType<typeof listChatMessages>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$m<typeof customFetch>;
+    request?: SecondParameter$l<typeof customFetch>;
 }) => {
     data: ListChatMessagesEnvelope | undefined;
     error: TError | undefined;
@@ -15486,9 +15515,9 @@ declare const useListChatMessages: <TError = ErrorType<ErrorResponse>>(chatId: s
     swrKey: string | false | readonly [any, ...unknown[]] | Record<any, any> | (() => swr.Arguments);
 };
 
-type AwaitedInput$l<T> = PromiseLike<T> | T;
-type Awaited$l<O> = O extends AwaitedInput$l<infer T> ? T : never;
-type SecondParameter$l<T extends (...args: never) => unknown> = Parameters<T>[1];
+type AwaitedInput$k<T> = PromiseLike<T> | T;
+type Awaited$k<O> = O extends AwaitedInput$k<infer T> ? T : never;
+type SecondParameter$k<T extends (...args: never) => unknown> = Parameters<T>[1];
 declare const getListDispatchesUrl: (params?: ListDispatchesParams) => string;
 /**
  * List the organization's dispatches, newest occurrence first.
@@ -15508,16 +15537,16 @@ declare const getListDispatchesUrl: (params?: ListDispatchesParams) => string;
  */
 declare const listDispatches: (params?: ListDispatchesParams, options?: Parameters<typeof customFetch>[1]) => Promise<ListDispatchesEnvelope>;
 declare const getListDispatchesKey: (params?: ListDispatchesParams) => readonly ["/v1/dispatches", ...ListDispatchesParams[]];
-type ListDispatchesQueryResult = NonNullable<Awaited$l<ReturnType<typeof listDispatches>>>;
+type ListDispatchesQueryResult = NonNullable<Awaited$k<ReturnType<typeof listDispatches>>>;
 /**
  * @summary List dispatches
  */
 declare const useListDispatches: <TError = ErrorType<ErrorResponse>>(params?: ListDispatchesParams, options?: {
-    swr?: SWRConfiguration<Awaited$l<ReturnType<typeof listDispatches>>, TError> & {
+    swr?: SWRConfiguration<Awaited$k<ReturnType<typeof listDispatches>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$l<typeof customFetch>;
+    request?: SecondParameter$k<typeof customFetch>;
 }) => {
     data: ListDispatchesEnvelope | undefined;
     error: TError | undefined;
@@ -15527,9 +15556,9 @@ declare const useListDispatches: <TError = ErrorType<ErrorResponse>>(params?: Li
     swrKey: string | false | readonly [any, ...unknown[]] | Record<any, any> | (() => swr.Arguments);
 };
 
-type AwaitedInput$k<T> = PromiseLike<T> | T;
-type Awaited$k<O> = O extends AwaitedInput$k<infer T> ? T : never;
-type SecondParameter$k<T extends (...args: never) => unknown> = Parameters<T>[1];
+type AwaitedInput$j<T> = PromiseLike<T> | T;
+type Awaited$j<O> = O extends AwaitedInput$j<infer T> ? T : never;
+type SecondParameter$j<T extends (...args: never) => unknown> = Parameters<T>[1];
 declare const getGetEmailUrl: (emailId: string) => string;
 /**
  * Retrieve detailed information about a specific email, including full body content and the artifact IDs of its attachments.
@@ -15537,16 +15566,16 @@ declare const getGetEmailUrl: (emailId: string) => string;
  */
 declare const getEmail: (emailId: string, options?: Parameters<typeof customFetch>[1]) => Promise<GetEmailEnvelope>;
 declare const getGetEmailKey: (emailId: string) => readonly [`/v1/emails/${string}`];
-type GetEmailQueryResult = NonNullable<Awaited$k<ReturnType<typeof getEmail>>>;
+type GetEmailQueryResult = NonNullable<Awaited$j<ReturnType<typeof getEmail>>>;
 /**
  * @summary Get email
  */
 declare const useGetEmail: <TError = ErrorType<ErrorResponse>>(emailId: string, options?: {
-    swr?: SWRConfiguration<Awaited$k<ReturnType<typeof getEmail>>, TError> & {
+    swr?: SWRConfiguration<Awaited$j<ReturnType<typeof getEmail>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$k<typeof customFetch>;
+    request?: SecondParameter$j<typeof customFetch>;
 }) => {
     data: GetEmailEnvelope | undefined;
     error: TError | undefined;
@@ -15561,19 +15590,19 @@ declare const getDeleteEmailUrl: (emailId: string) => string;
  * @summary Delete email
  */
 declare const deleteEmail: (emailId: string, options?: Parameters<typeof customFetch>[1]) => Promise<DeleteEmailEnvelope>;
-declare const getDeleteEmailMutationFetcher: (emailId: string, options?: SecondParameter$k<typeof customFetch>) => (_: Key, __: {
+declare const getDeleteEmailMutationFetcher: (emailId: string, options?: SecondParameter$j<typeof customFetch>) => (_: Key, __: {
     arg: Arguments;
 }) => Promise<DeleteEmailEnvelope>;
 declare const getDeleteEmailMutationKey: (emailId: string) => readonly [`/v1/emails/${string}`];
-type DeleteEmailMutationResult = NonNullable<Awaited$k<ReturnType<typeof deleteEmail>>>;
+type DeleteEmailMutationResult = NonNullable<Awaited$j<ReturnType<typeof deleteEmail>>>;
 /**
  * @summary Delete email
  */
 declare const useDeleteEmail: <TError = ErrorType<ErrorResponse>>(emailId: string, options?: {
-    swr?: SWRMutationConfiguration<Awaited$k<ReturnType<typeof deleteEmail>>, TError, Key, Arguments, Awaited$k<ReturnType<typeof deleteEmail>>> & {
+    swr?: SWRMutationConfiguration<Awaited$j<ReturnType<typeof deleteEmail>>, TError, Key, Arguments, Awaited$j<ReturnType<typeof deleteEmail>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$k<typeof customFetch>;
+    request?: SecondParameter$j<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<DeleteEmailEnvelope, TError, string | readonly [`/v1/emails/${string}`], Arguments>;
@@ -15593,16 +15622,16 @@ declare const getListEmailsUrl: (params?: ListEmailsParams) => string;
  */
 declare const listEmails: (params?: ListEmailsParams, options?: Parameters<typeof customFetch>[1]) => Promise<ListEmailsEnvelope>;
 declare const getListEmailsKey: (params?: ListEmailsParams) => readonly ["/v1/emails", ...ListEmailsParams[]];
-type ListEmailsQueryResult = NonNullable<Awaited$k<ReturnType<typeof listEmails>>>;
+type ListEmailsQueryResult = NonNullable<Awaited$j<ReturnType<typeof listEmails>>>;
 /**
  * @summary List emails
  */
 declare const useListEmails: <TError = ErrorType<ErrorResponse>>(params?: ListEmailsParams, options?: {
-    swr?: SWRConfiguration<Awaited$k<ReturnType<typeof listEmails>>, TError> & {
+    swr?: SWRConfiguration<Awaited$j<ReturnType<typeof listEmails>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$k<typeof customFetch>;
+    request?: SecondParameter$j<typeof customFetch>;
 }) => {
     data: ListEmailsEnvelope | undefined;
     error: TError | undefined;
@@ -15622,16 +15651,16 @@ declare const getListEmailThreadsUrl: (params?: ListEmailThreadsParams) => strin
  */
 declare const listEmailThreads: (params?: ListEmailThreadsParams, options?: Parameters<typeof customFetch>[1]) => Promise<ListEmailThreadsEnvelope>;
 declare const getListEmailThreadsKey: (params?: ListEmailThreadsParams) => readonly ["/v1/emails/threads", ...ListEmailThreadsParams[]];
-type ListEmailThreadsQueryResult = NonNullable<Awaited$k<ReturnType<typeof listEmailThreads>>>;
+type ListEmailThreadsQueryResult = NonNullable<Awaited$j<ReturnType<typeof listEmailThreads>>>;
 /**
  * @summary List email threads
  */
 declare const useListEmailThreads: <TError = ErrorType<ErrorResponse>>(params?: ListEmailThreadsParams, options?: {
-    swr?: SWRConfiguration<Awaited$k<ReturnType<typeof listEmailThreads>>, TError> & {
+    swr?: SWRConfiguration<Awaited$j<ReturnType<typeof listEmailThreads>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$k<typeof customFetch>;
+    request?: SecondParameter$j<typeof customFetch>;
 }) => {
     data: ListEmailThreadsEnvelope | undefined;
     error: TError | undefined;
@@ -15650,19 +15679,19 @@ declare const getReplyToEmailUrl: (emailId: string) => string;
  * @summary Reply to email
  */
 declare const replyToEmail: (emailId: string, replyToEmailBody?: ReplyToEmailBody, options?: Parameters<typeof customFetch>[1]) => Promise<ReplyToEmailEnvelope>;
-declare const getReplyToEmailMutationFetcher: (emailId: string, options?: SecondParameter$k<typeof customFetch>) => (_: Key, { arg }: {
+declare const getReplyToEmailMutationFetcher: (emailId: string, options?: SecondParameter$j<typeof customFetch>) => (_: Key, { arg }: {
     arg: ReplyToEmailBody | undefined;
 }) => Promise<ReplyToEmailEnvelope>;
 declare const getReplyToEmailMutationKey: (emailId: string) => readonly [`/v1/emails/${string}/reply`];
-type ReplyToEmailMutationResult = NonNullable<Awaited$k<ReturnType<typeof replyToEmail>>>;
+type ReplyToEmailMutationResult = NonNullable<Awaited$j<ReturnType<typeof replyToEmail>>>;
 /**
  * @summary Reply to email
  */
 declare const useReplyToEmail: <TError = ErrorType<ErrorResponse>>(emailId: string, options?: {
-    swr?: SWRMutationConfiguration<Awaited$k<ReturnType<typeof replyToEmail>>, TError, Key, ReplyToEmailBody | undefined, Awaited$k<ReturnType<typeof replyToEmail>>> & {
+    swr?: SWRMutationConfiguration<Awaited$j<ReturnType<typeof replyToEmail>>, TError, Key, ReplyToEmailBody | undefined, Awaited$j<ReturnType<typeof replyToEmail>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$k<typeof customFetch>;
+    request?: SecondParameter$j<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<ReplyToEmailEnvelope, TError, string | readonly [`/v1/emails/${string}/reply`], ReplyToEmailBody | undefined>;
@@ -15679,19 +15708,19 @@ declare const getSendEmailUrl: () => string;
  * @summary Send email
  */
 declare const sendEmail: (sendEmailBody?: SendEmailBody, options?: Parameters<typeof customFetch>[1]) => Promise<SendEmailEnvelope>;
-declare const getSendEmailMutationFetcher: (options?: SecondParameter$k<typeof customFetch>) => (_: Key, { arg }: {
+declare const getSendEmailMutationFetcher: (options?: SecondParameter$j<typeof customFetch>) => (_: Key, { arg }: {
     arg: SendEmailBody | undefined;
 }) => Promise<SendEmailEnvelope>;
 declare const getSendEmailMutationKey: () => readonly ["/v1/emails/send"];
-type SendEmailMutationResult = NonNullable<Awaited$k<ReturnType<typeof sendEmail>>>;
+type SendEmailMutationResult = NonNullable<Awaited$j<ReturnType<typeof sendEmail>>>;
 /**
  * @summary Send email
  */
 declare const useSendEmail: <TError = ErrorType<ErrorResponse>>(options?: {
-    swr?: SWRMutationConfiguration<Awaited$k<ReturnType<typeof sendEmail>>, TError, Key, SendEmailBody | undefined, Awaited$k<ReturnType<typeof sendEmail>>> & {
+    swr?: SWRMutationConfiguration<Awaited$j<ReturnType<typeof sendEmail>>, TError, Key, SendEmailBody | undefined, Awaited$j<ReturnType<typeof sendEmail>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$k<typeof customFetch>;
+    request?: SecondParameter$j<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<SendEmailEnvelope, TError, string | readonly ["/v1/emails/send"], SendEmailBody | undefined>;
@@ -15701,28 +15730,28 @@ declare const useSendEmail: <TError = ErrorType<ErrorResponse>>(options?: {
     swrKey: string | readonly ["/v1/emails/send"];
 };
 
-type AwaitedInput$j<T> = PromiseLike<T> | T;
-type Awaited$j<O> = O extends AwaitedInput$j<infer T> ? T : never;
-type SecondParameter$j<T extends (...args: never) => unknown> = Parameters<T>[1];
+type AwaitedInput$i<T> = PromiseLike<T> | T;
+type Awaited$i<O> = O extends AwaitedInput$i<infer T> ? T : never;
+type SecondParameter$i<T extends (...args: never) => unknown> = Parameters<T>[1];
 declare const getCreateWorkerEvalFromRunUrl: (workerRunId: string) => string;
 /**
  * Snapshot a worker run's trigger and resolved artifacts, and record its MCP tool responses from telemetry for replay. Each assertion is graded PASS/FAIL independently on every run.
  * @summary Create a worker eval from a run
  */
 declare const createWorkerEvalFromRun: (workerRunId: string, createWorkerEvalFromRunBody?: CreateWorkerEvalFromRunBody, options?: Parameters<typeof customFetch>[1]) => Promise<CreateWorkerEvalFromRunEnvelope>;
-declare const getCreateWorkerEvalFromRunMutationFetcher: (workerRunId: string, options?: SecondParameter$j<typeof customFetch>) => (_: Key, { arg }: {
+declare const getCreateWorkerEvalFromRunMutationFetcher: (workerRunId: string, options?: SecondParameter$i<typeof customFetch>) => (_: Key, { arg }: {
     arg: CreateWorkerEvalFromRunBody | undefined;
 }) => Promise<CreateWorkerEvalFromRunEnvelope>;
 declare const getCreateWorkerEvalFromRunMutationKey: (workerRunId: string) => readonly [`/v1/worker-runs/${string}/evals`];
-type CreateWorkerEvalFromRunMutationResult = NonNullable<Awaited$j<ReturnType<typeof createWorkerEvalFromRun>>>;
+type CreateWorkerEvalFromRunMutationResult = NonNullable<Awaited$i<ReturnType<typeof createWorkerEvalFromRun>>>;
 /**
  * @summary Create a worker eval from a run
  */
 declare const useCreateWorkerEvalFromRun: <TError = ErrorType<ErrorResponse>>(workerRunId: string, options?: {
-    swr?: SWRMutationConfiguration<Awaited$j<ReturnType<typeof createWorkerEvalFromRun>>, TError, Key, CreateWorkerEvalFromRunBody | undefined, Awaited$j<ReturnType<typeof createWorkerEvalFromRun>>> & {
+    swr?: SWRMutationConfiguration<Awaited$i<ReturnType<typeof createWorkerEvalFromRun>>, TError, Key, CreateWorkerEvalFromRunBody | undefined, Awaited$i<ReturnType<typeof createWorkerEvalFromRun>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$j<typeof customFetch>;
+    request?: SecondParameter$i<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<CreateWorkerEvalFromRunEnvelope, TError, string | readonly [`/v1/worker-runs/${string}/evals`], CreateWorkerEvalFromRunBody | undefined>;
@@ -15737,19 +15766,19 @@ declare const getRunEvalUrl: (evalId: string) => string;
  * @summary Run an eval
  */
 declare const runEval: (evalId: string, runEvalBody?: RunEvalBody, options?: Parameters<typeof customFetch>[1]) => Promise<RunEvalEnvelope>;
-declare const getRunEvalMutationFetcher: (evalId: string, options?: SecondParameter$j<typeof customFetch>) => (_: Key, { arg }: {
+declare const getRunEvalMutationFetcher: (evalId: string, options?: SecondParameter$i<typeof customFetch>) => (_: Key, { arg }: {
     arg: RunEvalBody | undefined;
 }) => Promise<RunEvalEnvelope>;
 declare const getRunEvalMutationKey: (evalId: string) => readonly [`/v1/evals/${string}/runs`];
-type RunEvalMutationResult = NonNullable<Awaited$j<ReturnType<typeof runEval>>>;
+type RunEvalMutationResult = NonNullable<Awaited$i<ReturnType<typeof runEval>>>;
 /**
  * @summary Run an eval
  */
 declare const useRunEval: <TError = ErrorType<ErrorResponse>>(evalId: string, options?: {
-    swr?: SWRMutationConfiguration<Awaited$j<ReturnType<typeof runEval>>, TError, Key, RunEvalBody | undefined, Awaited$j<ReturnType<typeof runEval>>> & {
+    swr?: SWRMutationConfiguration<Awaited$i<ReturnType<typeof runEval>>, TError, Key, RunEvalBody | undefined, Awaited$i<ReturnType<typeof runEval>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$j<typeof customFetch>;
+    request?: SecondParameter$i<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<RunEvalEnvelope, TError, string | readonly [`/v1/evals/${string}/runs`], RunEvalBody | undefined>;
@@ -15765,16 +15794,16 @@ declare const getGetEvalRunUrl: (evalRunId: string) => string;
  */
 declare const getEvalRun: (evalRunId: string, options?: Parameters<typeof customFetch>[1]) => Promise<GetEvalRunEnvelope>;
 declare const getGetEvalRunKey: (evalRunId: string) => readonly [`/v1/eval-runs/${string}`];
-type GetEvalRunQueryResult = NonNullable<Awaited$j<ReturnType<typeof getEvalRun>>>;
+type GetEvalRunQueryResult = NonNullable<Awaited$i<ReturnType<typeof getEvalRun>>>;
 /**
  * @summary Get an eval run
  */
 declare const useGetEvalRun: <TError = ErrorType<ErrorResponse>>(evalRunId: string, options?: {
-    swr?: SWRConfiguration<Awaited$j<ReturnType<typeof getEvalRun>>, TError> & {
+    swr?: SWRConfiguration<Awaited$i<ReturnType<typeof getEvalRun>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$j<typeof customFetch>;
+    request?: SecondParameter$i<typeof customFetch>;
 }) => {
     data: GetEvalRunEnvelope | undefined;
     error: TError | undefined;
@@ -15789,19 +15818,19 @@ declare const getCreateEvalBenchmarkUrl: (evalId: string) => string;
  * @summary Benchmark two worker versions on an eval
  */
 declare const createEvalBenchmark: (evalId: string, createEvalBenchmarkBody?: CreateEvalBenchmarkBody, options?: Parameters<typeof customFetch>[1]) => Promise<CreateEvalBenchmarkEnvelope>;
-declare const getCreateEvalBenchmarkMutationFetcher: (evalId: string, options?: SecondParameter$j<typeof customFetch>) => (_: Key, { arg }: {
+declare const getCreateEvalBenchmarkMutationFetcher: (evalId: string, options?: SecondParameter$i<typeof customFetch>) => (_: Key, { arg }: {
     arg: CreateEvalBenchmarkBody | undefined;
 }) => Promise<CreateEvalBenchmarkEnvelope>;
 declare const getCreateEvalBenchmarkMutationKey: (evalId: string) => readonly [`/v1/evals/${string}/benchmarks`];
-type CreateEvalBenchmarkMutationResult = NonNullable<Awaited$j<ReturnType<typeof createEvalBenchmark>>>;
+type CreateEvalBenchmarkMutationResult = NonNullable<Awaited$i<ReturnType<typeof createEvalBenchmark>>>;
 /**
  * @summary Benchmark two worker versions on an eval
  */
 declare const useCreateEvalBenchmark: <TError = ErrorType<ErrorResponse>>(evalId: string, options?: {
-    swr?: SWRMutationConfiguration<Awaited$j<ReturnType<typeof createEvalBenchmark>>, TError, Key, CreateEvalBenchmarkBody | undefined, Awaited$j<ReturnType<typeof createEvalBenchmark>>> & {
+    swr?: SWRMutationConfiguration<Awaited$i<ReturnType<typeof createEvalBenchmark>>, TError, Key, CreateEvalBenchmarkBody | undefined, Awaited$i<ReturnType<typeof createEvalBenchmark>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$j<typeof customFetch>;
+    request?: SecondParameter$i<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<CreateEvalBenchmarkEnvelope, TError, string | readonly [`/v1/evals/${string}/benchmarks`], CreateEvalBenchmarkBody | undefined>;
@@ -15817,16 +15846,16 @@ declare const getListEvalBenchmarksUrl: (evalId: string, params?: ListEvalBenchm
  */
 declare const listEvalBenchmarks: (evalId: string, params?: ListEvalBenchmarksParams, options?: Parameters<typeof customFetch>[1]) => Promise<ListEvalBenchmarksEnvelope>;
 declare const getListEvalBenchmarksKey: (evalId: string, params?: ListEvalBenchmarksParams) => readonly [`/v1/evals/${string}/benchmarks`, ...ListEvalBenchmarksParams[]];
-type ListEvalBenchmarksQueryResult = NonNullable<Awaited$j<ReturnType<typeof listEvalBenchmarks>>>;
+type ListEvalBenchmarksQueryResult = NonNullable<Awaited$i<ReturnType<typeof listEvalBenchmarks>>>;
 /**
  * @summary List an eval's benchmarks
  */
 declare const useListEvalBenchmarks: <TError = ErrorType<ErrorResponse>>(evalId: string, params?: ListEvalBenchmarksParams, options?: {
-    swr?: SWRConfiguration<Awaited$j<ReturnType<typeof listEvalBenchmarks>>, TError> & {
+    swr?: SWRConfiguration<Awaited$i<ReturnType<typeof listEvalBenchmarks>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$j<typeof customFetch>;
+    request?: SecondParameter$i<typeof customFetch>;
 }) => {
     data: ListEvalBenchmarksEnvelope | undefined;
     error: TError | undefined;
@@ -15842,16 +15871,16 @@ declare const getGetBenchmarkUrl: (benchmarkId: string) => string;
  */
 declare const getBenchmark: (benchmarkId: string, options?: Parameters<typeof customFetch>[1]) => Promise<GetBenchmarkEnvelope>;
 declare const getGetBenchmarkKey: (benchmarkId: string) => readonly [`/v1/benchmarks/${string}`];
-type GetBenchmarkQueryResult = NonNullable<Awaited$j<ReturnType<typeof getBenchmark>>>;
+type GetBenchmarkQueryResult = NonNullable<Awaited$i<ReturnType<typeof getBenchmark>>>;
 /**
  * @summary Get a benchmark
  */
 declare const useGetBenchmark: <TError = ErrorType<ErrorResponse>>(benchmarkId: string, options?: {
-    swr?: SWRConfiguration<Awaited$j<ReturnType<typeof getBenchmark>>, TError> & {
+    swr?: SWRConfiguration<Awaited$i<ReturnType<typeof getBenchmark>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$j<typeof customFetch>;
+    request?: SecondParameter$i<typeof customFetch>;
 }) => {
     data: GetBenchmarkEnvelope | undefined;
     error: TError | undefined;
@@ -15867,16 +15896,16 @@ declare const getListWorkerEvalsUrl: (workerId: string, params?: ListWorkerEvals
  */
 declare const listWorkerEvals: (workerId: string, params?: ListWorkerEvalsParams, options?: Parameters<typeof customFetch>[1]) => Promise<ListWorkerEvalsEnvelope>;
 declare const getListWorkerEvalsKey: (workerId: string, params?: ListWorkerEvalsParams) => readonly [`/v1/workers/${string}/evals`, ...ListWorkerEvalsParams[]];
-type ListWorkerEvalsQueryResult = NonNullable<Awaited$j<ReturnType<typeof listWorkerEvals>>>;
+type ListWorkerEvalsQueryResult = NonNullable<Awaited$i<ReturnType<typeof listWorkerEvals>>>;
 /**
  * @summary List a worker's evals
  */
 declare const useListWorkerEvals: <TError = ErrorType<ErrorResponse>>(workerId: string, params?: ListWorkerEvalsParams, options?: {
-    swr?: SWRConfiguration<Awaited$j<ReturnType<typeof listWorkerEvals>>, TError> & {
+    swr?: SWRConfiguration<Awaited$i<ReturnType<typeof listWorkerEvals>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$j<typeof customFetch>;
+    request?: SecondParameter$i<typeof customFetch>;
 }) => {
     data: ListWorkerEvalsEnvelope | undefined;
     error: TError | undefined;
@@ -15891,19 +15920,19 @@ declare const getCreateWorkerBenchmarksUrl: (workerId: string) => string;
  * @summary Benchmark two worker versions on all of the worker's evals
  */
 declare const createWorkerBenchmarks: (workerId: string, createWorkerBenchmarksBody?: CreateWorkerBenchmarksBody, options?: Parameters<typeof customFetch>[1]) => Promise<CreateWorkerBenchmarksEnvelope>;
-declare const getCreateWorkerBenchmarksMutationFetcher: (workerId: string, options?: SecondParameter$j<typeof customFetch>) => (_: Key, { arg }: {
+declare const getCreateWorkerBenchmarksMutationFetcher: (workerId: string, options?: SecondParameter$i<typeof customFetch>) => (_: Key, { arg }: {
     arg: CreateWorkerBenchmarksBody | undefined;
 }) => Promise<CreateWorkerBenchmarksEnvelope>;
 declare const getCreateWorkerBenchmarksMutationKey: (workerId: string) => readonly [`/v1/workers/${string}/benchmarks`];
-type CreateWorkerBenchmarksMutationResult = NonNullable<Awaited$j<ReturnType<typeof createWorkerBenchmarks>>>;
+type CreateWorkerBenchmarksMutationResult = NonNullable<Awaited$i<ReturnType<typeof createWorkerBenchmarks>>>;
 /**
  * @summary Benchmark two worker versions on all of the worker's evals
  */
 declare const useCreateWorkerBenchmarks: <TError = ErrorType<ErrorResponse>>(workerId: string, options?: {
-    swr?: SWRMutationConfiguration<Awaited$j<ReturnType<typeof createWorkerBenchmarks>>, TError, Key, CreateWorkerBenchmarksBody | undefined, Awaited$j<ReturnType<typeof createWorkerBenchmarks>>> & {
+    swr?: SWRMutationConfiguration<Awaited$i<ReturnType<typeof createWorkerBenchmarks>>, TError, Key, CreateWorkerBenchmarksBody | undefined, Awaited$i<ReturnType<typeof createWorkerBenchmarks>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$j<typeof customFetch>;
+    request?: SecondParameter$i<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<CreateWorkerBenchmarksEnvelope, TError, string | readonly [`/v1/workers/${string}/benchmarks`], CreateWorkerBenchmarksBody | undefined>;
@@ -15913,9 +15942,9 @@ declare const useCreateWorkerBenchmarks: <TError = ErrorType<ErrorResponse>>(wor
     swrKey: string | readonly [`/v1/workers/${string}/benchmarks`];
 };
 
-type AwaitedInput$i<T> = PromiseLike<T> | T;
-type Awaited$i<O> = O extends AwaitedInput$i<infer T> ? T : never;
-type SecondParameter$i<T extends (...args: never) => unknown> = Parameters<T>[1];
+type AwaitedInput$h<T> = PromiseLike<T> | T;
+type Awaited$h<O> = O extends AwaitedInput$h<infer T> ? T : never;
+type SecondParameter$h<T extends (...args: never) => unknown> = Parameters<T>[1];
 declare const getListExtractorJobsUrl: (params?: ListExtractorJobsParams) => string;
 /**
  * List all extraction jobs with pagination, filtering, and sorting.
@@ -15932,16 +15961,16 @@ declare const getListExtractorJobsUrl: (params?: ListExtractorJobsParams) => str
  */
 declare const listExtractorJobs: (params?: ListExtractorJobsParams, options?: Parameters<typeof customFetch>[1]) => Promise<ListExtractorJobsEnvelope>;
 declare const getListExtractorJobsKey: (params?: ListExtractorJobsParams) => readonly ["/v1/extractor-jobs", ...ListExtractorJobsParams[]];
-type ListExtractorJobsQueryResult = NonNullable<Awaited$i<ReturnType<typeof listExtractorJobs>>>;
+type ListExtractorJobsQueryResult = NonNullable<Awaited$h<ReturnType<typeof listExtractorJobs>>>;
 /**
  * @summary List extractor jobs
  */
 declare const useListExtractorJobs: <TError = ErrorType<ErrorResponse>>(params?: ListExtractorJobsParams, options?: {
-    swr?: SWRConfiguration<Awaited$i<ReturnType<typeof listExtractorJobs>>, TError> & {
+    swr?: SWRConfiguration<Awaited$h<ReturnType<typeof listExtractorJobs>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$i<typeof customFetch>;
+    request?: SecondParameter$h<typeof customFetch>;
 }) => {
     data: ListExtractorJobsEnvelope | undefined;
     error: TError | undefined;
@@ -15958,19 +15987,19 @@ declare const getCreateExtractorJobUrl: () => string;
  * @summary Create extractor job
  */
 declare const createExtractorJob: (createExtractorJobBody?: CreateExtractorJobBody, options?: Parameters<typeof customFetch>[1]) => Promise<CreateExtractorJobEnvelope>;
-declare const getCreateExtractorJobMutationFetcher: (options?: SecondParameter$i<typeof customFetch>) => (_: Key, { arg }: {
+declare const getCreateExtractorJobMutationFetcher: (options?: SecondParameter$h<typeof customFetch>) => (_: Key, { arg }: {
     arg: CreateExtractorJobBody | undefined;
 }) => Promise<CreateExtractorJobEnvelope>;
 declare const getCreateExtractorJobMutationKey: () => readonly ["/v1/extractor-jobs"];
-type CreateExtractorJobMutationResult = NonNullable<Awaited$i<ReturnType<typeof createExtractorJob>>>;
+type CreateExtractorJobMutationResult = NonNullable<Awaited$h<ReturnType<typeof createExtractorJob>>>;
 /**
  * @summary Create extractor job
  */
 declare const useCreateExtractorJob: <TError = ErrorType<ErrorResponse>>(options?: {
-    swr?: SWRMutationConfiguration<Awaited$i<ReturnType<typeof createExtractorJob>>, TError, Key, CreateExtractorJobBody | undefined, Awaited$i<ReturnType<typeof createExtractorJob>>> & {
+    swr?: SWRMutationConfiguration<Awaited$h<ReturnType<typeof createExtractorJob>>, TError, Key, CreateExtractorJobBody | undefined, Awaited$h<ReturnType<typeof createExtractorJob>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$i<typeof customFetch>;
+    request?: SecondParameter$h<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<CreateExtractorJobEnvelope, TError, string | readonly ["/v1/extractor-jobs"], CreateExtractorJobBody | undefined>;
@@ -15986,16 +16015,16 @@ declare const getGetExtractorJobUrl: (id: string) => string;
  */
 declare const getExtractorJob: (id: string, options?: Parameters<typeof customFetch>[1]) => Promise<GetExtractorJobEnvelope>;
 declare const getGetExtractorJobKey: (id: string) => readonly [`/v1/extractor-jobs/${string}`];
-type GetExtractorJobQueryResult = NonNullable<Awaited$i<ReturnType<typeof getExtractorJob>>>;
+type GetExtractorJobQueryResult = NonNullable<Awaited$h<ReturnType<typeof getExtractorJob>>>;
 /**
  * @summary Get extractor job
  */
 declare const useGetExtractorJob: <TError = ErrorType<ErrorResponse>>(id: string, options?: {
-    swr?: SWRConfiguration<Awaited$i<ReturnType<typeof getExtractorJob>>, TError> & {
+    swr?: SWRConfiguration<Awaited$h<ReturnType<typeof getExtractorJob>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$i<typeof customFetch>;
+    request?: SecondParameter$h<typeof customFetch>;
 }) => {
     data: GetExtractorJobEnvelope | undefined;
     error: TError | undefined;
@@ -16005,28 +16034,28 @@ declare const useGetExtractorJob: <TError = ErrorType<ErrorResponse>>(id: string
     swrKey: string | false | readonly [any, ...unknown[]] | Record<any, any> | (() => swr.Arguments);
 };
 
-type AwaitedInput$h<T> = PromiseLike<T> | T;
-type Awaited$h<O> = O extends AwaitedInput$h<infer T> ? T : never;
-type SecondParameter$h<T extends (...args: never) => unknown> = Parameters<T>[1];
+type AwaitedInput$g<T> = PromiseLike<T> | T;
+type Awaited$g<O> = O extends AwaitedInput$g<infer T> ? T : never;
+type SecondParameter$g<T extends (...args: never) => unknown> = Parameters<T>[1];
 declare const getCreateExtractorUrl: () => string;
 /**
  * Create a new extractor with a name and JSON schema defining the extraction output format.
  * @summary Create extractor
  */
 declare const createExtractor: (createExtractorBody?: CreateExtractorBody, options?: Parameters<typeof customFetch>[1]) => Promise<CreateExtractorEnvelope>;
-declare const getCreateExtractorMutationFetcher: (options?: SecondParameter$h<typeof customFetch>) => (_: Key, { arg }: {
+declare const getCreateExtractorMutationFetcher: (options?: SecondParameter$g<typeof customFetch>) => (_: Key, { arg }: {
     arg: CreateExtractorBody | undefined;
 }) => Promise<CreateExtractorEnvelope>;
 declare const getCreateExtractorMutationKey: () => readonly ["/v1/extractors"];
-type CreateExtractorMutationResult = NonNullable<Awaited$h<ReturnType<typeof createExtractor>>>;
+type CreateExtractorMutationResult = NonNullable<Awaited$g<ReturnType<typeof createExtractor>>>;
 /**
  * @summary Create extractor
  */
 declare const useCreateExtractor: <TError = ErrorType<ErrorResponse>>(options?: {
-    swr?: SWRMutationConfiguration<Awaited$h<ReturnType<typeof createExtractor>>, TError, Key, CreateExtractorBody | undefined, Awaited$h<ReturnType<typeof createExtractor>>> & {
+    swr?: SWRMutationConfiguration<Awaited$g<ReturnType<typeof createExtractor>>, TError, Key, CreateExtractorBody | undefined, Awaited$g<ReturnType<typeof createExtractor>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$h<typeof customFetch>;
+    request?: SecondParameter$g<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<CreateExtractorEnvelope, TError, string | readonly ["/v1/extractors"], CreateExtractorBody | undefined>;
@@ -16044,16 +16073,16 @@ declare const getListExtractorsUrl: (params?: ListExtractorsParams) => string;
  */
 declare const listExtractors: (params?: ListExtractorsParams, options?: Parameters<typeof customFetch>[1]) => Promise<ListExtractorsEnvelope>;
 declare const getListExtractorsKey: (params?: ListExtractorsParams) => readonly ["/v1/extractors", ...ListExtractorsParams[]];
-type ListExtractorsQueryResult = NonNullable<Awaited$h<ReturnType<typeof listExtractors>>>;
+type ListExtractorsQueryResult = NonNullable<Awaited$g<ReturnType<typeof listExtractors>>>;
 /**
  * @summary List extractors
  */
 declare const useListExtractors: <TError = ErrorType<ErrorResponse>>(params?: ListExtractorsParams, options?: {
-    swr?: SWRConfiguration<Awaited$h<ReturnType<typeof listExtractors>>, TError> & {
+    swr?: SWRConfiguration<Awaited$g<ReturnType<typeof listExtractors>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$h<typeof customFetch>;
+    request?: SecondParameter$g<typeof customFetch>;
 }) => {
     data: ListExtractorsEnvelope | undefined;
     error: TError | undefined;
@@ -16069,16 +16098,16 @@ declare const getGetExtractorUrl: (id: string) => string;
  */
 declare const getExtractor: (id: string, options?: Parameters<typeof customFetch>[1]) => Promise<GetExtractorEnvelope>;
 declare const getGetExtractorKey: (id: string) => readonly [`/v1/extractors/${string}`];
-type GetExtractorQueryResult = NonNullable<Awaited$h<ReturnType<typeof getExtractor>>>;
+type GetExtractorQueryResult = NonNullable<Awaited$g<ReturnType<typeof getExtractor>>>;
 /**
  * @summary Get extractor
  */
 declare const useGetExtractor: <TError = ErrorType<ErrorResponse>>(id: string, options?: {
-    swr?: SWRConfiguration<Awaited$h<ReturnType<typeof getExtractor>>, TError> & {
+    swr?: SWRConfiguration<Awaited$g<ReturnType<typeof getExtractor>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$h<typeof customFetch>;
+    request?: SecondParameter$g<typeof customFetch>;
 }) => {
     data: GetExtractorEnvelope | undefined;
     error: TError | undefined;
@@ -16093,19 +16122,19 @@ declare const getUpdateExtractorUrl: (id: string) => string;
  * @summary Update extractor
  */
 declare const updateExtractor: (id: string, updateExtractorBody?: UpdateExtractorBody, options?: Parameters<typeof customFetch>[1]) => Promise<UpdateExtractorEnvelope>;
-declare const getUpdateExtractorMutationFetcher: (id: string, options?: SecondParameter$h<typeof customFetch>) => (_: Key, { arg }: {
+declare const getUpdateExtractorMutationFetcher: (id: string, options?: SecondParameter$g<typeof customFetch>) => (_: Key, { arg }: {
     arg: UpdateExtractorBody | undefined;
 }) => Promise<UpdateExtractorEnvelope>;
 declare const getUpdateExtractorMutationKey: (id: string) => readonly [`/v1/extractors/${string}`];
-type UpdateExtractorMutationResult = NonNullable<Awaited$h<ReturnType<typeof updateExtractor>>>;
+type UpdateExtractorMutationResult = NonNullable<Awaited$g<ReturnType<typeof updateExtractor>>>;
 /**
  * @summary Update extractor
  */
 declare const useUpdateExtractor: <TError = ErrorType<ErrorResponse>>(id: string, options?: {
-    swr?: SWRMutationConfiguration<Awaited$h<ReturnType<typeof updateExtractor>>, TError, Key, UpdateExtractorBody | undefined, Awaited$h<ReturnType<typeof updateExtractor>>> & {
+    swr?: SWRMutationConfiguration<Awaited$g<ReturnType<typeof updateExtractor>>, TError, Key, UpdateExtractorBody | undefined, Awaited$g<ReturnType<typeof updateExtractor>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$h<typeof customFetch>;
+    request?: SecondParameter$g<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<UpdateExtractorEnvelope, TError, string | readonly [`/v1/extractors/${string}`], UpdateExtractorBody | undefined>;
@@ -16120,19 +16149,19 @@ declare const getDeleteExtractorUrl: (id: string) => string;
  * @summary Delete extractor
  */
 declare const deleteExtractor: (id: string, options?: Parameters<typeof customFetch>[1]) => Promise<DeleteExtractorEnvelope>;
-declare const getDeleteExtractorMutationFetcher: (id: string, options?: SecondParameter$h<typeof customFetch>) => (_: Key, __: {
+declare const getDeleteExtractorMutationFetcher: (id: string, options?: SecondParameter$g<typeof customFetch>) => (_: Key, __: {
     arg: Arguments;
 }) => Promise<DeleteExtractorEnvelope>;
 declare const getDeleteExtractorMutationKey: (id: string) => readonly [`/v1/extractors/${string}`];
-type DeleteExtractorMutationResult = NonNullable<Awaited$h<ReturnType<typeof deleteExtractor>>>;
+type DeleteExtractorMutationResult = NonNullable<Awaited$g<ReturnType<typeof deleteExtractor>>>;
 /**
  * @summary Delete extractor
  */
 declare const useDeleteExtractor: <TError = ErrorType<ErrorResponse>>(id: string, options?: {
-    swr?: SWRMutationConfiguration<Awaited$h<ReturnType<typeof deleteExtractor>>, TError, Key, Arguments, Awaited$h<ReturnType<typeof deleteExtractor>>> & {
+    swr?: SWRMutationConfiguration<Awaited$g<ReturnType<typeof deleteExtractor>>, TError, Key, Arguments, Awaited$g<ReturnType<typeof deleteExtractor>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$h<typeof customFetch>;
+    request?: SecondParameter$g<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<DeleteExtractorEnvelope, TError, string | readonly [`/v1/extractors/${string}`], Arguments>;
@@ -16142,9 +16171,9 @@ declare const useDeleteExtractor: <TError = ErrorType<ErrorResponse>>(id: string
     swrKey: string | readonly [`/v1/extractors/${string}`];
 };
 
-type AwaitedInput$g<T> = PromiseLike<T> | T;
-type Awaited$g<O> = O extends AwaitedInput$g<infer T> ? T : never;
-type SecondParameter$g<T extends (...args: never) => unknown> = Parameters<T>[1];
+type AwaitedInput$f<T> = PromiseLike<T> | T;
+type Awaited$f<O> = O extends AwaitedInput$f<infer T> ? T : never;
+type SecondParameter$f<T extends (...args: never) => unknown> = Parameters<T>[1];
 declare const getGetExtractUrl: (id: string) => string;
 /**
  * Retrieve a single extract by ID, including the extraction result data.
@@ -16152,16 +16181,16 @@ declare const getGetExtractUrl: (id: string) => string;
  */
 declare const getExtract: (id: string, options?: Parameters<typeof customFetch>[1]) => Promise<GetExtractEnvelope>;
 declare const getGetExtractKey: (id: string) => readonly [`/v1/extracts/${string}`];
-type GetExtractQueryResult = NonNullable<Awaited$g<ReturnType<typeof getExtract>>>;
+type GetExtractQueryResult = NonNullable<Awaited$f<ReturnType<typeof getExtract>>>;
 /**
  * @summary Get extract
  */
 declare const useGetExtract: <TError = ErrorType<ErrorResponse>>(id: string, options?: {
-    swr?: SWRConfiguration<Awaited$g<ReturnType<typeof getExtract>>, TError> & {
+    swr?: SWRConfiguration<Awaited$f<ReturnType<typeof getExtract>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$g<typeof customFetch>;
+    request?: SecondParameter$f<typeof customFetch>;
 }) => {
     data: GetExtractEnvelope | undefined;
     error: TError | undefined;
@@ -16177,16 +16206,16 @@ declare const getGetExtractCitationsUrl: (id: string) => string;
  */
 declare const getExtractCitations: (id: string, options?: Parameters<typeof customFetch>[1]) => Promise<GetExtractCitationsEnvelope>;
 declare const getGetExtractCitationsKey: (id: string) => readonly [`/v1/extracts/${string}/citations`];
-type GetExtractCitationsQueryResult = NonNullable<Awaited$g<ReturnType<typeof getExtractCitations>>>;
+type GetExtractCitationsQueryResult = NonNullable<Awaited$f<ReturnType<typeof getExtractCitations>>>;
 /**
  * @summary Get extract citations
  */
 declare const useGetExtractCitations: <TError = ErrorType<ErrorResponse>>(id: string, options?: {
-    swr?: SWRConfiguration<Awaited$g<ReturnType<typeof getExtractCitations>>, TError> & {
+    swr?: SWRConfiguration<Awaited$f<ReturnType<typeof getExtractCitations>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$g<typeof customFetch>;
+    request?: SecondParameter$f<typeof customFetch>;
 }) => {
     data: GetExtractCitationsEnvelope | undefined;
     error: TError | undefined;
@@ -16209,16 +16238,16 @@ declare const getListExtractsUrl: (params?: ListExtractsParams) => string;
  */
 declare const listExtracts: (params?: ListExtractsParams, options?: Parameters<typeof customFetch>[1]) => Promise<ListExtractsEnvelope>;
 declare const getListExtractsKey: (params?: ListExtractsParams) => readonly ["/v1/extracts", ...ListExtractsParams[]];
-type ListExtractsQueryResult = NonNullable<Awaited$g<ReturnType<typeof listExtracts>>>;
+type ListExtractsQueryResult = NonNullable<Awaited$f<ReturnType<typeof listExtracts>>>;
 /**
  * @summary List extracts
  */
 declare const useListExtracts: <TError = ErrorType<ErrorResponse>>(params?: ListExtractsParams, options?: {
-    swr?: SWRConfiguration<Awaited$g<ReturnType<typeof listExtracts>>, TError> & {
+    swr?: SWRConfiguration<Awaited$f<ReturnType<typeof listExtracts>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$g<typeof customFetch>;
+    request?: SecondParameter$f<typeof customFetch>;
 }) => {
     data: ListExtractsEnvelope | undefined;
     error: TError | undefined;
@@ -16228,9 +16257,9 @@ declare const useListExtracts: <TError = ErrorType<ErrorResponse>>(params?: List
     swrKey: string | false | readonly [any, ...unknown[]] | Record<any, any> | (() => swr.Arguments);
 };
 
-type AwaitedInput$f<T> = PromiseLike<T> | T;
-type Awaited$f<O> = O extends AwaitedInput$f<infer T> ? T : never;
-type SecondParameter$f<T extends (...args: never) => unknown> = Parameters<T>[1];
+type AwaitedInput$e<T> = PromiseLike<T> | T;
+type Awaited$e<O> = O extends AwaitedInput$e<infer T> ? T : never;
+type SecondParameter$e<T extends (...args: never) => unknown> = Parameters<T>[1];
 declare const getCheckInboxAvailabilityUrl: (params: CheckInboxAvailabilityParams) => string;
 /**
  * Check whether a given email username is available for creating a new inbox.
@@ -16241,16 +16270,16 @@ declare const getCheckInboxAvailabilityUrl: (params: CheckInboxAvailabilityParam
  */
 declare const checkInboxAvailability: (params: CheckInboxAvailabilityParams, options?: Parameters<typeof customFetch>[1]) => Promise<CheckInboxAvailabilityEnvelope>;
 declare const getCheckInboxAvailabilityKey: (params: CheckInboxAvailabilityParams) => readonly ["/v1/inboxes/availability", ...CheckInboxAvailabilityParams[]];
-type CheckInboxAvailabilityQueryResult = NonNullable<Awaited$f<ReturnType<typeof checkInboxAvailability>>>;
+type CheckInboxAvailabilityQueryResult = NonNullable<Awaited$e<ReturnType<typeof checkInboxAvailability>>>;
 /**
  * @summary Check email username availability
  */
 declare const useCheckInboxAvailability: <TError = ErrorType<ErrorResponse>>(params: CheckInboxAvailabilityParams, options?: {
-    swr?: SWRConfiguration<Awaited$f<ReturnType<typeof checkInboxAvailability>>, TError> & {
+    swr?: SWRConfiguration<Awaited$e<ReturnType<typeof checkInboxAvailability>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$f<typeof customFetch>;
+    request?: SecondParameter$e<typeof customFetch>;
 }) => {
     data: CheckInboxAvailabilityEnvelope | undefined;
     error: TError | undefined;
@@ -16272,19 +16301,19 @@ declare const getCreateInboxUrl: () => string;
  * @summary Create inbox
  */
 declare const createInbox: (createInboxBody?: CreateInboxBody, options?: Parameters<typeof customFetch>[1]) => Promise<CreateInboxEnvelope>;
-declare const getCreateInboxMutationFetcher: (options?: SecondParameter$f<typeof customFetch>) => (_: Key, { arg }: {
+declare const getCreateInboxMutationFetcher: (options?: SecondParameter$e<typeof customFetch>) => (_: Key, { arg }: {
     arg: CreateInboxBody | undefined;
 }) => Promise<CreateInboxEnvelope>;
 declare const getCreateInboxMutationKey: () => readonly ["/v1/inboxes"];
-type CreateInboxMutationResult = NonNullable<Awaited$f<ReturnType<typeof createInbox>>>;
+type CreateInboxMutationResult = NonNullable<Awaited$e<ReturnType<typeof createInbox>>>;
 /**
  * @summary Create inbox
  */
 declare const useCreateInbox: <TError = ErrorType<ErrorResponse>>(options?: {
-    swr?: SWRMutationConfiguration<Awaited$f<ReturnType<typeof createInbox>>, TError, Key, CreateInboxBody | undefined, Awaited$f<ReturnType<typeof createInbox>>> & {
+    swr?: SWRMutationConfiguration<Awaited$e<ReturnType<typeof createInbox>>, TError, Key, CreateInboxBody | undefined, Awaited$e<ReturnType<typeof createInbox>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$f<typeof customFetch>;
+    request?: SecondParameter$e<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<CreateInboxEnvelope, TError, string | readonly ["/v1/inboxes"], CreateInboxBody | undefined>;
@@ -16303,16 +16332,16 @@ declare const getListInboxesUrl: (params?: ListInboxesParams) => string;
  */
 declare const listInboxes: (params?: ListInboxesParams, options?: Parameters<typeof customFetch>[1]) => Promise<ListInboxesEnvelope>;
 declare const getListInboxesKey: (params?: ListInboxesParams) => readonly ["/v1/inboxes", ...ListInboxesParams[]];
-type ListInboxesQueryResult = NonNullable<Awaited$f<ReturnType<typeof listInboxes>>>;
+type ListInboxesQueryResult = NonNullable<Awaited$e<ReturnType<typeof listInboxes>>>;
 /**
  * @summary List inboxes
  */
 declare const useListInboxes: <TError = ErrorType<ErrorResponse>>(params?: ListInboxesParams, options?: {
-    swr?: SWRConfiguration<Awaited$f<ReturnType<typeof listInboxes>>, TError> & {
+    swr?: SWRConfiguration<Awaited$e<ReturnType<typeof listInboxes>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$f<typeof customFetch>;
+    request?: SecondParameter$e<typeof customFetch>;
 }) => {
     data: ListInboxesEnvelope | undefined;
     error: TError | undefined;
@@ -16330,19 +16359,19 @@ declare const getUpdateInboxUrl: (inboxId: string) => string;
  * @summary Update inbox
  */
 declare const updateInbox: (inboxId: string, updateInboxBody?: UpdateInboxBody, options?: Parameters<typeof customFetch>[1]) => Promise<UpdateInboxEnvelope>;
-declare const getUpdateInboxMutationFetcher: (inboxId: string, options?: SecondParameter$f<typeof customFetch>) => (_: Key, { arg }: {
+declare const getUpdateInboxMutationFetcher: (inboxId: string, options?: SecondParameter$e<typeof customFetch>) => (_: Key, { arg }: {
     arg: UpdateInboxBody | undefined;
 }) => Promise<UpdateInboxEnvelope>;
 declare const getUpdateInboxMutationKey: (inboxId: string) => readonly [`/v1/inboxes/${string}`];
-type UpdateInboxMutationResult = NonNullable<Awaited$f<ReturnType<typeof updateInbox>>>;
+type UpdateInboxMutationResult = NonNullable<Awaited$e<ReturnType<typeof updateInbox>>>;
 /**
  * @summary Update inbox
  */
 declare const useUpdateInbox: <TError = ErrorType<ErrorResponse>>(inboxId: string, options?: {
-    swr?: SWRMutationConfiguration<Awaited$f<ReturnType<typeof updateInbox>>, TError, Key, UpdateInboxBody | undefined, Awaited$f<ReturnType<typeof updateInbox>>> & {
+    swr?: SWRMutationConfiguration<Awaited$e<ReturnType<typeof updateInbox>>, TError, Key, UpdateInboxBody | undefined, Awaited$e<ReturnType<typeof updateInbox>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$f<typeof customFetch>;
+    request?: SecondParameter$e<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<UpdateInboxEnvelope, TError, string | readonly [`/v1/inboxes/${string}`], UpdateInboxBody | undefined>;
@@ -16357,19 +16386,19 @@ declare const getDeleteInboxUrl: (inboxId: string) => string;
  * @summary Delete inbox
  */
 declare const deleteInbox: (inboxId: string, options?: Parameters<typeof customFetch>[1]) => Promise<DeleteInboxEnvelope>;
-declare const getDeleteInboxMutationFetcher: (inboxId: string, options?: SecondParameter$f<typeof customFetch>) => (_: Key, __: {
+declare const getDeleteInboxMutationFetcher: (inboxId: string, options?: SecondParameter$e<typeof customFetch>) => (_: Key, __: {
     arg: Arguments;
 }) => Promise<DeleteInboxEnvelope>;
 declare const getDeleteInboxMutationKey: (inboxId: string) => readonly [`/v1/inboxes/${string}`];
-type DeleteInboxMutationResult = NonNullable<Awaited$f<ReturnType<typeof deleteInbox>>>;
+type DeleteInboxMutationResult = NonNullable<Awaited$e<ReturnType<typeof deleteInbox>>>;
 /**
  * @summary Delete inbox
  */
 declare const useDeleteInbox: <TError = ErrorType<ErrorResponse>>(inboxId: string, options?: {
-    swr?: SWRMutationConfiguration<Awaited$f<ReturnType<typeof deleteInbox>>, TError, Key, Arguments, Awaited$f<ReturnType<typeof deleteInbox>>> & {
+    swr?: SWRMutationConfiguration<Awaited$e<ReturnType<typeof deleteInbox>>, TError, Key, Arguments, Awaited$e<ReturnType<typeof deleteInbox>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$f<typeof customFetch>;
+    request?: SecondParameter$e<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<DeleteInboxEnvelope, TError, string | readonly [`/v1/inboxes/${string}`], Arguments>;
@@ -16379,9 +16408,9 @@ declare const useDeleteInbox: <TError = ErrorType<ErrorResponse>>(inboxId: strin
     swrKey: string | readonly [`/v1/inboxes/${string}`];
 };
 
-type AwaitedInput$e<T> = PromiseLike<T> | T;
-type Awaited$e<O> = O extends AwaitedInput$e<infer T> ? T : never;
-type SecondParameter$e<T extends (...args: never) => unknown> = Parameters<T>[1];
+type AwaitedInput$d<T> = PromiseLike<T> | T;
+type Awaited$d<O> = O extends AwaitedInput$d<infer T> ? T : never;
+type SecondParameter$d<T extends (...args: never) => unknown> = Parameters<T>[1];
 declare const getCreateInformationRequestUrl: () => string;
 /**
  * Ask a person for a specific fact you cannot establish yourself.
@@ -16396,19 +16425,19 @@ declare const getCreateInformationRequestUrl: () => string;
  * @summary Ask for information
  */
 declare const createInformationRequest: (createInformationRequestBody?: CreateInformationRequestBody, options?: Parameters<typeof customFetch>[1]) => Promise<CreateInformationRequestEnvelope>;
-declare const getCreateInformationRequestMutationFetcher: (options?: SecondParameter$e<typeof customFetch>) => (_: Key, { arg }: {
+declare const getCreateInformationRequestMutationFetcher: (options?: SecondParameter$d<typeof customFetch>) => (_: Key, { arg }: {
     arg: CreateInformationRequestBody | undefined;
 }) => Promise<CreateInformationRequestEnvelope>;
 declare const getCreateInformationRequestMutationKey: () => readonly ["/v1/information-requests"];
-type CreateInformationRequestMutationResult = NonNullable<Awaited$e<ReturnType<typeof createInformationRequest>>>;
+type CreateInformationRequestMutationResult = NonNullable<Awaited$d<ReturnType<typeof createInformationRequest>>>;
 /**
  * @summary Ask for information
  */
 declare const useCreateInformationRequest: <TError = ErrorType<ErrorResponse>>(options?: {
-    swr?: SWRMutationConfiguration<Awaited$e<ReturnType<typeof createInformationRequest>>, TError, Key, CreateInformationRequestBody | undefined, Awaited$e<ReturnType<typeof createInformationRequest>>> & {
+    swr?: SWRMutationConfiguration<Awaited$d<ReturnType<typeof createInformationRequest>>, TError, Key, CreateInformationRequestBody | undefined, Awaited$d<ReturnType<typeof createInformationRequest>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$e<typeof customFetch>;
+    request?: SecondParameter$d<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<CreateInformationRequestEnvelope, TError, string | readonly ["/v1/information-requests"], CreateInformationRequestBody | undefined>;
@@ -16426,16 +16455,16 @@ declare const getListInformationRequestsUrl: (params?: ListInformationRequestsPa
  */
 declare const listInformationRequests: (params?: ListInformationRequestsParams, options?: Parameters<typeof customFetch>[1]) => Promise<ListInformationRequestsEnvelope>;
 declare const getListInformationRequestsKey: (params?: ListInformationRequestsParams) => readonly ["/v1/information-requests", ...ListInformationRequestsParams[]];
-type ListInformationRequestsQueryResult = NonNullable<Awaited$e<ReturnType<typeof listInformationRequests>>>;
+type ListInformationRequestsQueryResult = NonNullable<Awaited$d<ReturnType<typeof listInformationRequests>>>;
 /**
  * @summary List information requests
  */
 declare const useListInformationRequests: <TError = ErrorType<ErrorResponse>>(params?: ListInformationRequestsParams, options?: {
-    swr?: SWRConfiguration<Awaited$e<ReturnType<typeof listInformationRequests>>, TError> & {
+    swr?: SWRConfiguration<Awaited$d<ReturnType<typeof listInformationRequests>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$e<typeof customFetch>;
+    request?: SecondParameter$d<typeof customFetch>;
 }) => {
     data: ListInformationRequestsEnvelope | undefined;
     error: TError | undefined;
@@ -16451,16 +16480,16 @@ declare const getGetInformationRequestUrl: (informationRequestId: string) => str
  */
 declare const getInformationRequest: (informationRequestId: string, options?: Parameters<typeof customFetch>[1]) => Promise<GetInformationRequestEnvelope>;
 declare const getGetInformationRequestKey: (informationRequestId: string) => readonly [`/v1/information-requests/${string}`];
-type GetInformationRequestQueryResult = NonNullable<Awaited$e<ReturnType<typeof getInformationRequest>>>;
+type GetInformationRequestQueryResult = NonNullable<Awaited$d<ReturnType<typeof getInformationRequest>>>;
 /**
  * @summary Get information request
  */
 declare const useGetInformationRequest: <TError = ErrorType<ErrorResponse>>(informationRequestId: string, options?: {
-    swr?: SWRConfiguration<Awaited$e<ReturnType<typeof getInformationRequest>>, TError> & {
+    swr?: SWRConfiguration<Awaited$d<ReturnType<typeof getInformationRequest>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$e<typeof customFetch>;
+    request?: SecondParameter$d<typeof customFetch>;
 }) => {
     data: GetInformationRequestEnvelope | undefined;
     error: TError | undefined;
@@ -16475,19 +16504,19 @@ declare const getResolveInformationRequestUrl: (informationRequestId: string) =>
  * @summary Resolve information request
  */
 declare const resolveInformationRequest: (informationRequestId: string, resolveInformationRequestBody?: ResolveInformationRequestBody, options?: Parameters<typeof customFetch>[1]) => Promise<ResolveInformationRequestEnvelope>;
-declare const getResolveInformationRequestMutationFetcher: (informationRequestId: string, options?: SecondParameter$e<typeof customFetch>) => (_: Key, { arg }: {
+declare const getResolveInformationRequestMutationFetcher: (informationRequestId: string, options?: SecondParameter$d<typeof customFetch>) => (_: Key, { arg }: {
     arg: ResolveInformationRequestBody | undefined;
 }) => Promise<ResolveInformationRequestEnvelope>;
 declare const getResolveInformationRequestMutationKey: (informationRequestId: string) => readonly [`/v1/information-requests/${string}/resolve`];
-type ResolveInformationRequestMutationResult = NonNullable<Awaited$e<ReturnType<typeof resolveInformationRequest>>>;
+type ResolveInformationRequestMutationResult = NonNullable<Awaited$d<ReturnType<typeof resolveInformationRequest>>>;
 /**
  * @summary Resolve information request
  */
 declare const useResolveInformationRequest: <TError = ErrorType<ErrorResponse>>(informationRequestId: string, options?: {
-    swr?: SWRMutationConfiguration<Awaited$e<ReturnType<typeof resolveInformationRequest>>, TError, Key, ResolveInformationRequestBody | undefined, Awaited$e<ReturnType<typeof resolveInformationRequest>>> & {
+    swr?: SWRMutationConfiguration<Awaited$d<ReturnType<typeof resolveInformationRequest>>, TError, Key, ResolveInformationRequestBody | undefined, Awaited$d<ReturnType<typeof resolveInformationRequest>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$e<typeof customFetch>;
+    request?: SecondParameter$d<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<ResolveInformationRequestEnvelope, TError, string | readonly [`/v1/information-requests/${string}/resolve`], ResolveInformationRequestBody | undefined>;
@@ -16497,9 +16526,9 @@ declare const useResolveInformationRequest: <TError = ErrorType<ErrorResponse>>(
     swrKey: string | readonly [`/v1/information-requests/${string}/resolve`];
 };
 
-type AwaitedInput$d<T> = PromiseLike<T> | T;
-type Awaited$d<O> = O extends AwaitedInput$d<infer T> ? T : never;
-type SecondParameter$d<T extends (...args: never) => unknown> = Parameters<T>[1];
+type AwaitedInput$c<T> = PromiseLike<T> | T;
+type Awaited$c<O> = O extends AwaitedInput$c<infer T> ? T : never;
+type SecondParameter$c<T extends (...args: never) => unknown> = Parameters<T>[1];
 declare const getScheduleJobUrl: (voiceAgentId: string) => string;
 /**
  * **Deprecated:** use `POST /v1/calls`, which returns the call itself.
@@ -16522,20 +16551,20 @@ declare const getScheduleJobUrl: (voiceAgentId: string) => string;
  * @summary Schedule an outbound job
  */
 declare const scheduleJob: (voiceAgentId: string, scheduleJobBody?: ScheduleJobBody, options?: Parameters<typeof customFetch>[1]) => Promise<ScheduleJobEnvelope>;
-declare const getScheduleJobMutationFetcher: (voiceAgentId: string, options?: SecondParameter$d<typeof customFetch>) => (_: Key, { arg }: {
+declare const getScheduleJobMutationFetcher: (voiceAgentId: string, options?: SecondParameter$c<typeof customFetch>) => (_: Key, { arg }: {
     arg: ScheduleJobBody | undefined;
 }) => Promise<ScheduleJobEnvelope>;
 declare const getScheduleJobMutationKey: (voiceAgentId: string) => readonly [`/v1/voice-agents/${string}/jobs`];
-type ScheduleJobMutationResult = NonNullable<Awaited$d<ReturnType<typeof scheduleJob>>>;
+type ScheduleJobMutationResult = NonNullable<Awaited$c<ReturnType<typeof scheduleJob>>>;
 /**
  * @deprecated
  * @summary Schedule an outbound job
  */
 declare const useScheduleJob: <TError = ErrorType<ErrorResponse>>(voiceAgentId: string, options?: {
-    swr?: SWRMutationConfiguration<Awaited$d<ReturnType<typeof scheduleJob>>, TError, Key, ScheduleJobBody | undefined, Awaited$d<ReturnType<typeof scheduleJob>>> & {
+    swr?: SWRMutationConfiguration<Awaited$c<ReturnType<typeof scheduleJob>>, TError, Key, ScheduleJobBody | undefined, Awaited$c<ReturnType<typeof scheduleJob>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$d<typeof customFetch>;
+    request?: SecondParameter$c<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<ScheduleJobEnvelope, TError, string | readonly [`/v1/voice-agents/${string}/jobs`], ScheduleJobBody | undefined>;
@@ -16562,17 +16591,17 @@ declare const getListJobsUrl: (params: ListJobsParams) => string;
  */
 declare const listJobs: (params: ListJobsParams, options?: Parameters<typeof customFetch>[1]) => Promise<ListJobsEnvelope>;
 declare const getListJobsKey: (params: ListJobsParams) => readonly ["/v1/voice-agents/jobs", ...ListJobsParams[]];
-type ListJobsQueryResult = NonNullable<Awaited$d<ReturnType<typeof listJobs>>>;
+type ListJobsQueryResult = NonNullable<Awaited$c<ReturnType<typeof listJobs>>>;
 /**
  * @deprecated
  * @summary List outbound jobs
  */
 declare const useListJobs: <TError = ErrorType<ErrorResponse>>(params: ListJobsParams, options?: {
-    swr?: SWRConfiguration<Awaited$d<ReturnType<typeof listJobs>>, TError> & {
+    swr?: SWRConfiguration<Awaited$c<ReturnType<typeof listJobs>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$d<typeof customFetch>;
+    request?: SecondParameter$c<typeof customFetch>;
 }) => {
     data: ListJobsEnvelope | undefined;
     error: TError | undefined;
@@ -16593,20 +16622,20 @@ declare const getCancelJobUrl: (jobId: string) => string;
  * @summary Cancel an outbound job
  */
 declare const cancelJob: (jobId: string, options?: Parameters<typeof customFetch>[1]) => Promise<CancelJobEnvelope>;
-declare const getCancelJobMutationFetcher: (jobId: string, options?: SecondParameter$d<typeof customFetch>) => (_: Key, __: {
+declare const getCancelJobMutationFetcher: (jobId: string, options?: SecondParameter$c<typeof customFetch>) => (_: Key, __: {
     arg: Arguments;
 }) => Promise<CancelJobEnvelope>;
 declare const getCancelJobMutationKey: (jobId: string) => readonly [`/v1/voice-agents/jobs/${string}/cancel`];
-type CancelJobMutationResult = NonNullable<Awaited$d<ReturnType<typeof cancelJob>>>;
+type CancelJobMutationResult = NonNullable<Awaited$c<ReturnType<typeof cancelJob>>>;
 /**
  * @deprecated
  * @summary Cancel an outbound job
  */
 declare const useCancelJob: <TError = ErrorType<ErrorResponse>>(jobId: string, options?: {
-    swr?: SWRMutationConfiguration<Awaited$d<ReturnType<typeof cancelJob>>, TError, Key, Arguments, Awaited$d<ReturnType<typeof cancelJob>>> & {
+    swr?: SWRMutationConfiguration<Awaited$c<ReturnType<typeof cancelJob>>, TError, Key, Arguments, Awaited$c<ReturnType<typeof cancelJob>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$d<typeof customFetch>;
+    request?: SecondParameter$c<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<CancelJobEnvelope, TError, string | readonly [`/v1/voice-agents/jobs/${string}/cancel`], Arguments>;
@@ -16616,9 +16645,9 @@ declare const useCancelJob: <TError = ErrorType<ErrorResponse>>(jobId: string, o
     swrKey: string | readonly [`/v1/voice-agents/jobs/${string}/cancel`];
 };
 
-type AwaitedInput$c<T> = PromiseLike<T> | T;
-type Awaited$c<O> = O extends AwaitedInput$c<infer T> ? T : never;
-type SecondParameter$c<T extends (...args: never) => unknown> = Parameters<T>[1];
+type AwaitedInput$b<T> = PromiseLike<T> | T;
+type Awaited$b<O> = O extends AwaitedInput$b<infer T> ? T : never;
+type SecondParameter$b<T extends (...args: never) => unknown> = Parameters<T>[1];
 declare const getListNotificationsUrl: (params?: ListNotificationsParams) => string;
 /**
  * List the organization's notifications, newest first.
@@ -16632,16 +16661,16 @@ declare const getListNotificationsUrl: (params?: ListNotificationsParams) => str
  */
 declare const listNotifications: (params?: ListNotificationsParams, options?: Parameters<typeof customFetch>[1]) => Promise<ListNotificationsEnvelope>;
 declare const getListNotificationsKey: (params?: ListNotificationsParams) => readonly ["/v1/notifications", ...ListNotificationsParams[]];
-type ListNotificationsQueryResult = NonNullable<Awaited$c<ReturnType<typeof listNotifications>>>;
+type ListNotificationsQueryResult = NonNullable<Awaited$b<ReturnType<typeof listNotifications>>>;
 /**
  * @summary List notifications
  */
 declare const useListNotifications: <TError = ErrorType<ErrorResponse>>(params?: ListNotificationsParams, options?: {
-    swr?: SWRConfiguration<Awaited$c<ReturnType<typeof listNotifications>>, TError> & {
+    swr?: SWRConfiguration<Awaited$b<ReturnType<typeof listNotifications>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$c<typeof customFetch>;
+    request?: SecondParameter$b<typeof customFetch>;
 }) => {
     data: ListNotificationsEnvelope | undefined;
     error: TError | undefined;
@@ -16661,16 +16690,16 @@ declare const getGetNotificationUrl: (notificationId: string) => string;
  */
 declare const getNotification: (notificationId: string, options?: Parameters<typeof customFetch>[1]) => Promise<GetNotificationEnvelope>;
 declare const getGetNotificationKey: (notificationId: string) => readonly [`/v1/notifications/${string}`];
-type GetNotificationQueryResult = NonNullable<Awaited$c<ReturnType<typeof getNotification>>>;
+type GetNotificationQueryResult = NonNullable<Awaited$b<ReturnType<typeof getNotification>>>;
 /**
  * @summary Get notification
  */
 declare const useGetNotification: <TError = ErrorType<ErrorResponse>>(notificationId: string, options?: {
-    swr?: SWRConfiguration<Awaited$c<ReturnType<typeof getNotification>>, TError> & {
+    swr?: SWRConfiguration<Awaited$b<ReturnType<typeof getNotification>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$c<typeof customFetch>;
+    request?: SecondParameter$b<typeof customFetch>;
 }) => {
     data: GetNotificationEnvelope | undefined;
     error: TError | undefined;
@@ -16680,9 +16709,9 @@ declare const useGetNotification: <TError = ErrorType<ErrorResponse>>(notificati
     swrKey: string | false | readonly [any, ...unknown[]] | Record<any, any> | (() => swr.Arguments);
 };
 
-type AwaitedInput$b<T> = PromiseLike<T> | T;
-type Awaited$b<O> = O extends AwaitedInput$b<infer T> ? T : never;
-type SecondParameter$b<T extends (...args: never) => unknown> = Parameters<T>[1];
+type AwaitedInput$a<T> = PromiseLike<T> | T;
+type Awaited$a<O> = O extends AwaitedInput$a<infer T> ? T : never;
+type SecondParameter$a<T extends (...args: never) => unknown> = Parameters<T>[1];
 declare const getGetProfileUrl: () => string;
 /**
  * Retrieve the current user's profile information. This endpoint requires a user session and cannot be used with API Keys.
@@ -16690,16 +16719,16 @@ declare const getGetProfileUrl: () => string;
  */
 declare const getProfile: (options?: Parameters<typeof customFetch>[1]) => Promise<GetProfileEnvelope>;
 declare const getGetProfileKey: () => readonly ["/v1/profile"];
-type GetProfileQueryResult = NonNullable<Awaited$b<ReturnType<typeof getProfile>>>;
+type GetProfileQueryResult = NonNullable<Awaited$a<ReturnType<typeof getProfile>>>;
 /**
  * @summary Get profile
  */
 declare const useGetProfile: <TError = ErrorType<ErrorResponse>>(options?: {
-    swr?: SWRConfiguration<Awaited$b<ReturnType<typeof getProfile>>, TError> & {
+    swr?: SWRConfiguration<Awaited$a<ReturnType<typeof getProfile>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$b<typeof customFetch>;
+    request?: SecondParameter$a<typeof customFetch>;
 }) => {
     data: GetProfileEnvelope | undefined;
     error: TError | undefined;
@@ -16709,9 +16738,9 @@ declare const useGetProfile: <TError = ErrorType<ErrorResponse>>(options?: {
     swrKey: string | false | readonly [any, ...unknown[]] | Record<any, any> | (() => swr.Arguments);
 };
 
-type AwaitedInput$a<T> = PromiseLike<T> | T;
-type Awaited$a<O> = O extends AwaitedInput$a<infer T> ? T : never;
-type SecondParameter$a<T extends (...args: never) => unknown> = Parameters<T>[1];
+type AwaitedInput$9<T> = PromiseLike<T> | T;
+type Awaited$9<O> = O extends AwaitedInput$9<infer T> ? T : never;
+type SecondParameter$9<T extends (...args: never) => unknown> = Parameters<T>[1];
 declare const getCreateScheduleUrl: () => string;
 /**
  * Create a schedule that performs an action, either repeatedly or once.
@@ -16726,19 +16755,19 @@ declare const getCreateScheduleUrl: () => string;
  * @summary Create a schedule
  */
 declare const createSchedule: (createScheduleBody?: CreateScheduleBody, options?: Parameters<typeof customFetch>[1]) => Promise<CreateScheduleEnvelope>;
-declare const getCreateScheduleMutationFetcher: (options?: SecondParameter$a<typeof customFetch>) => (_: Key, { arg }: {
+declare const getCreateScheduleMutationFetcher: (options?: SecondParameter$9<typeof customFetch>) => (_: Key, { arg }: {
     arg: CreateScheduleBody | undefined;
 }) => Promise<CreateScheduleEnvelope>;
 declare const getCreateScheduleMutationKey: () => readonly ["/v1/schedules"];
-type CreateScheduleMutationResult = NonNullable<Awaited$a<ReturnType<typeof createSchedule>>>;
+type CreateScheduleMutationResult = NonNullable<Awaited$9<ReturnType<typeof createSchedule>>>;
 /**
  * @summary Create a schedule
  */
 declare const useCreateSchedule: <TError = ErrorType<ErrorResponse>>(options?: {
-    swr?: SWRMutationConfiguration<Awaited$a<ReturnType<typeof createSchedule>>, TError, Key, CreateScheduleBody | undefined, Awaited$a<ReturnType<typeof createSchedule>>> & {
+    swr?: SWRMutationConfiguration<Awaited$9<ReturnType<typeof createSchedule>>, TError, Key, CreateScheduleBody | undefined, Awaited$9<ReturnType<typeof createSchedule>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$a<typeof customFetch>;
+    request?: SecondParameter$9<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<CreateScheduleEnvelope, TError, string | readonly ["/v1/schedules"], CreateScheduleBody | undefined>;
@@ -16754,16 +16783,16 @@ declare const getListSchedulesUrl: (params?: ListSchedulesParams) => string;
  */
 declare const listSchedules: (params?: ListSchedulesParams, options?: Parameters<typeof customFetch>[1]) => Promise<ListSchedulesEnvelope>;
 declare const getListSchedulesKey: (params?: ListSchedulesParams) => readonly ["/v1/schedules", ...ListSchedulesParams[]];
-type ListSchedulesQueryResult = NonNullable<Awaited$a<ReturnType<typeof listSchedules>>>;
+type ListSchedulesQueryResult = NonNullable<Awaited$9<ReturnType<typeof listSchedules>>>;
 /**
  * @summary List schedules
  */
 declare const useListSchedules: <TError = ErrorType<ErrorResponse>>(params?: ListSchedulesParams, options?: {
-    swr?: SWRConfiguration<Awaited$a<ReturnType<typeof listSchedules>>, TError> & {
+    swr?: SWRConfiguration<Awaited$9<ReturnType<typeof listSchedules>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$a<typeof customFetch>;
+    request?: SecondParameter$9<typeof customFetch>;
 }) => {
     data: ListSchedulesEnvelope | undefined;
     error: TError | undefined;
@@ -16779,16 +16808,16 @@ declare const getGetScheduleUrl: (scheduleId: string) => string;
  */
 declare const getSchedule: (scheduleId: string, options?: Parameters<typeof customFetch>[1]) => Promise<GetScheduleEnvelope>;
 declare const getGetScheduleKey: (scheduleId: string) => readonly [`/v1/schedules/${string}`];
-type GetScheduleQueryResult = NonNullable<Awaited$a<ReturnType<typeof getSchedule>>>;
+type GetScheduleQueryResult = NonNullable<Awaited$9<ReturnType<typeof getSchedule>>>;
 /**
  * @summary Get a schedule
  */
 declare const useGetSchedule: <TError = ErrorType<ErrorResponse>>(scheduleId: string, options?: {
-    swr?: SWRConfiguration<Awaited$a<ReturnType<typeof getSchedule>>, TError> & {
+    swr?: SWRConfiguration<Awaited$9<ReturnType<typeof getSchedule>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$a<typeof customFetch>;
+    request?: SecondParameter$9<typeof customFetch>;
 }) => {
     data: GetScheduleEnvelope | undefined;
     error: TError | undefined;
@@ -16807,19 +16836,19 @@ declare const getUpdateScheduleUrl: (scheduleId: string) => string;
  * @summary Update a schedule
  */
 declare const updateSchedule: (scheduleId: string, updateScheduleBody?: UpdateScheduleBody, options?: Parameters<typeof customFetch>[1]) => Promise<UpdateScheduleEnvelope>;
-declare const getUpdateScheduleMutationFetcher: (scheduleId: string, options?: SecondParameter$a<typeof customFetch>) => (_: Key, { arg }: {
+declare const getUpdateScheduleMutationFetcher: (scheduleId: string, options?: SecondParameter$9<typeof customFetch>) => (_: Key, { arg }: {
     arg: UpdateScheduleBody | undefined;
 }) => Promise<UpdateScheduleEnvelope>;
 declare const getUpdateScheduleMutationKey: (scheduleId: string) => readonly [`/v1/schedules/${string}`];
-type UpdateScheduleMutationResult = NonNullable<Awaited$a<ReturnType<typeof updateSchedule>>>;
+type UpdateScheduleMutationResult = NonNullable<Awaited$9<ReturnType<typeof updateSchedule>>>;
 /**
  * @summary Update a schedule
  */
 declare const useUpdateSchedule: <TError = ErrorType<ErrorResponse>>(scheduleId: string, options?: {
-    swr?: SWRMutationConfiguration<Awaited$a<ReturnType<typeof updateSchedule>>, TError, Key, UpdateScheduleBody | undefined, Awaited$a<ReturnType<typeof updateSchedule>>> & {
+    swr?: SWRMutationConfiguration<Awaited$9<ReturnType<typeof updateSchedule>>, TError, Key, UpdateScheduleBody | undefined, Awaited$9<ReturnType<typeof updateSchedule>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$a<typeof customFetch>;
+    request?: SecondParameter$9<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<UpdateScheduleEnvelope, TError, string | readonly [`/v1/schedules/${string}`], UpdateScheduleBody | undefined>;
@@ -16834,19 +16863,19 @@ declare const getDeleteScheduleUrl: (scheduleId: string) => string;
  * @summary Delete a schedule
  */
 declare const deleteSchedule: (scheduleId: string, options?: Parameters<typeof customFetch>[1]) => Promise<DeleteScheduleEnvelope>;
-declare const getDeleteScheduleMutationFetcher: (scheduleId: string, options?: SecondParameter$a<typeof customFetch>) => (_: Key, __: {
+declare const getDeleteScheduleMutationFetcher: (scheduleId: string, options?: SecondParameter$9<typeof customFetch>) => (_: Key, __: {
     arg: Arguments;
 }) => Promise<DeleteScheduleEnvelope>;
 declare const getDeleteScheduleMutationKey: (scheduleId: string) => readonly [`/v1/schedules/${string}`];
-type DeleteScheduleMutationResult = NonNullable<Awaited$a<ReturnType<typeof deleteSchedule>>>;
+type DeleteScheduleMutationResult = NonNullable<Awaited$9<ReturnType<typeof deleteSchedule>>>;
 /**
  * @summary Delete a schedule
  */
 declare const useDeleteSchedule: <TError = ErrorType<ErrorResponse>>(scheduleId: string, options?: {
-    swr?: SWRMutationConfiguration<Awaited$a<ReturnType<typeof deleteSchedule>>, TError, Key, Arguments, Awaited$a<ReturnType<typeof deleteSchedule>>> & {
+    swr?: SWRMutationConfiguration<Awaited$9<ReturnType<typeof deleteSchedule>>, TError, Key, Arguments, Awaited$9<ReturnType<typeof deleteSchedule>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$a<typeof customFetch>;
+    request?: SecondParameter$9<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<DeleteScheduleEnvelope, TError, string | readonly [`/v1/schedules/${string}`], Arguments>;
@@ -16856,9 +16885,9 @@ declare const useDeleteSchedule: <TError = ErrorType<ErrorResponse>>(scheduleId:
     swrKey: string | readonly [`/v1/schedules/${string}`];
 };
 
-type AwaitedInput$9<T> = PromiseLike<T> | T;
-type Awaited$9<O> = O extends AwaitedInput$9<infer T> ? T : never;
-type SecondParameter$9<T extends (...args: never) => unknown> = Parameters<T>[1];
+type AwaitedInput$8<T> = PromiseLike<T> | T;
+type Awaited$8<O> = O extends AwaitedInput$8<infer T> ? T : never;
+type SecondParameter$8<T extends (...args: never) => unknown> = Parameters<T>[1];
 declare const getCreateSecretUrl: () => string;
 /**
  * Create an organization-level secret. The value is encrypted at rest and **write-only** — no endpoint ever returns it.
@@ -16867,19 +16896,19 @@ declare const getCreateSecretUrl: () => string;
  * @summary Create a secret
  */
 declare const createSecret: (createSecretBody?: CreateSecretBody, options?: Parameters<typeof customFetch>[1]) => Promise<CreateSecretEnvelope>;
-declare const getCreateSecretMutationFetcher: (options?: SecondParameter$9<typeof customFetch>) => (_: Key, { arg }: {
+declare const getCreateSecretMutationFetcher: (options?: SecondParameter$8<typeof customFetch>) => (_: Key, { arg }: {
     arg: CreateSecretBody | undefined;
 }) => Promise<CreateSecretEnvelope>;
 declare const getCreateSecretMutationKey: () => readonly ["/v1/secrets"];
-type CreateSecretMutationResult = NonNullable<Awaited$9<ReturnType<typeof createSecret>>>;
+type CreateSecretMutationResult = NonNullable<Awaited$8<ReturnType<typeof createSecret>>>;
 /**
  * @summary Create a secret
  */
 declare const useCreateSecret: <TError = ErrorType<ErrorResponse>>(options?: {
-    swr?: SWRMutationConfiguration<Awaited$9<ReturnType<typeof createSecret>>, TError, Key, CreateSecretBody | undefined, Awaited$9<ReturnType<typeof createSecret>>> & {
+    swr?: SWRMutationConfiguration<Awaited$8<ReturnType<typeof createSecret>>, TError, Key, CreateSecretBody | undefined, Awaited$8<ReturnType<typeof createSecret>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$9<typeof customFetch>;
+    request?: SecondParameter$8<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<CreateSecretEnvelope, TError, string | readonly ["/v1/secrets"], CreateSecretBody | undefined>;
@@ -16895,16 +16924,16 @@ declare const getListSecretsUrl: (params?: ListSecretsParams) => string;
  */
 declare const listSecrets: (params?: ListSecretsParams, options?: Parameters<typeof customFetch>[1]) => Promise<ListSecretsEnvelope>;
 declare const getListSecretsKey: (params?: ListSecretsParams) => readonly ["/v1/secrets", ...ListSecretsParams[]];
-type ListSecretsQueryResult = NonNullable<Awaited$9<ReturnType<typeof listSecrets>>>;
+type ListSecretsQueryResult = NonNullable<Awaited$8<ReturnType<typeof listSecrets>>>;
 /**
  * @summary List secrets
  */
 declare const useListSecrets: <TError = ErrorType<ErrorResponse>>(params?: ListSecretsParams, options?: {
-    swr?: SWRConfiguration<Awaited$9<ReturnType<typeof listSecrets>>, TError> & {
+    swr?: SWRConfiguration<Awaited$8<ReturnType<typeof listSecrets>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$9<typeof customFetch>;
+    request?: SecondParameter$8<typeof customFetch>;
 }) => {
     data: ListSecretsEnvelope | undefined;
     error: TError | undefined;
@@ -16920,16 +16949,16 @@ declare const getGetSecretUrl: (secretId: string) => string;
  */
 declare const getSecret: (secretId: string, options?: Parameters<typeof customFetch>[1]) => Promise<GetSecretEnvelope>;
 declare const getGetSecretKey: (secretId: string) => readonly [`/v1/secrets/${string}`];
-type GetSecretQueryResult = NonNullable<Awaited$9<ReturnType<typeof getSecret>>>;
+type GetSecretQueryResult = NonNullable<Awaited$8<ReturnType<typeof getSecret>>>;
 /**
  * @summary Get secret
  */
 declare const useGetSecret: <TError = ErrorType<ErrorResponse>>(secretId: string, options?: {
-    swr?: SWRConfiguration<Awaited$9<ReturnType<typeof getSecret>>, TError> & {
+    swr?: SWRConfiguration<Awaited$8<ReturnType<typeof getSecret>>, TError> & {
         swrKey?: Key;
         enabled?: boolean;
     };
-    request?: SecondParameter$9<typeof customFetch>;
+    request?: SecondParameter$8<typeof customFetch>;
 }) => {
     data: GetSecretEnvelope | undefined;
     error: TError | undefined;
@@ -16948,19 +16977,19 @@ declare const getUpdateSecretUrl: (secretId: string) => string;
  * @summary Update secret
  */
 declare const updateSecret: (secretId: string, updateSecretBody?: UpdateSecretBody, options?: Parameters<typeof customFetch>[1]) => Promise<UpdateSecretEnvelope>;
-declare const getUpdateSecretMutationFetcher: (secretId: string, options?: SecondParameter$9<typeof customFetch>) => (_: Key, { arg }: {
+declare const getUpdateSecretMutationFetcher: (secretId: string, options?: SecondParameter$8<typeof customFetch>) => (_: Key, { arg }: {
     arg: UpdateSecretBody | undefined;
 }) => Promise<UpdateSecretEnvelope>;
 declare const getUpdateSecretMutationKey: (secretId: string) => readonly [`/v1/secrets/${string}`];
-type UpdateSecretMutationResult = NonNullable<Awaited$9<ReturnType<typeof updateSecret>>>;
+type UpdateSecretMutationResult = NonNullable<Awaited$8<ReturnType<typeof updateSecret>>>;
 /**
  * @summary Update secret
  */
 declare const useUpdateSecret: <TError = ErrorType<ErrorResponse>>(secretId: string, options?: {
-    swr?: SWRMutationConfiguration<Awaited$9<ReturnType<typeof updateSecret>>, TError, Key, UpdateSecretBody | undefined, Awaited$9<ReturnType<typeof updateSecret>>> & {
+    swr?: SWRMutationConfiguration<Awaited$8<ReturnType<typeof updateSecret>>, TError, Key, UpdateSecretBody | undefined, Awaited$8<ReturnType<typeof updateSecret>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$9<typeof customFetch>;
+    request?: SecondParameter$8<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<UpdateSecretEnvelope, TError, string | readonly [`/v1/secrets/${string}`], UpdateSecretBody | undefined>;
@@ -16975,19 +17004,19 @@ declare const getDeleteSecretUrl: (secretId: string) => string;
  * @summary Delete secret
  */
 declare const deleteSecret: (secretId: string, options?: Parameters<typeof customFetch>[1]) => Promise<DeleteSecretEnvelope>;
-declare const getDeleteSecretMutationFetcher: (secretId: string, options?: SecondParameter$9<typeof customFetch>) => (_: Key, __: {
+declare const getDeleteSecretMutationFetcher: (secretId: string, options?: SecondParameter$8<typeof customFetch>) => (_: Key, __: {
     arg: Arguments;
 }) => Promise<DeleteSecretEnvelope>;
 declare const getDeleteSecretMutationKey: (secretId: string) => readonly [`/v1/secrets/${string}`];
-type DeleteSecretMutationResult = NonNullable<Awaited$9<ReturnType<typeof deleteSecret>>>;
+type DeleteSecretMutationResult = NonNullable<Awaited$8<ReturnType<typeof deleteSecret>>>;
 /**
  * @summary Delete secret
  */
 declare const useDeleteSecret: <TError = ErrorType<ErrorResponse>>(secretId: string, options?: {
-    swr?: SWRMutationConfiguration<Awaited$9<ReturnType<typeof deleteSecret>>, TError, Key, Arguments, Awaited$9<ReturnType<typeof deleteSecret>>> & {
+    swr?: SWRMutationConfiguration<Awaited$8<ReturnType<typeof deleteSecret>>, TError, Key, Arguments, Awaited$8<ReturnType<typeof deleteSecret>>> & {
         swrKey?: string;
     };
-    request?: SecondParameter$9<typeof customFetch>;
+    request?: SecondParameter$8<typeof customFetch>;
 }) => {
     isMutating: boolean;
     trigger: swr_mutation.TriggerWithOptionsArgs<DeleteSecretEnvelope, TError, string | readonly [`/v1/secrets/${string}`], Arguments>;
@@ -16997,39 +17026,6 @@ declare const useDeleteSecret: <TError = ErrorType<ErrorResponse>>(secretId: str
     swrKey: string | readonly [`/v1/secrets/${string}`];
 };
 
-type AwaitedInput$8<T> = PromiseLike<T> | T;
-type Awaited$8<O> = O extends AwaitedInput$8<infer T> ? T : never;
-type SecondParameter$8<T extends (...args: never) => unknown> = Parameters<T>[1];
-declare const getRefreshSessionUrl: () => string;
-/**
- * Rotate the refresh token and return a new access token for `tenant_id`. Call it with a different `tenant_id` to switch tenants.
- *
- * Requires a valid user session (not an API key). The refresh token must belong to the same user, and the user must be a member of `tenant_id` (404 otherwise).
- * @summary Refresh session
- */
-declare const refreshSession: (refreshSessionBody?: RefreshSessionBody, options?: Parameters<typeof customFetch>[1]) => Promise<RefreshSessionEnvelope>;
-declare const getRefreshSessionMutationFetcher: (options?: SecondParameter$8<typeof customFetch>) => (_: Key, { arg }: {
-    arg: RefreshSessionBody | undefined;
-}) => Promise<RefreshSessionEnvelope>;
-declare const getRefreshSessionMutationKey: () => readonly ["/v1/auth/session/refresh"];
-type RefreshSessionMutationResult = NonNullable<Awaited$8<ReturnType<typeof refreshSession>>>;
-/**
- * @summary Refresh session
- */
-declare const useRefreshSession: <TError = ErrorType<ErrorResponse>>(options?: {
-    swr?: SWRMutationConfiguration<Awaited$8<ReturnType<typeof refreshSession>>, TError, Key, RefreshSessionBody | undefined, Awaited$8<ReturnType<typeof refreshSession>>> & {
-        swrKey?: string;
-    };
-    request?: SecondParameter$8<typeof customFetch>;
-}) => {
-    isMutating: boolean;
-    trigger: swr_mutation.TriggerWithOptionsArgs<RefreshSessionEnvelope, TError, string | readonly ["/v1/auth/session/refresh"], RefreshSessionBody | undefined>;
-    reset: () => void;
-    error: TError | undefined;
-    data: RefreshSessionEnvelope | undefined;
-    swrKey: string | readonly ["/v1/auth/session/refresh"];
-};
-
 type AwaitedInput$7<T> = PromiseLike<T> | T;
 type Awaited$7<O> = O extends AwaitedInput$7<infer T> ? T : never;
 type SecondParameter$7<T extends (...args: never) => unknown> = Parameters<T>[1];