@avallon-labs/sdk 0.0.1

package/README.md

@@ -0,0 +1,135 @@
+# @avallon/sdk
+
+TypeScript SDK for the Avallon API. Auto-generated from OpenAPI with custom auth utilities.
+
+## Installation
+
+```bash
+npm install @avallon/sdk
+```
+
+For React/SWR hooks:
+```bash
+npm install @avallon/sdk swr react
+```
+
+## Usage
+
+### Configure
+
+```typescript
+import { configure } from "@avallon/sdk";
+
+configure({
+  baseUrl: "https://api.avallon.ai",
+  apiKey: "your-api-key",
+  // OR for user auth:
+  getAccessToken: () => localStorage.getItem("access_token"),
+});
+```
+
+### API Calls (Plain Fetch)
+
+```typescript
+import { listAgents, createAgent } from "@avallon/sdk";
+
+// List agents
+const response = await listAgents();
+console.log(response.data.data.agents);
+
+// Create agent
+const created = await createAgent({ agent_name: "My Agent" });
+```
+
+### API Calls (React SWR Hooks)
+
+```typescript
+import { useListAgents, useCreateAgent } from "@avallon/sdk";
+
+function AgentsList() {
+  const { data, error, isLoading } = useListAgents();
+
+  if (isLoading) return <Spinner />;
+  if (error) return <Error message={error.message} />;
+
+  return <ul>{data.data.data.agents.map(a => <li key={a.id}>{a.agent_name}</li>)}</ul>;
+}
+
+function CreateAgent() {
+  const { trigger, isMutating } = useCreateAgent();
+
+  return (
+    <button onClick={() => trigger({ agent_name: "New Agent" })} disabled={isMutating}>
+      Create
+    </button>
+  );
+}
+```
+
+### OAuth Flow
+
+```typescript
+import { startOAuthFlow, getStoredVerifier, clearStoredVerifier, postV1AuthSignIn } from "@avallon/sdk";
+
+// 1. Start OAuth (redirects user)
+const { url } = await startOAuthFlow({
+  provider: "google",
+  redirectUri: "https://app.example.com/callback",
+});
+window.location.href = url;
+
+// 2. After redirect, exchange code for tokens
+const verifier = getStoredVerifier();
+const response = await postV1AuthSignIn({
+  type: "oauth",
+  code: new URLSearchParams(location.search).get("code"),
+  verifier,
+});
+clearStoredVerifier();
+
+// 3. Store tokens and configure SDK
+const { access_token, refresh_token, expires_at } = response.data.data;
+localStorage.setItem("access_token", access_token);
+configure({ getAccessToken: () => localStorage.getItem("access_token") });
+```
+
+### Error Handling
+
+```typescript
+import { AvallonError } from "@avallon/sdk";
+
+try {
+  await createAgent({ agent_name: "" });
+} catch (e) {
+  if (e instanceof AvallonError) {
+    if (e.isValidationError()) {
+      console.log("Validation errors:", e.errors);
+    } else if (e.isUnauthorized()) {
+      // Redirect to login
+    }
+  }
+}
+```
+
+## Development
+
+```bash
+# Regenerate SDK from OpenAPI
+npm run generate
+
+# Build
+npm run build
+```
+
+## Structure
+
+```
+src/           # Handwritten code
+  index.ts     # Main exports
+  fetcher.ts   # Fetch wrapper with auth
+  auth.ts      # OAuth PKCE utilities
+
+generated/     # Auto-generated (do not edit)
+  endpoints/   # API functions + SWR hooks
+  models/      # Request/response types
+```

package/dist/generated/endpoints/agents/agents.d.ts

@@ -0,0 +1,172 @@
+import type { Key, SWRConfiguration } from "swr";
+import type { SWRMutationConfiguration } from "swr/mutation";
+import type { CreateAgent200, CreateAgent400, CreateAgent401, CreateAgent500, CreateAgentBody, GetAgent200, GetAgent400, GetAgent401, GetAgent404, GetAgent500, ListAgents200, ListAgents400, ListAgents401, ListAgents500, ListAgentsParams } from "../../models";
+import { customFetch } from "../../../src/fetcher";
+type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1];
+/**
+ * List all agents for your tenant.
+
+**Filtering:**
+
+Filter agents by name using the `agent_name` query parameter (exact match).
+
+**Response:**
+
+Returns an array of all agents with their configurations and a total count.
+ * @summary List agents
+ */
+export type listAgentsResponse200 = {
+    data: ListAgents200;
+    status: 200;
+};
+export type listAgentsResponse400 = {
+    data: ListAgents400;
+    status: 400;
+};
+export type listAgentsResponse401 = {
+    data: ListAgents401;
+    status: 401;
+};
+export type listAgentsResponse500 = {
+    data: ListAgents500;
+    status: 500;
+};
+export type listAgentsResponseSuccess = listAgentsResponse200 & {
+    headers: Headers;
+};
+export type listAgentsResponseError = (listAgentsResponse400 | listAgentsResponse401 | listAgentsResponse500) & {
+    headers: Headers;
+};
+export type listAgentsResponse = listAgentsResponseSuccess | listAgentsResponseError;
+export declare const getListAgentsUrl: (params?: ListAgentsParams) => string;
+export declare const listAgents: (params?: ListAgentsParams, options?: RequestInit) => Promise<listAgentsResponse>;
+export declare const getListAgentsKey: (params?: ListAgentsParams) => readonly ["/v1/agents", ...ListAgentsParams[]];
+export type ListAgentsQueryResult = NonNullable<Awaited<ReturnType<typeof listAgents>>>;
+/**
+ * @summary List agents
+ */
+export declare const useListAgents: <TError = ListAgents400 | ListAgents401 | ListAgents500>(params?: ListAgentsParams, options?: {
+    swr?: SWRConfiguration<Awaited<ReturnType<typeof listAgents>>, TError> & {
+        swrKey?: Key;
+        enabled?: boolean;
+    };
+    request?: SecondParameter<typeof customFetch>;
+}) => {
+    data: listAgentsResponse | undefined;
+    error: TError | undefined;
+    mutate: import("swr").KeyedMutator<listAgentsResponse>;
+    isValidating: boolean;
+    isLoading: import("swr/_internal").IsLoadingResponse<Data, Config>;
+    swrKey: string | false | readonly [any, ...unknown[]] | Record<any, any> | (() => import("swr").Arguments);
+};
+/**
+ * Create a new voice agent with the specified configuration.
+
+**Required fields:**
+
+All fields in the request body are required except `phone_number_id` and `transfer_phone_number`.
+
+**Response:**
+
+Returns the created agent with its ID and configuration.
+ * @summary Create agent
+ */
+export type createAgentResponse200 = {
+    data: CreateAgent200;
+    status: 200;
+};
+export type createAgentResponse400 = {
+    data: CreateAgent400;
+    status: 400;
+};
+export type createAgentResponse401 = {
+    data: CreateAgent401;
+    status: 401;
+};
+export type createAgentResponse500 = {
+    data: CreateAgent500;
+    status: 500;
+};
+export type createAgentResponseSuccess = createAgentResponse200 & {
+    headers: Headers;
+};
+export type createAgentResponseError = (createAgentResponse400 | createAgentResponse401 | createAgentResponse500) & {
+    headers: Headers;
+};
+export type createAgentResponse = createAgentResponseSuccess | createAgentResponseError;
+export declare const getCreateAgentUrl: () => string;
+export declare const createAgent: (createAgentBody: CreateAgentBody, options?: RequestInit) => Promise<createAgentResponse>;
+export declare const getCreateAgentMutationFetcher: (options?: SecondParameter<typeof customFetch>) => (_: Key, { arg }: {
+    arg: CreateAgentBody;
+}) => Promise<createAgentResponse>;
+export declare const getCreateAgentMutationKey: () => readonly ["/v1/agents"];
+export type CreateAgentMutationResult = NonNullable<Awaited<ReturnType<typeof createAgent>>>;
+/**
+ * @summary Create agent
+ */
+export declare const useCreateAgent: <TError = CreateAgent400 | CreateAgent401 | CreateAgent500>(options?: {
+    swr?: SWRMutationConfiguration<Awaited<ReturnType<typeof createAgent>>, TError, Key, CreateAgentBody, Awaited<ReturnType<typeof createAgent>>> & {
+        swrKey?: string;
+    };
+    request?: SecondParameter<typeof customFetch>;
+}) => {
+    isMutating: boolean;
+    trigger: import("swr/mutation").TriggerWithArgs<createAgentResponse, TError, string | readonly ["/v1/agents"], CreateAgentBody>;
+    reset: () => void;
+    error: TError | undefined;
+    data: createAgentResponse | undefined;
+    swrKey: string | readonly ["/v1/agents"];
+};
+/**
+ * Retrieve a single agent by ID.
+ * @summary Get agent
+ */
+export type getAgentResponse200 = {
+    data: GetAgent200;
+    status: 200;
+};
+export type getAgentResponse400 = {
+    data: GetAgent400;
+    status: 400;
+};
+export type getAgentResponse401 = {
+    data: GetAgent401;
+    status: 401;
+};
+export type getAgentResponse404 = {
+    data: GetAgent404;
+    status: 404;
+};
+export type getAgentResponse500 = {
+    data: GetAgent500;
+    status: 500;
+};
+export type getAgentResponseSuccess = getAgentResponse200 & {
+    headers: Headers;
+};
+export type getAgentResponseError = (getAgentResponse400 | getAgentResponse401 | getAgentResponse404 | getAgentResponse500) & {
+    headers: Headers;
+};
+export type getAgentResponse = getAgentResponseSuccess | getAgentResponseError;
+export declare const getGetAgentUrl: (id: string) => string;
+export declare const getAgent: (id: string, options?: RequestInit) => Promise<getAgentResponse>;
+export declare const getGetAgentKey: (id: string) => readonly [`/v1/agents/${string}`];
+export type GetAgentQueryResult = NonNullable<Awaited<ReturnType<typeof getAgent>>>;
+/**
+ * @summary Get agent
+ */
+export declare const useGetAgent: <TError = GetAgent400 | GetAgent401 | GetAgent404 | GetAgent500>(id: string, options?: {
+    swr?: SWRConfiguration<Awaited<ReturnType<typeof getAgent>>, TError> & {
+        swrKey?: Key;
+        enabled?: boolean;
+    };
+    request?: SecondParameter<typeof customFetch>;
+}) => {
+    data: getAgentResponse | undefined;
+    error: TError | undefined;
+    mutate: import("swr").KeyedMutator<getAgentResponse>;
+    isValidating: boolean;
+    isLoading: import("swr/_internal").IsLoadingResponse<Data, Config>;
+    swrKey: string | false | readonly [any, ...unknown[]] | Record<any, any> | (() => import("swr").Arguments);
+};
+export {};

package/dist/generated/endpoints/agents/agents.js

@@ -0,0 +1,96 @@
+/**
+ * Generated by orval v8.1.0 🍺
+ * Do not edit manually.
+ * Avallon API
+ * OpenAPI spec version: 1.0.0
+ */
+import useSwr from "swr";
+import useSWRMutation from "swr/mutation";
+import { customFetch } from "../../../src/fetcher";
+export const getListAgentsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : value.toString());
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `/v1/agents?${stringifiedParams}`
+        : `/v1/agents`;
+};
+export const listAgents = async (params, options) => {
+    return customFetch(getListAgentsUrl(params), {
+        ...options,
+        method: "GET",
+    });
+};
+export const getListAgentsKey = (params) => [`/v1/agents`, ...(params ? [params] : [])];
+/**
+ * @summary List agents
+ */
+export const useListAgents = (params, options) => {
+    const { swr: swrOptions, request: requestOptions } = options ?? {};
+    const isEnabled = swrOptions?.enabled !== false;
+    const swrKey = swrOptions?.swrKey ?? (() => (isEnabled ? getListAgentsKey(params) : null));
+    const swrFn = () => listAgents(params, requestOptions);
+    const query = useSwr(swrKey, swrFn, swrOptions);
+    return {
+        swrKey,
+        ...query,
+    };
+};
+export const getCreateAgentUrl = () => {
+    return `/v1/agents`;
+};
+export const createAgent = async (createAgentBody, options) => {
+    return customFetch(getCreateAgentUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...options?.headers },
+        body: JSON.stringify(createAgentBody),
+    });
+};
+export const getCreateAgentMutationFetcher = (options) => {
+    return (_, { arg }) => {
+        return createAgent(arg, options);
+    };
+};
+export const getCreateAgentMutationKey = () => [`/v1/agents`];
+/**
+ * @summary Create agent
+ */
+export const useCreateAgent = (options) => {
+    const { swr: swrOptions, request: requestOptions } = options ?? {};
+    const swrKey = swrOptions?.swrKey ?? getCreateAgentMutationKey();
+    const swrFn = getCreateAgentMutationFetcher(requestOptions);
+    const query = useSWRMutation(swrKey, swrFn, swrOptions);
+    return {
+        swrKey,
+        ...query,
+    };
+};
+export const getGetAgentUrl = (id) => {
+    return `/v1/agents/${id}`;
+};
+export const getAgent = async (id, options) => {
+    return customFetch(getGetAgentUrl(id), {
+        ...options,
+        method: "GET",
+    });
+};
+export const getGetAgentKey = (id) => [`/v1/agents/${id}`];
+/**
+ * @summary Get agent
+ */
+export const useGetAgent = (id, options) => {
+    const { swr: swrOptions, request: requestOptions } = options ?? {};
+    const isEnabled = swrOptions?.enabled !== false && !!id;
+    const swrKey = swrOptions?.swrKey ?? (() => (isEnabled ? getGetAgentKey(id) : null));
+    const swrFn = () => getAgent(id, requestOptions);
+    const query = useSwr(swrKey, swrFn, swrOptions);
+    return {
+        swrKey,
+        ...query,
+    };
+};

package/dist/generated/endpoints/default/default.d.ts

@@ -0,0 +1,176 @@
+import type { Key, SWRConfiguration } from "swr";
+import type { SWRMutationConfiguration } from "swr/mutation";
+import type { GetV1AuthOauthUrl200, GetV1AuthOauthUrl400, GetV1AuthOauthUrl401, GetV1AuthOauthUrl500, GetV1AuthOauthUrlParams, PostV1AuthRefreshToken200, PostV1AuthRefreshToken400, PostV1AuthRefreshToken401, PostV1AuthRefreshToken500, PostV1AuthRefreshTokenBody, PostV1AuthSignIn200, PostV1AuthSignIn400, PostV1AuthSignIn401, PostV1AuthSignIn500, PostV1AuthSignInBody, PostV1AuthSignUp200, PostV1AuthSignUp400, PostV1AuthSignUp401, PostV1AuthSignUp500, PostV1AuthSignUpBody } from "../../models";
+import { customFetch } from "../../../src/fetcher";
+type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1];
+export type postV1AuthSignUpResponse200 = {
+    data: PostV1AuthSignUp200;
+    status: 200;
+};
+export type postV1AuthSignUpResponse400 = {
+    data: PostV1AuthSignUp400;
+    status: 400;
+};
+export type postV1AuthSignUpResponse401 = {
+    data: PostV1AuthSignUp401;
+    status: 401;
+};
+export type postV1AuthSignUpResponse500 = {
+    data: PostV1AuthSignUp500;
+    status: 500;
+};
+export type postV1AuthSignUpResponseSuccess = postV1AuthSignUpResponse200 & {
+    headers: Headers;
+};
+export type postV1AuthSignUpResponseError = (postV1AuthSignUpResponse400 | postV1AuthSignUpResponse401 | postV1AuthSignUpResponse500) & {
+    headers: Headers;
+};
+export type postV1AuthSignUpResponse = postV1AuthSignUpResponseSuccess | postV1AuthSignUpResponseError;
+export declare const getPostV1AuthSignUpUrl: () => string;
+export declare const postV1AuthSignUp: (postV1AuthSignUpBody: PostV1AuthSignUpBody, options?: RequestInit) => Promise<postV1AuthSignUpResponse>;
+export declare const getPostV1AuthSignUpMutationFetcher: (options?: SecondParameter<typeof customFetch>) => (_: Key, { arg }: {
+    arg: PostV1AuthSignUpBody;
+}) => Promise<postV1AuthSignUpResponse>;
+export declare const getPostV1AuthSignUpMutationKey: () => readonly ["/v1/auth/sign-up"];
+export type PostV1AuthSignUpMutationResult = NonNullable<Awaited<ReturnType<typeof postV1AuthSignUp>>>;
+export declare const usePostV1AuthSignUp: <TError = PostV1AuthSignUp400 | PostV1AuthSignUp401 | PostV1AuthSignUp500>(options?: {
+    swr?: SWRMutationConfiguration<Awaited<ReturnType<typeof postV1AuthSignUp>>, TError, Key, PostV1AuthSignUpBody, Awaited<ReturnType<typeof postV1AuthSignUp>>> & {
+        swrKey?: string;
+    };
+    request?: SecondParameter<typeof customFetch>;
+}) => {
+    isMutating: boolean;
+    trigger: import("swr/mutation").TriggerWithArgs<postV1AuthSignUpResponse, TError, string | readonly ["/v1/auth/sign-up"], PostV1AuthSignUpBody>;
+    reset: () => void;
+    error: TError | undefined;
+    data: postV1AuthSignUpResponse | undefined;
+    swrKey: string | readonly ["/v1/auth/sign-up"];
+};
+export type postV1AuthSignInResponse200 = {
+    data: PostV1AuthSignIn200;
+    status: 200;
+};
+export type postV1AuthSignInResponse400 = {
+    data: PostV1AuthSignIn400;
+    status: 400;
+};
+export type postV1AuthSignInResponse401 = {
+    data: PostV1AuthSignIn401;
+    status: 401;
+};
+export type postV1AuthSignInResponse500 = {
+    data: PostV1AuthSignIn500;
+    status: 500;
+};
+export type postV1AuthSignInResponseSuccess = postV1AuthSignInResponse200 & {
+    headers: Headers;
+};
+export type postV1AuthSignInResponseError = (postV1AuthSignInResponse400 | postV1AuthSignInResponse401 | postV1AuthSignInResponse500) & {
+    headers: Headers;
+};
+export type postV1AuthSignInResponse = postV1AuthSignInResponseSuccess | postV1AuthSignInResponseError;
+export declare const getPostV1AuthSignInUrl: () => string;
+export declare const postV1AuthSignIn: (postV1AuthSignInBody: PostV1AuthSignInBody, options?: RequestInit) => Promise<postV1AuthSignInResponse>;
+export declare const getPostV1AuthSignInMutationFetcher: (options?: SecondParameter<typeof customFetch>) => (_: Key, { arg }: {
+    arg: PostV1AuthSignInBody;
+}) => Promise<postV1AuthSignInResponse>;
+export declare const getPostV1AuthSignInMutationKey: () => readonly ["/v1/auth/sign-in"];
+export type PostV1AuthSignInMutationResult = NonNullable<Awaited<ReturnType<typeof postV1AuthSignIn>>>;
+export declare const usePostV1AuthSignIn: <TError = PostV1AuthSignIn400 | PostV1AuthSignIn401 | PostV1AuthSignIn500>(options?: {
+    swr?: SWRMutationConfiguration<Awaited<ReturnType<typeof postV1AuthSignIn>>, TError, Key, PostV1AuthSignInBody, Awaited<ReturnType<typeof postV1AuthSignIn>>> & {
+        swrKey?: string;
+    };
+    request?: SecondParameter<typeof customFetch>;
+}) => {
+    isMutating: boolean;
+    trigger: import("swr/mutation").TriggerWithArgs<postV1AuthSignInResponse, TError, string | readonly ["/v1/auth/sign-in"], PostV1AuthSignInBody>;
+    reset: () => void;
+    error: TError | undefined;
+    data: postV1AuthSignInResponse | undefined;
+    swrKey: string | readonly ["/v1/auth/sign-in"];
+};
+export type postV1AuthRefreshTokenResponse200 = {
+    data: PostV1AuthRefreshToken200;
+    status: 200;
+};
+export type postV1AuthRefreshTokenResponse400 = {
+    data: PostV1AuthRefreshToken400;
+    status: 400;
+};
+export type postV1AuthRefreshTokenResponse401 = {
+    data: PostV1AuthRefreshToken401;
+    status: 401;
+};
+export type postV1AuthRefreshTokenResponse500 = {
+    data: PostV1AuthRefreshToken500;
+    status: 500;
+};
+export type postV1AuthRefreshTokenResponseSuccess = postV1AuthRefreshTokenResponse200 & {
+    headers: Headers;
+};
+export type postV1AuthRefreshTokenResponseError = (postV1AuthRefreshTokenResponse400 | postV1AuthRefreshTokenResponse401 | postV1AuthRefreshTokenResponse500) & {
+    headers: Headers;
+};
+export type postV1AuthRefreshTokenResponse = postV1AuthRefreshTokenResponseSuccess | postV1AuthRefreshTokenResponseError;
+export declare const getPostV1AuthRefreshTokenUrl: () => string;
+export declare const postV1AuthRefreshToken: (postV1AuthRefreshTokenBody: PostV1AuthRefreshTokenBody, options?: RequestInit) => Promise<postV1AuthRefreshTokenResponse>;
+export declare const getPostV1AuthRefreshTokenMutationFetcher: (options?: SecondParameter<typeof customFetch>) => (_: Key, { arg }: {
+    arg: PostV1AuthRefreshTokenBody;
+}) => Promise<postV1AuthRefreshTokenResponse>;
+export declare const getPostV1AuthRefreshTokenMutationKey: () => readonly ["/v1/auth/refresh-token"];
+export type PostV1AuthRefreshTokenMutationResult = NonNullable<Awaited<ReturnType<typeof postV1AuthRefreshToken>>>;
+export declare const usePostV1AuthRefreshToken: <TError = PostV1AuthRefreshToken400 | PostV1AuthRefreshToken401 | PostV1AuthRefreshToken500>(options?: {
+    swr?: SWRMutationConfiguration<Awaited<ReturnType<typeof postV1AuthRefreshToken>>, TError, Key, PostV1AuthRefreshTokenBody, Awaited<ReturnType<typeof postV1AuthRefreshToken>>> & {
+        swrKey?: string;
+    };
+    request?: SecondParameter<typeof customFetch>;
+}) => {
+    isMutating: boolean;
+    trigger: import("swr/mutation").TriggerWithArgs<postV1AuthRefreshTokenResponse, TError, string | readonly ["/v1/auth/refresh-token"], PostV1AuthRefreshTokenBody>;
+    reset: () => void;
+    error: TError | undefined;
+    data: postV1AuthRefreshTokenResponse | undefined;
+    swrKey: string | readonly ["/v1/auth/refresh-token"];
+};
+export type getV1AuthOauthUrlResponse200 = {
+    data: GetV1AuthOauthUrl200;
+    status: 200;
+};
+export type getV1AuthOauthUrlResponse400 = {
+    data: GetV1AuthOauthUrl400;
+    status: 400;
+};
+export type getV1AuthOauthUrlResponse401 = {
+    data: GetV1AuthOauthUrl401;
+    status: 401;
+};
+export type getV1AuthOauthUrlResponse500 = {
+    data: GetV1AuthOauthUrl500;
+    status: 500;
+};
+export type getV1AuthOauthUrlResponseSuccess = getV1AuthOauthUrlResponse200 & {
+    headers: Headers;
+};
+export type getV1AuthOauthUrlResponseError = (getV1AuthOauthUrlResponse400 | getV1AuthOauthUrlResponse401 | getV1AuthOauthUrlResponse500) & {
+    headers: Headers;
+};
+export type getV1AuthOauthUrlResponse = getV1AuthOauthUrlResponseSuccess | getV1AuthOauthUrlResponseError;
+export declare const getGetV1AuthOauthUrlUrl: (params: GetV1AuthOauthUrlParams) => string;
+export declare const getV1AuthOauthUrl: (params: GetV1AuthOauthUrlParams, options?: RequestInit) => Promise<getV1AuthOauthUrlResponse>;
+export declare const getGetV1AuthOauthUrlKey: (params: GetV1AuthOauthUrlParams) => readonly ["/v1/auth/oauth-url", ...GetV1AuthOauthUrlParams[]];
+export type GetV1AuthOauthUrlQueryResult = NonNullable<Awaited<ReturnType<typeof getV1AuthOauthUrl>>>;
+export declare const useGetV1AuthOauthUrl: <TError = GetV1AuthOauthUrl400 | GetV1AuthOauthUrl401 | GetV1AuthOauthUrl500>(params: GetV1AuthOauthUrlParams, options?: {
+    swr?: SWRConfiguration<Awaited<ReturnType<typeof getV1AuthOauthUrl>>, TError> & {
+        swrKey?: Key;
+        enabled?: boolean;
+    };
+    request?: SecondParameter<typeof customFetch>;
+}) => {
+    data: getV1AuthOauthUrlResponse | undefined;
+    error: TError | undefined;
+    mutate: import("swr").KeyedMutator<getV1AuthOauthUrlResponse>;
+    isValidating: boolean;
+    isLoading: import("swr/_internal").IsLoadingResponse<Data, Config>;
+    swrKey: string | false | readonly [any, ...unknown[]] | Record<any, any> | (() => import("swr").Arguments);
+};
+export {};