@openrouter/sdk 0.0.0-beta.4 → 0.0.0-beta.5

package/src/react-query/{parametersGetParametersAuthorSlug.ts → modelGetParametersAuthorSlug.ts}

@@ -13,7 +13,7 @@ import {
   UseSuspenseQueryResult,
 } from "@tanstack/react-query";
 import { OpenRouterCore } from "../core.js";
-import { parametersGetParametersAuthorSlug } from "../funcs/parametersGetParametersAuthorSlug.js";
+import { modelGetParametersAuthorSlug } from "../funcs/modelGetParametersAuthorSlug.js";
 import { combineSignals } from "../lib/primitives.js";
 import { RequestOptions } from "../lib/sdks.js";
 import * as operations from "../models/operations/index.js";
@@ -25,20 +25,20 @@ import {
   TupleToPrefixes,
 } from "./_types.js";
 
-export type ParametersGetParametersAuthorSlugQueryData =
+export type ModelGetParametersAuthorSlugQueryData =
   operations.GetParametersAuthorSlugResponse;
 
 /**
  * Get a model's supported parameters and data about which are most popular
  */
-export function useParametersGetParametersAuthorSlug(
+export function useModelGetParametersAuthorSlug(
   security: operations.GetParametersAuthorSlugSecurity,
   request: operations.GetParametersAuthorSlugRequest,
-  options?: QueryHookOptions<ParametersGetParametersAuthorSlugQueryData>,
-): UseQueryResult<ParametersGetParametersAuthorSlugQueryData, Error> {
+  options?: QueryHookOptions<ModelGetParametersAuthorSlugQueryData>,
+): UseQueryResult<ModelGetParametersAuthorSlugQueryData, Error> {
   const client = useOpenRouterContext();
   return useQuery({
-    ...buildParametersGetParametersAuthorSlugQuery(
+    ...buildModelGetParametersAuthorSlugQuery(
       client,
       security,
       request,
@@ -51,16 +51,14 @@ export function useParametersGetParametersAuthorSlug(
 /**
  * Get a model's supported parameters and data about which are most popular
  */
-export function useParametersGetParametersAuthorSlugSuspense(
+export function useModelGetParametersAuthorSlugSuspense(
   security: operations.GetParametersAuthorSlugSecurity,
   request: operations.GetParametersAuthorSlugRequest,
-  options?: SuspenseQueryHookOptions<
-    ParametersGetParametersAuthorSlugQueryData
-  >,
-): UseSuspenseQueryResult<ParametersGetParametersAuthorSlugQueryData, Error> {
+  options?: SuspenseQueryHookOptions<ModelGetParametersAuthorSlugQueryData>,
+): UseSuspenseQueryResult<ModelGetParametersAuthorSlugQueryData, Error> {
   const client = useOpenRouterContext();
   return useSuspenseQuery({
-    ...buildParametersGetParametersAuthorSlugQuery(
+    ...buildModelGetParametersAuthorSlugQuery(
       client,
       security,
       request,
@@ -70,14 +68,14 @@ export function useParametersGetParametersAuthorSlugSuspense(
   });
 }
 
-export function prefetchParametersGetParametersAuthorSlug(
+export function prefetchModelGetParametersAuthorSlug(
   queryClient: QueryClient,
   client$: OpenRouterCore,
   security: operations.GetParametersAuthorSlugSecurity,
   request: operations.GetParametersAuthorSlugRequest,
 ): Promise<void> {
   return queryClient.prefetchQuery({
-    ...buildParametersGetParametersAuthorSlugQuery(
+    ...buildModelGetParametersAuthorSlugQuery(
       client$,
       security,
       request,
@@ -85,7 +83,7 @@ export function prefetchParametersGetParametersAuthorSlug(
   });
 }
 
-export function setParametersGetParametersAuthorSlugData(
+export function setModelGetParametersAuthorSlugData(
   client: QueryClient,
   queryKeyBase: [
     author: string,
@@ -94,17 +92,14 @@ export function setParametersGetParametersAuthorSlugData(
       provider?: operations.GetParametersAuthorSlugProvider | undefined;
     },
   ],
-  data: ParametersGetParametersAuthorSlugQueryData,
-): ParametersGetParametersAuthorSlugQueryData | undefined {
-  const key = queryKeyParametersGetParametersAuthorSlug(...queryKeyBase);
+  data: ModelGetParametersAuthorSlugQueryData,
+): ModelGetParametersAuthorSlugQueryData | undefined {
+  const key = queryKeyModelGetParametersAuthorSlug(...queryKeyBase);
 
-  return client.setQueryData<ParametersGetParametersAuthorSlugQueryData>(
-    key,
-    data,
-  );
+  return client.setQueryData<ModelGetParametersAuthorSlugQueryData>(key, data);
 }
 
-export function invalidateParametersGetParametersAuthorSlug(
+export function invalidateModelGetParametersAuthorSlug(
   client: QueryClient,
   queryKeyBase: TupleToPrefixes<
     [
@@ -121,24 +116,24 @@ export function invalidateParametersGetParametersAuthorSlug(
     ...filters,
     queryKey: [
       "@openrouter/sdk",
-      "Parameters",
+      "Model",
       "getParametersAuthorSlug",
       ...queryKeyBase,
     ],
   });
 }
 
-export function invalidateAllParametersGetParametersAuthorSlug(
+export function invalidateAllModelGetParametersAuthorSlug(
   client: QueryClient,
   filters?: Omit<InvalidateQueryFilters, "queryKey" | "predicate" | "exact">,
 ): Promise<void> {
   return client.invalidateQueries({
     ...filters,
-    queryKey: ["@openrouter/sdk", "Parameters", "getParametersAuthorSlug"],
+    queryKey: ["@openrouter/sdk", "Model", "getParametersAuthorSlug"],
   });
 }
 
-export function buildParametersGetParametersAuthorSlugQuery(
+export function buildModelGetParametersAuthorSlugQuery(
   client$: OpenRouterCore,
   security: operations.GetParametersAuthorSlugSecurity,
   request: operations.GetParametersAuthorSlugRequest,
@@ -147,24 +142,24 @@ export function buildParametersGetParametersAuthorSlugQuery(
   queryKey: QueryKey;
   queryFn: (
     context: QueryFunctionContext,
-  ) => Promise<ParametersGetParametersAuthorSlugQueryData>;
+  ) => Promise<ModelGetParametersAuthorSlugQueryData>;
 } {
   return {
-    queryKey: queryKeyParametersGetParametersAuthorSlug(
+    queryKey: queryKeyModelGetParametersAuthorSlug(
       request.author,
       request.slug,
       { provider: request.provider },
     ),
-    queryFn: async function parametersGetParametersAuthorSlugQueryFn(
+    queryFn: async function modelGetParametersAuthorSlugQueryFn(
       ctx,
-    ): Promise<ParametersGetParametersAuthorSlugQueryData> {
+    ): Promise<ModelGetParametersAuthorSlugQueryData> {
       const sig = combineSignals(ctx.signal, options?.fetchOptions?.signal);
       const mergedOptions = {
         ...options,
         fetchOptions: { ...options?.fetchOptions, signal: sig },
       };
 
-      return unwrapAsync(parametersGetParametersAuthorSlug(
+      return unwrapAsync(modelGetParametersAuthorSlug(
         client$,
         security,
         request,
@@ -174,7 +169,7 @@ export function buildParametersGetParametersAuthorSlugQuery(
   };
 }
 
-export function queryKeyParametersGetParametersAuthorSlug(
+export function queryKeyModelGetParametersAuthorSlug(
   author: string,
   slug: string,
   parameters: {
@@ -183,7 +178,7 @@ export function queryKeyParametersGetParametersAuthorSlug(
 ): QueryKey {
   return [
     "@openrouter/sdk",
-    "Parameters",
+    "Model",
     "getParametersAuthorSlug",
     author,
     slug,

package/src/react-query/oAuthPostAuthKeys.ts

@@ -0,0 +1,88 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import {
+  MutationKey,
+  useMutation,
+  UseMutationResult,
+} from "@tanstack/react-query";
+import { OpenRouterCore } from "../core.js";
+import { oAuthPostAuthKeys } from "../funcs/oAuthPostAuthKeys.js";
+import { combineSignals } from "../lib/primitives.js";
+import { RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+import { useOpenRouterContext } from "./_context.js";
+import { MutationHookOptions } from "./_types.js";
+
+export type OAuthPostAuthKeysMutationVariables = {
+  request?: operations.PostAuthKeysRequest | undefined;
+  options?: RequestOptions;
+};
+
+export type OAuthPostAuthKeysMutationData = operations.PostAuthKeysResponse;
+
+/**
+ * Exchange authorization code for API key
+ *
+ * @remarks
+ * Exchange an authorization code from the PKCE flow for a user-controlled API key
+ */
+export function useOAuthPostAuthKeysMutation(
+  options?: MutationHookOptions<
+    OAuthPostAuthKeysMutationData,
+    Error,
+    OAuthPostAuthKeysMutationVariables
+  >,
+): UseMutationResult<
+  OAuthPostAuthKeysMutationData,
+  Error,
+  OAuthPostAuthKeysMutationVariables
+> {
+  const client = useOpenRouterContext();
+  return useMutation({
+    ...buildOAuthPostAuthKeysMutation(client, options),
+    ...options,
+  });
+}
+
+export function mutationKeyOAuthPostAuthKeys(): MutationKey {
+  return ["@openrouter/sdk", "OAuth", "postAuthKeys"];
+}
+
+export function buildOAuthPostAuthKeysMutation(
+  client$: OpenRouterCore,
+  hookOptions?: RequestOptions,
+): {
+  mutationKey: MutationKey;
+  mutationFn: (
+    variables: OAuthPostAuthKeysMutationVariables,
+  ) => Promise<OAuthPostAuthKeysMutationData>;
+} {
+  return {
+    mutationKey: mutationKeyOAuthPostAuthKeys(),
+    mutationFn: function oAuthPostAuthKeysMutationFn({
+      request,
+      options,
+    }): Promise<OAuthPostAuthKeysMutationData> {
+      const mergedOptions = {
+        ...hookOptions,
+        ...options,
+        fetchOptions: {
+          ...hookOptions?.fetchOptions,
+          ...options?.fetchOptions,
+          signal: combineSignals(
+            hookOptions?.fetchOptions?.signal,
+            options?.fetchOptions?.signal,
+          ),
+        },
+      };
+      return unwrapAsync(oAuthPostAuthKeys(
+        client$,
+        request,
+        mergedOptions,
+      ));
+    },
+  };
+}

package/src/react-query/oAuthPostAuthKeysCode.ts

@@ -0,0 +1,89 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import {
+  MutationKey,
+  useMutation,
+  UseMutationResult,
+} from "@tanstack/react-query";
+import { OpenRouterCore } from "../core.js";
+import { oAuthPostAuthKeysCode } from "../funcs/oAuthPostAuthKeysCode.js";
+import { combineSignals } from "../lib/primitives.js";
+import { RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+import { useOpenRouterContext } from "./_context.js";
+import { MutationHookOptions } from "./_types.js";
+
+export type OAuthPostAuthKeysCodeMutationVariables = {
+  request?: operations.PostAuthKeysCodeRequest | undefined;
+  options?: RequestOptions;
+};
+
+export type OAuthPostAuthKeysCodeMutationData =
+  operations.PostAuthKeysCodeResponse;
+
+/**
+ * Create authorization code
+ *
+ * @remarks
+ * Create an authorization code for the PKCE flow to generate a user-controlled API key
+ */
+export function useOAuthPostAuthKeysCodeMutation(
+  options?: MutationHookOptions<
+    OAuthPostAuthKeysCodeMutationData,
+    Error,
+    OAuthPostAuthKeysCodeMutationVariables
+  >,
+): UseMutationResult<
+  OAuthPostAuthKeysCodeMutationData,
+  Error,
+  OAuthPostAuthKeysCodeMutationVariables
+> {
+  const client = useOpenRouterContext();
+  return useMutation({
+    ...buildOAuthPostAuthKeysCodeMutation(client, options),
+    ...options,
+  });
+}
+
+export function mutationKeyOAuthPostAuthKeysCode(): MutationKey {
+  return ["@openrouter/sdk", "OAuth", "postAuthKeysCode"];
+}
+
+export function buildOAuthPostAuthKeysCodeMutation(
+  client$: OpenRouterCore,
+  hookOptions?: RequestOptions,
+): {
+  mutationKey: MutationKey;
+  mutationFn: (
+    variables: OAuthPostAuthKeysCodeMutationVariables,
+  ) => Promise<OAuthPostAuthKeysCodeMutationData>;
+} {
+  return {
+    mutationKey: mutationKeyOAuthPostAuthKeysCode(),
+    mutationFn: function oAuthPostAuthKeysCodeMutationFn({
+      request,
+      options,
+    }): Promise<OAuthPostAuthKeysCodeMutationData> {
+      const mergedOptions = {
+        ...hookOptions,
+        ...options,
+        fetchOptions: {
+          ...hookOptions?.fetchOptions,
+          ...options?.fetchOptions,
+          signal: combineSignals(
+            hookOptions?.fetchOptions?.signal,
+            options?.fetchOptions?.signal,
+          ),
+        },
+      };
+      return unwrapAsync(oAuthPostAuthKeysCode(
+        client$,
+        request,
+        mergedOptions,
+      ));
+    },
+  };
+}

package/src/react-query/{getProviders.ts → providersGetProviders.ts}

@@ -13,7 +13,7 @@ import {
   UseSuspenseQueryResult,
 } from "@tanstack/react-query";
 import { OpenRouterCore } from "../core.js";
-import { getProviders } from "../funcs/getProviders.js";
+import { providersGetProviders } from "../funcs/providersGetProviders.js";
 import { combineSignals } from "../lib/primitives.js";
 import { RequestOptions } from "../lib/sdks.js";
 import * as operations from "../models/operations/index.js";
@@ -21,14 +21,17 @@ import { unwrapAsync } from "../types/fp.js";
 import { useOpenRouterContext } from "./_context.js";
 import { QueryHookOptions, SuspenseQueryHookOptions } from "./_types.js";
 
-export type GetProvidersQueryData = operations.GetProvidersResponse;
+export type ProvidersGetProvidersQueryData = operations.GetProvidersResponse;
 
-export function useGetProviders(
-  options?: QueryHookOptions<GetProvidersQueryData>,
-): UseQueryResult<GetProvidersQueryData, Error> {
+/**
+ * List all available model providers
+ */
+export function useProvidersGetProviders(
+  options?: QueryHookOptions<ProvidersGetProvidersQueryData>,
+): UseQueryResult<ProvidersGetProvidersQueryData, Error> {
   const client = useOpenRouterContext();
   return useQuery({
-    ...buildGetProvidersQuery(
+    ...buildProvidersGetProvidersQuery(
       client,
       options,
     ),
@@ -36,12 +39,15 @@ export function useGetProviders(
   });
 }
 
-export function useGetProvidersSuspense(
-  options?: SuspenseQueryHookOptions<GetProvidersQueryData>,
-): UseSuspenseQueryResult<GetProvidersQueryData, Error> {
+/**
+ * List all available model providers
+ */
+export function useProvidersGetProvidersSuspense(
+  options?: SuspenseQueryHookOptions<ProvidersGetProvidersQueryData>,
+): UseSuspenseQueryResult<ProvidersGetProvidersQueryData, Error> {
   const client = useOpenRouterContext();
   return useSuspenseQuery({
-    ...buildGetProvidersQuery(
+    ...buildProvidersGetProvidersQuery(
       client,
       options,
     ),
@@ -49,55 +55,57 @@ export function useGetProvidersSuspense(
   });
 }
 
-export function prefetchGetProviders(
+export function prefetchProvidersGetProviders(
   queryClient: QueryClient,
   client$: OpenRouterCore,
 ): Promise<void> {
   return queryClient.prefetchQuery({
-    ...buildGetProvidersQuery(
+    ...buildProvidersGetProvidersQuery(
       client$,
     ),
   });
 }
 
-export function setGetProvidersData(
+export function setProvidersGetProvidersData(
   client: QueryClient,
-  data: GetProvidersQueryData,
-): GetProvidersQueryData | undefined {
-  const key = queryKeyGetProviders();
+  data: ProvidersGetProvidersQueryData,
+): ProvidersGetProvidersQueryData | undefined {
+  const key = queryKeyProvidersGetProviders();
 
-  return client.setQueryData<GetProvidersQueryData>(key, data);
+  return client.setQueryData<ProvidersGetProvidersQueryData>(key, data);
 }
 
-export function invalidateAllGetProviders(
+export function invalidateAllProvidersGetProviders(
   client: QueryClient,
   filters?: Omit<InvalidateQueryFilters, "queryKey" | "predicate" | "exact">,
 ): Promise<void> {
   return client.invalidateQueries({
     ...filters,
-    queryKey: ["@openrouter/sdk", "getProviders"],
+    queryKey: ["@openrouter/sdk", "Providers", "getProviders"],
   });
 }
 
-export function buildGetProvidersQuery(
+export function buildProvidersGetProvidersQuery(
   client$: OpenRouterCore,
   options?: RequestOptions,
 ): {
   queryKey: QueryKey;
-  queryFn: (context: QueryFunctionContext) => Promise<GetProvidersQueryData>;
+  queryFn: (
+    context: QueryFunctionContext,
+  ) => Promise<ProvidersGetProvidersQueryData>;
 } {
   return {
-    queryKey: queryKeyGetProviders(),
-    queryFn: async function getProvidersQueryFn(
+    queryKey: queryKeyProvidersGetProviders(),
+    queryFn: async function providersGetProvidersQueryFn(
       ctx,
-    ): Promise<GetProvidersQueryData> {
+    ): Promise<ProvidersGetProvidersQueryData> {
       const sig = combineSignals(ctx.signal, options?.fetchOptions?.signal);
       const mergedOptions = {
         ...options,
         fetchOptions: { ...options?.fetchOptions, signal: sig },
       };
 
-      return unwrapAsync(getProviders(
+      return unwrapAsync(providersGetProviders(
         client$,
         mergedOptions,
       ));
@@ -105,6 +113,6 @@ export function buildGetProvidersQuery(
   };
 }
 
-export function queryKeyGetProviders(): QueryKey {
-  return ["@openrouter/sdk", "getProviders"];
+export function queryKeyProvidersGetProviders(): QueryKey {
+  return ["@openrouter/sdk", "Providers", "getProviders"];
 }

package/src/sdk/credits.ts

@@ -0,0 +1,26 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { creditsPostCreditsCoinbase } from "../funcs/creditsPostCreditsCoinbase.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Credits extends ClientSDK {
+  /**
+   * Create a Coinbase charge for crypto payment
+   */
+  async postCreditsCoinbase(
+    security: operations.PostCreditsCoinbaseSecurity,
+    request?: operations.PostCreditsCoinbaseRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.PostCreditsCoinbaseResponse> {
+    return unwrapAsync(creditsPostCreditsCoinbase(
+      this,
+      security,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/embeddings.ts

@@ -2,7 +2,7 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
-import { embeddingsPostEmbeddings } from "../funcs/embeddingsPostEmbeddings.js";
+import { embeddingsGenerate } from "../funcs/embeddingsGenerate.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
 import * as operations from "../models/operations/index.js";
 import { unwrapAsync } from "../types/fp.js";
@@ -14,11 +14,11 @@ export class Embeddings extends ClientSDK {
    * @remarks
    * Submits an embedding request to the embeddings router
    */
-  async postEmbeddings(
+  async generate(
     request?: operations.PostEmbeddingsRequest | undefined,
     options?: RequestOptions,
   ): Promise<operations.PostEmbeddingsResponse> {
-    return unwrapAsync(embeddingsPostEmbeddings(
+    return unwrapAsync(embeddingsGenerate(
       this,
       request,
       options,

package/src/sdk/{parameters.ts → model.ts}

@@ -2,12 +2,12 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
-import { parametersGetParametersAuthorSlug } from "../funcs/parametersGetParametersAuthorSlug.js";
+import { modelGetParametersAuthorSlug } from "../funcs/modelGetParametersAuthorSlug.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
 import * as operations from "../models/operations/index.js";
 import { unwrapAsync } from "../types/fp.js";
 
-export class ParametersT extends ClientSDK {
+export class Model extends ClientSDK {
   /**
    * Get a model's supported parameters and data about which are most popular
    */
@@ -16,7 +16,7 @@ export class ParametersT extends ClientSDK {
     request: operations.GetParametersAuthorSlugRequest,
     options?: RequestOptions,
   ): Promise<operations.GetParametersAuthorSlugResponse> {
-    return unwrapAsync(parametersGetParametersAuthorSlug(
+    return unwrapAsync(modelGetParametersAuthorSlug(
       this,
       security,
       request,

package/src/sdk/oauth.ts

@@ -0,0 +1,45 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { oAuthPostAuthKeys } from "../funcs/oAuthPostAuthKeys.js";
+import { oAuthPostAuthKeysCode } from "../funcs/oAuthPostAuthKeysCode.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class OAuth extends ClientSDK {
+  /**
+   * Exchange authorization code for API key
+   *
+   * @remarks
+   * Exchange an authorization code from the PKCE flow for a user-controlled API key
+   */
+  async postAuthKeys(
+    request?: operations.PostAuthKeysRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.PostAuthKeysResponse> {
+    return unwrapAsync(oAuthPostAuthKeys(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Create authorization code
+   *
+   * @remarks
+   * Create an authorization code for the PKCE flow to generate a user-controlled API key
+   */
+  async postAuthKeysCode(
+    request?: operations.PostAuthKeysCodeRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.PostAuthKeysCodeResponse> {
+    return unwrapAsync(oAuthPostAuthKeysCode(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/providers.ts

@@ -0,0 +1,22 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { providersGetProviders } from "../funcs/providersGetProviders.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Providers extends ClientSDK {
+  /**
+   * List all available model providers
+   */
+  async getProviders(
+    options?: RequestOptions,
+  ): Promise<operations.GetProvidersResponse> {
+    return unwrapAsync(providersGetProviders(
+      this,
+      options,
+    ));
+  }
+}