@renai-labs/sdk 0.1.0

package/dist/generated/@tanstack/react-query.gen.js

@@ -0,0 +1,3431 @@
+// This file is auto-generated by @hey-api/openapi-ts
+import { infiniteQueryOptions, queryOptions } from '@tanstack/react-query';
+import { client } from '../client.gen';
+import { RenClient } from '../sdk.gen';
+const createQueryKey = (id, options, infinite, tags) => {
+    const params = { _id: id, baseUrl: options?.baseUrl || (options?.client ?? client).getConfig().baseUrl };
+    if (infinite) {
+        params._infinite = infinite;
+    }
+    if (tags) {
+        params.tags = tags;
+    }
+    if (options?.body) {
+        params.body = options.body;
+    }
+    if (options?.headers) {
+        params.headers = options.headers;
+    }
+    if (options?.path) {
+        params.path = options.path;
+    }
+    if (options?.query) {
+        params.query = options.query;
+    }
+    return [params];
+};
+export const composioMcpListQueryKey = (options) => createQueryKey('composioMcpList', options);
+/**
+ * List Composio MCPs
+ */
+export const composioMcpListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().composio.mcp.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: composioMcpListQueryKey(options)
+});
+const createInfiniteParams = (queryKey, page) => {
+    const params = { ...queryKey[0] };
+    if (page.body) {
+        params.body = {
+            ...queryKey[0].body,
+            ...page.body
+        };
+    }
+    if (page.headers) {
+        params.headers = {
+            ...queryKey[0].headers,
+            ...page.headers
+        };
+    }
+    if (page.path) {
+        params.path = {
+            ...queryKey[0].path,
+            ...page.path
+        };
+    }
+    if (page.query) {
+        params.query = {
+            ...queryKey[0].query,
+            ...page.query
+        };
+    }
+    return params;
+};
+export const composioMcpListInfiniteQueryKey = (options) => createQueryKey('composioMcpList', options, true);
+/**
+ * List Composio MCPs
+ */
+export const composioMcpListInfiniteOptions = (options) => infiniteQueryOptions(
+// @ts-ignore
+{
+    queryFn: async ({ pageParam, queryKey, signal }) => {
+        // @ts-ignore
+        const page = typeof pageParam === 'object' ? pageParam : {
+            query: {
+                offset: pageParam
+            }
+        };
+        const params = createInfiniteParams(queryKey, page);
+        const { data } = await RenClient.__registry.get().composio.mcp.list({
+            ...options,
+            ...params,
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: composioMcpListInfiniteQueryKey(options)
+});
+export const composioMcpGetQueryKey = (options) => createQueryKey('composioMcpGet', options);
+/**
+ * Get a Composio MCP
+ */
+export const composioMcpGetOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().composio.mcp.get({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: composioMcpGetQueryKey(options)
+});
+export const composioConnectionListQueryKey = (options) => createQueryKey('composioConnectionList', options);
+/**
+ * List Composio connections for the owner
+ */
+export const composioConnectionListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().composio.connection.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: composioConnectionListQueryKey(options)
+});
+export const composioConnectionListInfiniteQueryKey = (options) => createQueryKey('composioConnectionList', options, true);
+/**
+ * List Composio connections for the owner
+ */
+export const composioConnectionListInfiniteOptions = (options) => infiniteQueryOptions(
+// @ts-ignore
+{
+    queryFn: async ({ pageParam, queryKey, signal }) => {
+        // @ts-ignore
+        const page = typeof pageParam === 'object' ? pageParam : {
+            query: {
+                offset: pageParam
+            }
+        };
+        const params = createInfiniteParams(queryKey, page);
+        const { data } = await RenClient.__registry.get().composio.connection.list({
+            ...options,
+            ...params,
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: composioConnectionListInfiniteQueryKey(options)
+});
+/**
+ * Initiate a Composio connection (link + pending row, or reuse active)
+ */
+export const composioConnectionInitiateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().composio.connection.initiate({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const composioConnectionGetQueryKey = (options) => createQueryKey('composioConnectionGet', options);
+/**
+ * Get a Composio connection
+ */
+export const composioConnectionGetOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().composio.connection.get({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: composioConnectionGetQueryKey(options)
+});
+/**
+ * Poll Composio and reconcile connection status (pending→active transition)
+ */
+export const composioConnectionRefreshMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().composio.connection.refresh({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Archive a Composio connection (best-effort revoke + local archive)
+ */
+export const composioConnectionArchiveMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().composio.connection.archive({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const agentListQueryKey = (options) => createQueryKey('agentList', options);
+/**
+ * List agents
+ */
+export const agentListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().agent.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: agentListQueryKey(options)
+});
+export const agentListInfiniteQueryKey = (options) => createQueryKey('agentList', options, true);
+/**
+ * List agents
+ */
+export const agentListInfiniteOptions = (options) => infiniteQueryOptions(
+// @ts-ignore
+{
+    queryFn: async ({ pageParam, queryKey, signal }) => {
+        // @ts-ignore
+        const page = typeof pageParam === 'object' ? pageParam : {
+            query: {
+                offset: pageParam
+            }
+        };
+        const params = createInfiniteParams(queryKey, page);
+        const { data } = await RenClient.__registry.get().agent.list({
+            ...options,
+            ...params,
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: agentListInfiniteQueryKey(options)
+});
+/**
+ * Create an agent
+ */
+export const agentCreateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().agent.create({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const agentGetBySlugQueryKey = (options) => createQueryKey('agentGetBySlug', options);
+/**
+ * Get an agent by slug
+ */
+export const agentGetBySlugOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().agent.getBySlug({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: agentGetBySlugQueryKey(options)
+});
+export const agentGetQueryKey = (options) => createQueryKey('agentGet', options);
+/**
+ * Get an agent
+ */
+export const agentGetOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().agent.get({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: agentGetQueryKey(options)
+});
+/**
+ * Update agent metadata
+ */
+export const agentUpdateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().agent.update({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Archive an agent
+ */
+export const agentArchiveMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().agent.archive({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const agentVersionListQueryKey = (options) => createQueryKey('agentVersionList', options);
+/**
+ * List agent versions
+ */
+export const agentVersionListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().agent.version.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: agentVersionListQueryKey(options)
+});
+export const agentVersionListInfiniteQueryKey = (options) => createQueryKey('agentVersionList', options, true);
+/**
+ * List agent versions
+ */
+export const agentVersionListInfiniteOptions = (options) => infiniteQueryOptions(
+// @ts-ignore
+{
+    queryFn: async ({ pageParam, queryKey, signal }) => {
+        // @ts-ignore
+        const page = typeof pageParam === 'object' ? pageParam : {
+            query: {
+                offset: pageParam
+            }
+        };
+        const params = createInfiniteParams(queryKey, page);
+        const { data } = await RenClient.__registry.get().agent.version.list({
+            ...options,
+            ...params,
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: agentVersionListInfiniteQueryKey(options)
+});
+/**
+ * Create an agent version
+ */
+export const agentVersionCreateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().agent.version.create({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const agentVersionGetQueryKey = (options) => createQueryKey('agentVersionGet', options);
+/**
+ * Get an agent version
+ */
+export const agentVersionGetOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().agent.version.get({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: agentVersionGetQueryKey(options)
+});
+/**
+ * Archive an agent version
+ */
+export const agentVersionArchiveMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().agent.version.archive({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const dashboardGetQueryKey = (options) => createQueryKey('dashboardGet', options);
+/**
+ * Get dashboard analytics
+ */
+export const dashboardGetOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().dashboard.get({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: dashboardGetQueryKey(options)
+});
+export const environmentListQueryKey = (options) => createQueryKey('environmentList', options);
+/**
+ * List environments
+ */
+export const environmentListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().environment.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: environmentListQueryKey(options)
+});
+export const environmentListInfiniteQueryKey = (options) => createQueryKey('environmentList', options, true);
+/**
+ * List environments
+ */
+export const environmentListInfiniteOptions = (options) => infiniteQueryOptions(
+// @ts-ignore
+{
+    queryFn: async ({ pageParam, queryKey, signal }) => {
+        // @ts-ignore
+        const page = typeof pageParam === 'object' ? pageParam : {
+            query: {
+                offset: pageParam
+            }
+        };
+        const params = createInfiniteParams(queryKey, page);
+        const { data } = await RenClient.__registry.get().environment.list({
+            ...options,
+            ...params,
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: environmentListInfiniteQueryKey(options)
+});
+/**
+ * Create an environment
+ */
+export const environmentCreateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().environment.create({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Delete an environment permanently
+ */
+export const environmentDeleteMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().environment.delete({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const environmentGetQueryKey = (options) => createQueryKey('environmentGet', options);
+/**
+ * Get an environment
+ */
+export const environmentGetOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().environment.get({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: environmentGetQueryKey(options)
+});
+/**
+ * Update an environment
+ */
+export const environmentUpdateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().environment.update({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Archive an environment
+ */
+export const environmentArchiveMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().environment.archive({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const fileStoreListQueryKey = (options) => createQueryKey('fileStoreList', options);
+/**
+ * List file stores
+ */
+export const fileStoreListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().fileStore.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: fileStoreListQueryKey(options)
+});
+export const fileStoreListInfiniteQueryKey = (options) => createQueryKey('fileStoreList', options, true);
+/**
+ * List file stores
+ */
+export const fileStoreListInfiniteOptions = (options) => infiniteQueryOptions(
+// @ts-ignore
+{
+    queryFn: async ({ pageParam, queryKey, signal }) => {
+        // @ts-ignore
+        const page = typeof pageParam === 'object' ? pageParam : {
+            query: {
+                offset: pageParam
+            }
+        };
+        const params = createInfiniteParams(queryKey, page);
+        const { data } = await RenClient.__registry.get().fileStore.list({
+            ...options,
+            ...params,
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: fileStoreListInfiniteQueryKey(options)
+});
+/**
+ * Create a file store
+ */
+export const fileStoreCreateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().fileStore.create({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const fileStoreGetQueryKey = (options) => createQueryKey('fileStoreGet', options);
+/**
+ * Get a file store
+ */
+export const fileStoreGetOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().fileStore.get({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: fileStoreGetQueryKey(options)
+});
+/**
+ * Update a file store
+ */
+export const fileStoreUpdateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().fileStore.update({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Archive a file store
+ */
+export const fileStoreArchiveMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().fileStore.archive({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Delete a file
+ */
+export const fileStoreFilesDeleteMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().fileStore.files.delete({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const fileStoreFilesListQueryKey = (options) => createQueryKey('fileStoreFilesList', options);
+/**
+ * List files in a file store
+ */
+export const fileStoreFilesListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().fileStore.files.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: fileStoreFilesListQueryKey(options)
+});
+/**
+ * Upload file(s) via multipart/form-data
+ *
+ * Form fields: `files` (one or many), optional `path` (to override a single file's path), optional `prefix` (to prepend to all file names). For files >100MB, use /files/presign-upload.
+ */
+export const fileStoreFilesUploadMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().fileStore.files.upload({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const fileStoreFilesPresignDownloadQueryKey = (options) => createQueryKey('fileStoreFilesPresignDownload', options);
+/**
+ * Get a presigned GET URL for a file
+ */
+export const fileStoreFilesPresignDownloadOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().fileStore.files.presignDownload({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: fileStoreFilesPresignDownloadQueryKey(options)
+});
+/**
+ * Rename or move a file
+ */
+export const fileStoreFilesRenameMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().fileStore.files.rename({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Get a presigned PUT URL for a file
+ */
+export const fileStoreFilesPresignUploadMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().fileStore.files.presignUpload({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const mcpListQueryKey = (options) => createQueryKey('mcpList', options);
+/**
+ * List MCPs
+ */
+export const mcpListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().mcp.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: mcpListQueryKey(options)
+});
+export const mcpListInfiniteQueryKey = (options) => createQueryKey('mcpList', options, true);
+/**
+ * List MCPs
+ */
+export const mcpListInfiniteOptions = (options) => infiniteQueryOptions(
+// @ts-ignore
+{
+    queryFn: async ({ pageParam, queryKey, signal }) => {
+        // @ts-ignore
+        const page = typeof pageParam === 'object' ? pageParam : {
+            query: {
+                offset: pageParam
+            }
+        };
+        const params = createInfiniteParams(queryKey, page);
+        const { data } = await RenClient.__registry.get().mcp.list({
+            ...options,
+            ...params,
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: mcpListInfiniteQueryKey(options)
+});
+/**
+ * Create an MCP
+ */
+export const mcpCreateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().mcp.create({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const mcpGetBySlugQueryKey = (options) => createQueryKey('mcpGetBySlug', options);
+/**
+ * Get an MCP by slug
+ */
+export const mcpGetBySlugOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().mcp.getBySlug({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: mcpGetBySlugQueryKey(options)
+});
+export const mcpGetQueryKey = (options) => createQueryKey('mcpGet', options);
+/**
+ * Get an MCP
+ */
+export const mcpGetOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().mcp.get({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: mcpGetQueryKey(options)
+});
+/**
+ * Archive an MCP
+ */
+export const mcpArchiveMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().mcp.archive({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Start OAuth for an MCP (or confirm it is already connected)
+ */
+export const mcpOauthConnectMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().mcp.oauth.connect({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const mcpOauthSessionQueryKey = (options) => createQueryKey('mcpOauthSession', options);
+/**
+ * Poll an MCP OAuth session status
+ */
+export const mcpOauthSessionOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().mcp.oauth.session({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: mcpOauthSessionQueryKey(options)
+});
+export const memoryStoreListQueryKey = (options) => createQueryKey('memoryStoreList', options);
+/**
+ * List memory stores
+ */
+export const memoryStoreListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().memoryStore.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: memoryStoreListQueryKey(options)
+});
+export const memoryStoreListInfiniteQueryKey = (options) => createQueryKey('memoryStoreList', options, true);
+/**
+ * List memory stores
+ */
+export const memoryStoreListInfiniteOptions = (options) => infiniteQueryOptions(
+// @ts-ignore
+{
+    queryFn: async ({ pageParam, queryKey, signal }) => {
+        // @ts-ignore
+        const page = typeof pageParam === 'object' ? pageParam : {
+            query: {
+                offset: pageParam
+            }
+        };
+        const params = createInfiniteParams(queryKey, page);
+        const { data } = await RenClient.__registry.get().memoryStore.list({
+            ...options,
+            ...params,
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: memoryStoreListInfiniteQueryKey(options)
+});
+/**
+ * Create a memory store
+ */
+export const memoryStoreCreateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().memoryStore.create({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const memoryStoreGetQueryKey = (options) => createQueryKey('memoryStoreGet', options);
+/**
+ * Get a memory store
+ */
+export const memoryStoreGetOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().memoryStore.get({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: memoryStoreGetQueryKey(options)
+});
+/**
+ * Update a memory store
+ */
+export const memoryStoreUpdateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().memoryStore.update({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Archive a memory store
+ */
+export const memoryStoreArchiveMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().memoryStore.archive({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Delete a file
+ */
+export const memoryStoreFilesDeleteMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().memoryStore.files.delete({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const memoryStoreFilesListQueryKey = (options) => createQueryKey('memoryStoreFilesList', options);
+/**
+ * List files in a memory store
+ */
+export const memoryStoreFilesListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().memoryStore.files.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: memoryStoreFilesListQueryKey(options)
+});
+/**
+ * Upload file(s) via multipart/form-data
+ *
+ * Form fields: `files` (one or many), optional `path` (to override a single file's path), optional `prefix` (to prepend to all file names). For files >100MB, use /files/presign-upload.
+ */
+export const memoryStoreFilesUploadMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().memoryStore.files.upload({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const memoryStoreFilesDownloadQueryKey = (options) => createQueryKey('memoryStoreFilesDownload', options);
+/**
+ * Download a file (bytes proxied through API)
+ */
+export const memoryStoreFilesDownloadOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().memoryStore.files.download({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: memoryStoreFilesDownloadQueryKey(options)
+});
+/**
+ * Rename or move a file
+ */
+export const memoryStoreFilesRenameMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().memoryStore.files.rename({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const patListQueryKey = (options) => createQueryKey('patList', options);
+/**
+ * List personal access tokens
+ */
+export const patListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().pat.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: patListQueryKey(options)
+});
+/**
+ * Create a personal access token
+ */
+export const patCreateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pat.create({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Revoke a personal access token
+ */
+export const patRevokeMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pat.revoke({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const podListQueryKey = (options) => createQueryKey('podList', options);
+/**
+ * List pods
+ */
+export const podListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().pod.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podListQueryKey(options)
+});
+export const podListInfiniteQueryKey = (options) => createQueryKey('podList', options, true);
+/**
+ * List pods
+ */
+export const podListInfiniteOptions = (options) => infiniteQueryOptions(
+// @ts-ignore
+{
+    queryFn: async ({ pageParam, queryKey, signal }) => {
+        // @ts-ignore
+        const page = typeof pageParam === 'object' ? pageParam : {
+            query: {
+                offset: pageParam
+            }
+        };
+        const params = createInfiniteParams(queryKey, page);
+        const { data } = await RenClient.__registry.get().pod.list({
+            ...options,
+            ...params,
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podListInfiniteQueryKey(options)
+});
+/**
+ * Create a pod
+ */
+export const podCreateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.create({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const podGetQueryKey = (options) => createQueryKey('podGet', options);
+/**
+ * Get a pod
+ */
+export const podGetOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().pod.get({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podGetQueryKey(options)
+});
+/**
+ * Update a pod
+ */
+export const podUpdateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.update({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Archive a pod
+ */
+export const podArchiveMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.archive({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const podMemberListQueryKey = (options) => createQueryKey('podMemberList', options);
+/**
+ * List pod members
+ */
+export const podMemberListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().pod.member.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podMemberListQueryKey(options)
+});
+/**
+ * Add a member to a pod
+ */
+export const podMemberAddMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.member.add({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Remove a member from a pod
+ */
+export const podMemberRemoveMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.member.remove({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const podVaultListQueryKey = (options) => createQueryKey('podVaultList', options);
+/**
+ * List pod vaults (ordered by priority)
+ */
+export const podVaultListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().pod.vault.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podVaultListQueryKey(options)
+});
+/**
+ * Add a vault to a pod
+ */
+export const podVaultAddMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.vault.add({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Remove a vault from a pod
+ */
+export const podVaultRemoveMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.vault.remove({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const podSandboxCurrentQueryKey = (options) => createQueryKey('podSandboxCurrent', options);
+/**
+ * Get the current sandbox for this pod
+ */
+export const podSandboxCurrentOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().pod.sandbox.current({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podSandboxCurrentQueryKey(options)
+});
+/**
+ * Provision a sandbox for this pod (idempotent)
+ *
+ * Returns the existing active sandbox if one is linked; otherwise creates one.
+ */
+export const podSandboxProvisionMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.sandbox.provision({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const podProjectListQueryKey = (options) => createQueryKey('podProjectList', options);
+/**
+ * List projects
+ */
+export const podProjectListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().pod.project.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podProjectListQueryKey(options)
+});
+export const podProjectListInfiniteQueryKey = (options) => createQueryKey('podProjectList', options, true);
+/**
+ * List projects
+ */
+export const podProjectListInfiniteOptions = (options) => infiniteQueryOptions(
+// @ts-ignore
+{
+    queryFn: async ({ pageParam, queryKey, signal }) => {
+        // @ts-ignore
+        const page = typeof pageParam === 'object' ? pageParam : {
+            query: {
+                offset: pageParam
+            }
+        };
+        const params = createInfiniteParams(queryKey, page);
+        const { data } = await RenClient.__registry.get().pod.project.list({
+            ...options,
+            ...params,
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podProjectListInfiniteQueryKey(options)
+});
+/**
+ * Create a project
+ */
+export const podProjectCreateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.project.create({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const podProjectGetQueryKey = (options) => createQueryKey('podProjectGet', options);
+/**
+ * Get a project
+ */
+export const podProjectGetOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().pod.project.get({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podProjectGetQueryKey(options)
+});
+/**
+ * Update a project
+ */
+export const podProjectUpdateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.project.update({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Archive a project
+ */
+export const podProjectArchiveMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.project.archive({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const podProjectAgentListQueryKey = (options) => createQueryKey('podProjectAgentList', options);
+/**
+ * List project agents
+ */
+export const podProjectAgentListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().pod.project.agent.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podProjectAgentListQueryKey(options)
+});
+/**
+ * Add an agent to a project
+ */
+export const podProjectAgentAddMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.project.agent.add({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Remove an agent from a project
+ */
+export const podProjectAgentRemoveMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.project.agent.remove({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const podProjectFileStoreListQueryKey = (options) => createQueryKey('podProjectFileStoreList', options);
+/**
+ * List project file stores
+ */
+export const podProjectFileStoreListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().pod.project.fileStore.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podProjectFileStoreListQueryKey(options)
+});
+/**
+ * Attach a file store to a project
+ */
+export const podProjectFileStoreAddMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.project.fileStore.add({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Detach a file store from a project
+ */
+export const podProjectFileStoreRemoveMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.project.fileStore.remove({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const podProjectMemoryStoreListQueryKey = (options) => createQueryKey('podProjectMemoryStoreList', options);
+/**
+ * List project memory stores
+ */
+export const podProjectMemoryStoreListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().pod.project.memoryStore.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podProjectMemoryStoreListQueryKey(options)
+});
+/**
+ * Attach a memory store to a project
+ */
+export const podProjectMemoryStoreAddMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.project.memoryStore.add({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Detach a memory store from a project
+ */
+export const podProjectMemoryStoreRemoveMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.project.memoryStore.remove({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const podProjectRoutineListQueryKey = (options) => createQueryKey('podProjectRoutineList', options);
+/**
+ * List routines for a project
+ */
+export const podProjectRoutineListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().pod.project.routine.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podProjectRoutineListQueryKey(options)
+});
+export const podProjectRoutineListInfiniteQueryKey = (options) => createQueryKey('podProjectRoutineList', options, true);
+/**
+ * List routines for a project
+ */
+export const podProjectRoutineListInfiniteOptions = (options) => infiniteQueryOptions(
+// @ts-ignore
+{
+    queryFn: async ({ pageParam, queryKey, signal }) => {
+        // @ts-ignore
+        const page = typeof pageParam === 'object' ? pageParam : {
+            query: {
+                offset: pageParam
+            }
+        };
+        const params = createInfiniteParams(queryKey, page);
+        const { data } = await RenClient.__registry.get().pod.project.routine.list({
+            ...options,
+            ...params,
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podProjectRoutineListInfiniteQueryKey(options)
+});
+export const podProjectRoutinesRunsListAllQueryKey = (options) => createQueryKey('podProjectRoutinesRunsListAll', options);
+/**
+ * List routine runs across a project
+ */
+export const podProjectRoutinesRunsListAllOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().pod.project.routines.runs.listAll({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podProjectRoutinesRunsListAllQueryKey(options)
+});
+export const podProjectRoutinesRunsListAllInfiniteQueryKey = (options) => createQueryKey('podProjectRoutinesRunsListAll', options, true);
+/**
+ * List routine runs across a project
+ */
+export const podProjectRoutinesRunsListAllInfiniteOptions = (options) => infiniteQueryOptions(
+// @ts-ignore
+{
+    queryFn: async ({ pageParam, queryKey, signal }) => {
+        // @ts-ignore
+        const page = typeof pageParam === 'object' ? pageParam : {
+            query: {
+                offset: pageParam
+            }
+        };
+        const params = createInfiniteParams(queryKey, page);
+        const { data } = await RenClient.__registry.get().pod.project.routines.runs.listAll({
+            ...options,
+            ...params,
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podProjectRoutinesRunsListAllInfiniteQueryKey(options)
+});
+export const podSessionListQueryKey = (options) => createQueryKey('podSessionList', options);
+/**
+ * List sessions
+ */
+export const podSessionListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().pod.session.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podSessionListQueryKey(options)
+});
+export const podSessionListInfiniteQueryKey = (options) => createQueryKey('podSessionList', options, true);
+/**
+ * List sessions
+ */
+export const podSessionListInfiniteOptions = (options) => infiniteQueryOptions(
+// @ts-ignore
+{
+    queryFn: async ({ pageParam, queryKey, signal }) => {
+        // @ts-ignore
+        const page = typeof pageParam === 'object' ? pageParam : {
+            query: {
+                offset: pageParam
+            }
+        };
+        const params = createInfiniteParams(queryKey, page);
+        const { data } = await RenClient.__registry.get().pod.session.list({
+            ...options,
+            ...params,
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podSessionListInfiniteQueryKey(options)
+});
+/**
+ * Create a session
+ */
+export const podSessionCreateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.session.create({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const podSessionGetQueryKey = (options) => createQueryKey('podSessionGet', options);
+/**
+ * Get a session
+ */
+export const podSessionGetOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().pod.session.get({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podSessionGetQueryKey(options)
+});
+/**
+ * Update a session
+ */
+export const podSessionUpdateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.session.update({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Archive a session
+ */
+export const podSessionArchiveMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.session.archive({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const podSessionMessageListQueryKey = (options) => createQueryKey('podSessionMessageList', options);
+/**
+ * List session messages
+ */
+export const podSessionMessageListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().pod.session.message.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podSessionMessageListQueryKey(options)
+});
+export const podSessionMessageListInfiniteQueryKey = (options) => createQueryKey('podSessionMessageList', options, true);
+/**
+ * List session messages
+ */
+export const podSessionMessageListInfiniteOptions = (options) => infiniteQueryOptions(
+// @ts-ignore
+{
+    queryFn: async ({ pageParam, queryKey, signal }) => {
+        // @ts-ignore
+        const page = typeof pageParam === 'object' ? pageParam : {
+            query: {
+                offset: pageParam
+            }
+        };
+        const params = createInfiniteParams(queryKey, page);
+        const { data } = await RenClient.__registry.get().pod.session.message.list({
+            ...options,
+            ...params,
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podSessionMessageListInfiniteQueryKey(options)
+});
+export const podRoutineListQueryKey = (options) => createQueryKey('podRoutineList', options);
+/**
+ * List routines
+ */
+export const podRoutineListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().pod.routine.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podRoutineListQueryKey(options)
+});
+export const podRoutineListInfiniteQueryKey = (options) => createQueryKey('podRoutineList', options, true);
+/**
+ * List routines
+ */
+export const podRoutineListInfiniteOptions = (options) => infiniteQueryOptions(
+// @ts-ignore
+{
+    queryFn: async ({ pageParam, queryKey, signal }) => {
+        // @ts-ignore
+        const page = typeof pageParam === 'object' ? pageParam : {
+            query: {
+                offset: pageParam
+            }
+        };
+        const params = createInfiniteParams(queryKey, page);
+        const { data } = await RenClient.__registry.get().pod.routine.list({
+            ...options,
+            ...params,
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podRoutineListInfiniteQueryKey(options)
+});
+/**
+ * Create a routine
+ */
+export const podRoutineCreateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.routine.create({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const podRoutineGetQueryKey = (options) => createQueryKey('podRoutineGet', options);
+/**
+ * Get a routine
+ */
+export const podRoutineGetOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().pod.routine.get({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podRoutineGetQueryKey(options)
+});
+/**
+ * Update a routine
+ */
+export const podRoutineUpdateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.routine.update({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Archive a routine
+ */
+export const podRoutineArchiveMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.routine.archive({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Pause a routine
+ */
+export const podRoutinePauseMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.routine.pause({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Resume a routine
+ */
+export const podRoutineResumeMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.routine.resume({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const podRoutineCronTriggerListQueryKey = (options) => createQueryKey('podRoutineCronTriggerList', options);
+/**
+ * List cron triggers
+ */
+export const podRoutineCronTriggerListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().pod.routine.cronTrigger.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podRoutineCronTriggerListQueryKey(options)
+});
+export const podRoutineCronTriggerListInfiniteQueryKey = (options) => createQueryKey('podRoutineCronTriggerList', options, true);
+/**
+ * List cron triggers
+ */
+export const podRoutineCronTriggerListInfiniteOptions = (options) => infiniteQueryOptions(
+// @ts-ignore
+{
+    queryFn: async ({ pageParam, queryKey, signal }) => {
+        // @ts-ignore
+        const page = typeof pageParam === 'object' ? pageParam : {
+            query: {
+                offset: pageParam
+            }
+        };
+        const params = createInfiniteParams(queryKey, page);
+        const { data } = await RenClient.__registry.get().pod.routine.cronTrigger.list({
+            ...options,
+            ...params,
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podRoutineCronTriggerListInfiniteQueryKey(options)
+});
+/**
+ * Create a cron trigger
+ */
+export const podRoutineCronTriggerCreateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.routine.cronTrigger.create({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const podRoutineCronTriggerGetQueryKey = (options) => createQueryKey('podRoutineCronTriggerGet', options);
+/**
+ * Get a cron trigger
+ */
+export const podRoutineCronTriggerGetOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().pod.routine.cronTrigger.get({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podRoutineCronTriggerGetQueryKey(options)
+});
+/**
+ * Update a cron trigger
+ */
+export const podRoutineCronTriggerUpdateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.routine.cronTrigger.update({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Archive a cron trigger
+ */
+export const podRoutineCronTriggerArchiveMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.routine.cronTrigger.archive({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const podRoutineWebhookTriggerListQueryKey = (options) => createQueryKey('podRoutineWebhookTriggerList', options);
+/**
+ * List webhook triggers
+ */
+export const podRoutineWebhookTriggerListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().pod.routine.webhookTrigger.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podRoutineWebhookTriggerListQueryKey(options)
+});
+export const podRoutineWebhookTriggerListInfiniteQueryKey = (options) => createQueryKey('podRoutineWebhookTriggerList', options, true);
+/**
+ * List webhook triggers
+ */
+export const podRoutineWebhookTriggerListInfiniteOptions = (options) => infiniteQueryOptions(
+// @ts-ignore
+{
+    queryFn: async ({ pageParam, queryKey, signal }) => {
+        // @ts-ignore
+        const page = typeof pageParam === 'object' ? pageParam : {
+            query: {
+                offset: pageParam
+            }
+        };
+        const params = createInfiniteParams(queryKey, page);
+        const { data } = await RenClient.__registry.get().pod.routine.webhookTrigger.list({
+            ...options,
+            ...params,
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podRoutineWebhookTriggerListInfiniteQueryKey(options)
+});
+/**
+ * Create a webhook trigger
+ */
+export const podRoutineWebhookTriggerCreateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.routine.webhookTrigger.create({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const podRoutineWebhookTriggerGetQueryKey = (options) => createQueryKey('podRoutineWebhookTriggerGet', options);
+/**
+ * Get a webhook trigger
+ */
+export const podRoutineWebhookTriggerGetOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().pod.routine.webhookTrigger.get({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podRoutineWebhookTriggerGetQueryKey(options)
+});
+/**
+ * Update a webhook trigger
+ */
+export const podRoutineWebhookTriggerUpdateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.routine.webhookTrigger.update({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Archive a webhook trigger
+ */
+export const podRoutineWebhookTriggerArchiveMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.routine.webhookTrigger.archive({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const podRoutineApiTriggerListQueryKey = (options) => createQueryKey('podRoutineApiTriggerList', options);
+/**
+ * List API triggers
+ */
+export const podRoutineApiTriggerListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().pod.routine.apiTrigger.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podRoutineApiTriggerListQueryKey(options)
+});
+export const podRoutineApiTriggerListInfiniteQueryKey = (options) => createQueryKey('podRoutineApiTriggerList', options, true);
+/**
+ * List API triggers
+ */
+export const podRoutineApiTriggerListInfiniteOptions = (options) => infiniteQueryOptions(
+// @ts-ignore
+{
+    queryFn: async ({ pageParam, queryKey, signal }) => {
+        // @ts-ignore
+        const page = typeof pageParam === 'object' ? pageParam : {
+            query: {
+                offset: pageParam
+            }
+        };
+        const params = createInfiniteParams(queryKey, page);
+        const { data } = await RenClient.__registry.get().pod.routine.apiTrigger.list({
+            ...options,
+            ...params,
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podRoutineApiTriggerListInfiniteQueryKey(options)
+});
+/**
+ * Create an API trigger
+ *
+ * Server generates a single-use plaintext token. The token is returned ONCE in this response and never again — only its sha256 hash is stored.
+ */
+export const podRoutineApiTriggerCreateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.routine.apiTrigger.create({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Rotate an API trigger token
+ *
+ * Generates a new token, replaces the stored hash, returns the plaintext once.
+ */
+export const podRoutineApiTriggerRotateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.routine.apiTrigger.rotate({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const podRoutineApiTriggerGetQueryKey = (options) => createQueryKey('podRoutineApiTriggerGet', options);
+/**
+ * Get an API trigger
+ */
+export const podRoutineApiTriggerGetOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().pod.routine.apiTrigger.get({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podRoutineApiTriggerGetQueryKey(options)
+});
+/**
+ * Update an API trigger
+ */
+export const podRoutineApiTriggerUpdateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.routine.apiTrigger.update({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Archive an API trigger
+ */
+export const podRoutineApiTriggerArchiveMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.routine.apiTrigger.archive({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const podRoutineRunsListQueryKey = (options) => createQueryKey('podRoutineRunsList', options);
+/**
+ * List routine runs
+ */
+export const podRoutineRunsListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().pod.routine.runs.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podRoutineRunsListQueryKey(options)
+});
+export const podRoutineRunsListInfiniteQueryKey = (options) => createQueryKey('podRoutineRunsList', options, true);
+/**
+ * List routine runs
+ */
+export const podRoutineRunsListInfiniteOptions = (options) => infiniteQueryOptions(
+// @ts-ignore
+{
+    queryFn: async ({ pageParam, queryKey, signal }) => {
+        // @ts-ignore
+        const page = typeof pageParam === 'object' ? pageParam : {
+            query: {
+                offset: pageParam
+            }
+        };
+        const params = createInfiniteParams(queryKey, page);
+        const { data } = await RenClient.__registry.get().pod.routine.runs.list({
+            ...options,
+            ...params,
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podRoutineRunsListInfiniteQueryKey(options)
+});
+/**
+ * Create a routine run
+ */
+export const podRoutineRunsCreateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.routine.runs.create({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const podRoutineRunsGetQueryKey = (options) => createQueryKey('podRoutineRunsGet', options);
+/**
+ * Get a routine run
+ */
+export const podRoutineRunsGetOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().pod.routine.runs.get({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podRoutineRunsGetQueryKey(options)
+});
+/**
+ * Mark a routine run as started
+ */
+export const podRoutineRunsStartMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.routine.runs.start({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Mark a routine run as completed
+ */
+export const podRoutineRunsCompleteMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.routine.runs.complete({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Mark a routine run as failed
+ */
+export const podRoutineRunsFailMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.routine.runs.fail({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Cancel a routine run
+ */
+export const podRoutineRunsCancelMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().pod.routine.runs.cancel({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const podRoutinesRunsListAllQueryKey = (options) => createQueryKey('podRoutinesRunsListAll', options);
+/**
+ * List routine runs across pod
+ */
+export const podRoutinesRunsListAllOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().pod.routines.runs.listAll({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podRoutinesRunsListAllQueryKey(options)
+});
+export const podRoutinesRunsListAllInfiniteQueryKey = (options) => createQueryKey('podRoutinesRunsListAll', options, true);
+/**
+ * List routine runs across pod
+ */
+export const podRoutinesRunsListAllInfiniteOptions = (options) => infiniteQueryOptions(
+// @ts-ignore
+{
+    queryFn: async ({ pageParam, queryKey, signal }) => {
+        // @ts-ignore
+        const page = typeof pageParam === 'object' ? pageParam : {
+            query: {
+                offset: pageParam
+            }
+        };
+        const params = createInfiniteParams(queryKey, page);
+        const { data } = await RenClient.__registry.get().pod.routines.runs.listAll({
+            ...options,
+            ...params,
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: podRoutinesRunsListAllInfiniteQueryKey(options)
+});
+export const replayListQueryKey = (options) => createQueryKey('replayList', options);
+/**
+ * List replays
+ */
+export const replayListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().replay.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: replayListQueryKey(options)
+});
+export const replayListInfiniteQueryKey = (options) => createQueryKey('replayList', options, true);
+/**
+ * List replays
+ */
+export const replayListInfiniteOptions = (options) => infiniteQueryOptions(
+// @ts-ignore
+{
+    queryFn: async ({ pageParam, queryKey, signal }) => {
+        // @ts-ignore
+        const page = typeof pageParam === 'object' ? pageParam : {
+            query: {
+                offset: pageParam
+            }
+        };
+        const params = createInfiniteParams(queryKey, page);
+        const { data } = await RenClient.__registry.get().replay.list({
+            ...options,
+            ...params,
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: replayListInfiniteQueryKey(options)
+});
+/**
+ * Create a replay
+ */
+export const replayCreateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().replay.create({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const replayGetQueryKey = (options) => createQueryKey('replayGet', options);
+/**
+ * Get a replay
+ */
+export const replayGetOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().replay.get({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: replayGetQueryKey(options)
+});
+/**
+ * Archive a replay
+ */
+export const replayArchiveMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().replay.archive({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const routinesRunsListAllQueryKey = (options) => createQueryKey('routinesRunsListAll', options);
+/**
+ * List routine runs across user
+ */
+export const routinesRunsListAllOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().routines.runs.listAll({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: routinesRunsListAllQueryKey(options)
+});
+export const routinesRunsListAllInfiniteQueryKey = (options) => createQueryKey('routinesRunsListAll', options, true);
+/**
+ * List routine runs across user
+ */
+export const routinesRunsListAllInfiniteOptions = (options) => infiniteQueryOptions(
+// @ts-ignore
+{
+    queryFn: async ({ pageParam, queryKey, signal }) => {
+        // @ts-ignore
+        const page = typeof pageParam === 'object' ? pageParam : {
+            query: {
+                offset: pageParam
+            }
+        };
+        const params = createInfiniteParams(queryKey, page);
+        const { data } = await RenClient.__registry.get().routines.runs.listAll({
+            ...options,
+            ...params,
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: routinesRunsListAllInfiniteQueryKey(options)
+});
+export const sessionListQueryKey = (options) => createQueryKey('sessionList', options);
+/**
+ * List sessions across pods for the authenticated user
+ */
+export const sessionListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().session.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: sessionListQueryKey(options)
+});
+export const sessionListInfiniteQueryKey = (options) => createQueryKey('sessionList', options, true);
+/**
+ * List sessions across pods for the authenticated user
+ */
+export const sessionListInfiniteOptions = (options) => infiniteQueryOptions(
+// @ts-ignore
+{
+    queryFn: async ({ pageParam, queryKey, signal }) => {
+        // @ts-ignore
+        const page = typeof pageParam === 'object' ? pageParam : {
+            query: {
+                offset: pageParam
+            }
+        };
+        const params = createInfiniteParams(queryKey, page);
+        const { data } = await RenClient.__registry.get().session.list({
+            ...options,
+            ...params,
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: sessionListInfiniteQueryKey(options)
+});
+export const sessionGetQueryKey = (options) => createQueryKey('sessionGet', options);
+/**
+ * Get a session by org scope
+ */
+export const sessionGetOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().session.get({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: sessionGetQueryKey(options)
+});
+export const skillListQueryKey = (options) => createQueryKey('skillList', options);
+/**
+ * List skills
+ */
+export const skillListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().skill.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: skillListQueryKey(options)
+});
+export const skillListInfiniteQueryKey = (options) => createQueryKey('skillList', options, true);
+/**
+ * List skills
+ */
+export const skillListInfiniteOptions = (options) => infiniteQueryOptions(
+// @ts-ignore
+{
+    queryFn: async ({ pageParam, queryKey, signal }) => {
+        // @ts-ignore
+        const page = typeof pageParam === 'object' ? pageParam : {
+            query: {
+                offset: pageParam
+            }
+        };
+        const params = createInfiniteParams(queryKey, page);
+        const { data } = await RenClient.__registry.get().skill.list({
+            ...options,
+            ...params,
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: skillListInfiniteQueryKey(options)
+});
+/**
+ * Create a skill
+ */
+export const skillCreateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().skill.create({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const skillGetBySlugQueryKey = (options) => createQueryKey('skillGetBySlug', options);
+/**
+ * Get a skill by slug
+ */
+export const skillGetBySlugOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().skill.getBySlug({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: skillGetBySlugQueryKey(options)
+});
+export const skillGetQueryKey = (options) => createQueryKey('skillGet', options);
+/**
+ * Get a skill
+ */
+export const skillGetOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().skill.get({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: skillGetQueryKey(options)
+});
+/**
+ * Update skill metadata
+ */
+export const skillUpdateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().skill.update({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Archive a skill
+ */
+export const skillArchiveMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().skill.archive({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Copy a skill
+ */
+export const skillCopyMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().skill.copy({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const skillVersionListQueryKey = (options) => createQueryKey('skillVersionList', options);
+/**
+ * List skill versions
+ */
+export const skillVersionListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().skill.version.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: skillVersionListQueryKey(options)
+});
+export const skillVersionListInfiniteQueryKey = (options) => createQueryKey('skillVersionList', options, true);
+/**
+ * List skill versions
+ */
+export const skillVersionListInfiniteOptions = (options) => infiniteQueryOptions(
+// @ts-ignore
+{
+    queryFn: async ({ pageParam, queryKey, signal }) => {
+        // @ts-ignore
+        const page = typeof pageParam === 'object' ? pageParam : {
+            query: {
+                offset: pageParam
+            }
+        };
+        const params = createInfiniteParams(queryKey, page);
+        const { data } = await RenClient.__registry.get().skill.version.list({
+            ...options,
+            ...params,
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: skillVersionListInfiniteQueryKey(options)
+});
+/**
+ * Create a skill version
+ */
+export const skillVersionCreateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().skill.version.create({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const skillVersionGetQueryKey = (options) => createQueryKey('skillVersionGet', options);
+/**
+ * Get a skill version
+ */
+export const skillVersionGetOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().skill.version.get({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: skillVersionGetQueryKey(options)
+});
+export const skillVersionDataQueryKey = (options) => createQueryKey('skillVersionData', options);
+/**
+ * Read skill version data
+ */
+export const skillVersionDataOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().skill.version.data({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: skillVersionDataQueryKey(options)
+});
+/**
+ * Archive a skill version
+ */
+export const skillVersionArchiveMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().skill.version.archive({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const vaultListQueryKey = (options) => createQueryKey('vaultList', options);
+/**
+ * List vaults
+ */
+export const vaultListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().vault.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: vaultListQueryKey(options)
+});
+export const vaultListInfiniteQueryKey = (options) => createQueryKey('vaultList', options, true);
+/**
+ * List vaults
+ */
+export const vaultListInfiniteOptions = (options) => infiniteQueryOptions(
+// @ts-ignore
+{
+    queryFn: async ({ pageParam, queryKey, signal }) => {
+        // @ts-ignore
+        const page = typeof pageParam === 'object' ? pageParam : {
+            query: {
+                offset: pageParam
+            }
+        };
+        const params = createInfiniteParams(queryKey, page);
+        const { data } = await RenClient.__registry.get().vault.list({
+            ...options,
+            ...params,
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: vaultListInfiniteQueryKey(options)
+});
+/**
+ * Create a vault
+ */
+export const vaultCreateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().vault.create({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Delete a vault permanently
+ */
+export const vaultDeleteMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().vault.delete({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const vaultGetQueryKey = (options) => createQueryKey('vaultGet', options);
+/**
+ * Get a vault
+ */
+export const vaultGetOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().vault.get({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: vaultGetQueryKey(options)
+});
+/**
+ * Update a vault (name, description)
+ */
+export const vaultUpdateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().vault.update({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Archive a vault
+ */
+export const vaultArchiveMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().vault.archive({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const credentialListQueryKey = (options) => createQueryKey('credentialList', options);
+/**
+ * List credentials
+ */
+export const credentialListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().credential.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: credentialListQueryKey(options)
+});
+export const credentialListInfiniteQueryKey = (options) => createQueryKey('credentialList', options, true);
+/**
+ * List credentials
+ */
+export const credentialListInfiniteOptions = (options) => infiniteQueryOptions(
+// @ts-ignore
+{
+    queryFn: async ({ pageParam, queryKey, signal }) => {
+        // @ts-ignore
+        const page = typeof pageParam === 'object' ? pageParam : {
+            query: {
+                offset: pageParam
+            }
+        };
+        const params = createInfiniteParams(queryKey, page);
+        const { data } = await RenClient.__registry.get().credential.list({
+            ...options,
+            ...params,
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: credentialListInfiniteQueryKey(options)
+});
+/**
+ * Create a credential
+ */
+export const credentialCreateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().credential.create({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Delete a credential permanently
+ */
+export const credentialDeleteMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().credential.delete({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const credentialGetQueryKey = (options) => createQueryKey('credentialGet', options);
+/**
+ * Get a credential
+ */
+export const credentialGetOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().credential.get({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: credentialGetQueryKey(options)
+});
+/**
+ * Update a credential (rename or rotate value)
+ */
+export const credentialUpdateMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().credential.update({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Archive a credential
+ */
+export const credentialArchiveMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().credential.archive({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+/**
+ * Begin SDK-delegated OAuth flow against an MCP
+ */
+export const credentialOauthStartMutation = (options) => {
+    const mutationOptions = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await RenClient.__registry.get().credential.oauth.start({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+export const credentialOauthSessionQueryKey = (options) => createQueryKey('credentialOauthSession', options);
+/**
+ * Poll an OAuth session's status
+ */
+export const credentialOauthSessionOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().credential.oauth.session({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: credentialOauthSessionQueryKey(options)
+});
+export const registryAgentListQueryKey = (options) => createQueryKey('registryAgentList', options);
+/**
+ * List registry agents
+ */
+export const registryAgentListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().registry.agent.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: registryAgentListQueryKey(options)
+});
+export const registryAgentListInfiniteQueryKey = (options) => createQueryKey('registryAgentList', options, true);
+/**
+ * List registry agents
+ */
+export const registryAgentListInfiniteOptions = (options) => infiniteQueryOptions(
+// @ts-ignore
+{
+    queryFn: async ({ pageParam, queryKey, signal }) => {
+        // @ts-ignore
+        const page = typeof pageParam === 'object' ? pageParam : {
+            query: {
+                offset: pageParam
+            }
+        };
+        const params = createInfiniteParams(queryKey, page);
+        const { data } = await RenClient.__registry.get().registry.agent.list({
+            ...options,
+            ...params,
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: registryAgentListInfiniteQueryKey(options)
+});
+export const registryAgentGetQueryKey = (options) => createQueryKey('registryAgentGet', options);
+/**
+ * Get a registry agent
+ */
+export const registryAgentGetOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().registry.agent.get({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: registryAgentGetQueryKey(options)
+});
+export const registrySkillListQueryKey = (options) => createQueryKey('registrySkillList', options);
+/**
+ * List registry skills
+ */
+export const registrySkillListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().registry.skill.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: registrySkillListQueryKey(options)
+});
+export const registrySkillListInfiniteQueryKey = (options) => createQueryKey('registrySkillList', options, true);
+/**
+ * List registry skills
+ */
+export const registrySkillListInfiniteOptions = (options) => infiniteQueryOptions(
+// @ts-ignore
+{
+    queryFn: async ({ pageParam, queryKey, signal }) => {
+        // @ts-ignore
+        const page = typeof pageParam === 'object' ? pageParam : {
+            query: {
+                offset: pageParam
+            }
+        };
+        const params = createInfiniteParams(queryKey, page);
+        const { data } = await RenClient.__registry.get().registry.skill.list({
+            ...options,
+            ...params,
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: registrySkillListInfiniteQueryKey(options)
+});
+export const registrySkillGetQueryKey = (options) => createQueryKey('registrySkillGet', options);
+/**
+ * Get a registry skill
+ */
+export const registrySkillGetOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().registry.skill.get({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: registrySkillGetQueryKey(options)
+});
+export const registryMcpListQueryKey = (options) => createQueryKey('registryMcpList', options);
+/**
+ * List registry MCPs
+ */
+export const registryMcpListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().registry.mcp.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: registryMcpListQueryKey(options)
+});
+export const registryMcpListInfiniteQueryKey = (options) => createQueryKey('registryMcpList', options, true);
+/**
+ * List registry MCPs
+ */
+export const registryMcpListInfiniteOptions = (options) => infiniteQueryOptions(
+// @ts-ignore
+{
+    queryFn: async ({ pageParam, queryKey, signal }) => {
+        // @ts-ignore
+        const page = typeof pageParam === 'object' ? pageParam : {
+            query: {
+                offset: pageParam
+            }
+        };
+        const params = createInfiniteParams(queryKey, page);
+        const { data } = await RenClient.__registry.get().registry.mcp.list({
+            ...options,
+            ...params,
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: registryMcpListInfiniteQueryKey(options)
+});
+export const registryMcpGetQueryKey = (options) => createQueryKey('registryMcpGet', options);
+/**
+ * Get a registry MCP
+ */
+export const registryMcpGetOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().registry.mcp.get({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: registryMcpGetQueryKey(options)
+});
+export const registryComposioMcpListQueryKey = (options) => createQueryKey('registryComposioMcpList', options);
+/**
+ * List Composio MCPs
+ */
+export const registryComposioMcpListOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().registry.composioMcp.list({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: registryComposioMcpListQueryKey(options)
+});
+export const registryComposioMcpListInfiniteQueryKey = (options) => createQueryKey('registryComposioMcpList', options, true);
+/**
+ * List Composio MCPs
+ */
+export const registryComposioMcpListInfiniteOptions = (options) => infiniteQueryOptions(
+// @ts-ignore
+{
+    queryFn: async ({ pageParam, queryKey, signal }) => {
+        // @ts-ignore
+        const page = typeof pageParam === 'object' ? pageParam : {
+            query: {
+                offset: pageParam
+            }
+        };
+        const params = createInfiniteParams(queryKey, page);
+        const { data } = await RenClient.__registry.get().registry.composioMcp.list({
+            ...options,
+            ...params,
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: registryComposioMcpListInfiniteQueryKey(options)
+});
+export const registryComposioMcpGetQueryKey = (options) => createQueryKey('registryComposioMcpGet', options);
+/**
+ * Get a Composio MCP
+ */
+export const registryComposioMcpGetOptions = (options) => queryOptions({
+    queryFn: async ({ queryKey, signal }) => {
+        const { data } = await RenClient.__registry.get().registry.composioMcp.get({
+            ...options,
+            ...queryKey[0],
+            signal,
+            throwOnError: true
+        });
+        return data;
+    },
+    queryKey: registryComposioMcpGetQueryKey(options)
+});