@robelest/convex-auth 0.0.4-preview.25 → 0.0.4-preview.28

package/dist/providers/custom.js

@@ -0,0 +1,119 @@
+import { envOptionalString, readConfigSync } from "../server/env.js";
+import { createOAuthProvider } from "../server/oauth/factory.js";
+import { sha256 } from "@oslojs/crypto/sha2";
+import { encodeBase64urlNoPadding } from "@oslojs/encoding";
+
+//#region src/providers/custom.ts
+/**
+* Custom OAuth provider.
+*
+* Use this as an escape hatch for OAuth providers that do not have a first-
+* party wrapper yet.
+*
+* @module
+*/
+function defaultRedirectUri(providerId) {
+	const rootUrl = readConfigSync(envOptionalString("CUSTOM_AUTH_SITE_URL")) ?? readConfigSync(envOptionalString("CONVEX_SITE_URL"));
+	if (!rootUrl) throw new Error(`Missing CONVEX_SITE_URL while configuring ${providerId} OAuth provider. Set CONVEX_SITE_URL or pass redirectUri explicitly.`);
+	return `${rootUrl}/api/auth/callback/${providerId}`;
+}
+function joinScopes(scopes, separator = " ") {
+	return scopes.join(separator);
+}
+function createCodeChallenge(codeVerifier) {
+	return encodeBase64urlNoPadding(sha256(new TextEncoder().encode(codeVerifier)));
+}
+function createRuntimeClient(config) {
+	const redirectUri = config.redirectUri ?? defaultRedirectUri(config.id);
+	const authorization = config.authorization;
+	const token = config.token;
+	const pkce = authorization.pkce ?? "required";
+	const scopes = [...config.scopes ?? []];
+	return {
+		pkce,
+		createAuthorizationURL({ state, codeVerifier, scopes: requestedScopes, nonce }) {
+			const url = new URL(authorization.url);
+			const nextScopes = requestedScopes.length > 0 ? requestedScopes : scopes;
+			url.searchParams.set("response_type", "code");
+			url.searchParams.set(authorization.clientIdParam ?? "client_id", config.clientId);
+			url.searchParams.set("redirect_uri", redirectUri);
+			url.searchParams.set("state", state);
+			if (nextScopes.length > 0) url.searchParams.set(authorization.scopeParam ?? "scope", joinScopes(nextScopes, authorization.scopeSeparator));
+			if (codeVerifier !== void 0 && pkce !== "never") {
+				url.searchParams.set("code_challenge_method", "S256");
+				url.searchParams.set("code_challenge", createCodeChallenge(codeVerifier));
+			}
+			if (nonce !== void 0) url.searchParams.set("nonce", nonce);
+			for (const [key, value] of Object.entries(authorization.extraParams ?? {})) url.searchParams.set(key, value);
+			return url;
+		},
+		async validateAuthorizationCode({ code, codeVerifier }) {
+			const body = new URLSearchParams();
+			body.set("grant_type", "authorization_code");
+			body.set("code", code);
+			if (token.includeRedirectUri ?? true) body.set("redirect_uri", redirectUri);
+			if (pkce !== "never" && codeVerifier !== void 0) body.set(token.codeVerifierParam ?? "code_verifier", codeVerifier);
+			if (token.includeScopes === true && scopes.length > 0) body.set(token.scopeParam ?? "scope", joinScopes(scopes, token.scopeSeparator ?? authorization.scopeSeparator));
+			if (token.authMethod !== "basic") body.set(token.clientIdParam ?? "client_id", config.clientId);
+			if (token.authMethod !== "basic" && token.authMethod !== "none" && config.clientSecret) body.set(token.clientSecretParam ?? "client_secret", config.clientSecret);
+			for (const [key, value] of Object.entries(token.extraParams ?? {})) body.set(key, value);
+			const headers = new Headers({ "Content-Type": "application/x-www-form-urlencoded" });
+			if (token.authMethod === "basic") {
+				if (!config.clientSecret) throw new Error(`OAuth provider "${config.id}" requires clientSecret for token.authMethod="basic".`);
+				const credentials = btoa(`${config.clientId}:${config.clientSecret}`);
+				headers.set("Authorization", `Basic ${credentials}`);
+			}
+			const response = await fetch(token.url, {
+				method: "POST",
+				headers,
+				body
+			});
+			if (!response.ok) throw new Error(`OAuth token exchange failed: ${response.status}`);
+			const raw = await response.json();
+			const rawScopes = typeof raw.scope === "string" ? raw.scope : void 0;
+			const expiresIn = typeof raw.expires_in === "number" ? raw.expires_in : void 0;
+			return {
+				accessToken: typeof raw.access_token === "string" ? raw.access_token : void 0,
+				refreshToken: typeof raw.refresh_token === "string" ? raw.refresh_token : void 0,
+				idToken: typeof raw.id_token === "string" ? raw.id_token : void 0,
+				accessTokenExpiresAt: expiresIn !== void 0 ? new Date(Date.now() + expiresIn * 1e3) : void 0,
+				scopes: rawScopes ? rawScopes.split(/[\s,]+/).map((scope) => scope.trim()).filter((scope) => scope.length > 0) : void 0,
+				raw
+			};
+		}
+	};
+}
+/**
+* Create a custom OAuth provider.
+*
+* @param config - OAuth endpoints, credentials, and profile callbacks.
+* @returns A configured OAuth provider for `createAuth`.
+*
+* @example
+* ```ts
+* import { custom } from "@robelest/convex-auth/providers";
+*
+* custom({
+*   id: "workos",
+*   clientId: process.env.WORKOS_CLIENT_ID!,
+*   clientSecret: process.env.WORKOS_CLIENT_SECRET!,
+*   authorization: { url: "https://api.workos.com/sso/authorize" },
+*   token: { url: "https://api.workos.com/sso/token", authMethod: "basic" },
+* })
+* ```
+*/
+function custom(config) {
+	return createOAuthProvider({
+		id: config.id,
+		provider: createRuntimeClient(config),
+		scopes: config.scopes ?? [],
+		profile: config.profile,
+		nonce: config.nonce,
+		validateTokens: config.validateTokens,
+		accountLinking: config.accountLinking
+	});
+}
+
+//#endregion
+export { custom };
+//# sourceMappingURL=custom.js.map

package/dist/providers/device.d.ts

@@ -1,67 +1,33 @@
+import { DeviceProviderConfig } from "../server/types.js";
+
 //#region src/providers/device.d.ts
-/**
- * Device authorization provider (RFC 8628).
- *
- * Enables input-constrained devices (CLIs, TVs, IoT) to authenticate
- * by displaying a short code that the user enters on a secondary device.
- *
- * ```ts
- * import { Device } from "@robelest/convex-auth/providers";
- *
- * new Device()
- * ```
- *
- * @module
- */
-/**
- * Configuration for the Device authorization provider.
- */
+/** Configuration for the {@link device} provider. */
 interface DeviceConfig {
-  /**
-   * User code character set.
-   * Default: `"BCDFGHJKLMNPQRSTVWXZ"` (base-20, no vowels per RFC 8628 §6.1).
-   */
+  /** Character set used to generate the short user code. */
   charset?: string;
-  /** User code length (before formatting). Default: 8. */
+  /** Number of characters in the generated user code. */
   userCodeLength?: number;
-  /** Device code + user code lifetime in seconds. Default: 900 (15 min). */
+  /** Device code lifetime in seconds. */
   expiresIn?: number;
-  /** Minimum polling interval in seconds. Default: 5. */
+  /** Polling interval in seconds suggested to the device client. */
   interval?: number;
-  /**
-   * Base URL for the verification page where users enter the device code.
-   *
-   * Example: `"http://localhost:3000/device"` or `"https://myapp.com/device"`.
-   *
-   * If not provided, falls back to `SITE_URL + "/device"`.
-   */
+  /** Verification page URL shown to the user on the device. */
   verificationUri?: string;
 }
 /**
- * Device authorization provider (RFC 8628).
+ * Create a device authorization provider.
  *
- * Enables input-constrained devices (CLIs, TVs, IoT) to authenticate
- * by displaying a short user code. The user visits a verification page
- * on a secondary device, signs in with any existing provider, and
- * enters the code to authorize the device.
+ * @param config - Optional device flow code and polling settings.
+ * @returns A configured device flow provider for `createAuth`.
  *
  * @example
  * ```ts
- * import { createAuth } from "@robelest/convex-auth/component";
- * import { Device } from "@robelest/convex-auth/providers";
- * import { components } from "./_generated/api";
+ * import { device } from "@robelest/convex-auth/providers";
  *
- * const auth = createAuth(components.auth, {
- *   providers: [new Device()],
- * });
+ * device({ verificationUri: "https://example.com/device" })
  * ```
  */
-declare class Device {
-  readonly id: string;
-  readonly type: "device";
-  readonly config: DeviceConfig;
-  constructor(config?: DeviceConfig);
-}
+declare function device(config?: DeviceConfig): DeviceProviderConfig;
 //#endregion
-export { Device, DeviceConfig };
+export { DeviceConfig, device };
 //# sourceMappingURL=device.d.ts.map

package/dist/providers/device.js

@@ -1,47 +1,30 @@
 //#region src/providers/device.ts
-/** No-vowel base-20 charset per RFC 8628 §6.1 recommendation. */
 const DEFAULT_CHARSET = "BCDFGHJKLMNPQRSTVWXZ";
 /**
-* Device authorization provider (RFC 8628).
+* Create a device authorization provider.
 *
-* Enables input-constrained devices (CLIs, TVs, IoT) to authenticate
-* by displaying a short user code. The user visits a verification page
-* on a secondary device, signs in with any existing provider, and
-* enters the code to authorize the device.
+* @param config - Optional device flow code and polling settings.
+* @returns A configured device flow provider for `createAuth`.
 *
 * @example
 * ```ts
-* import { createAuth } from "@robelest/convex-auth/component";
-* import { Device } from "@robelest/convex-auth/providers";
-* import { components } from "./_generated/api";
+* import { device } from "@robelest/convex-auth/providers";
 *
-* const auth = createAuth(components.auth, {
-*   providers: [new Device()],
-* });
+* device({ verificationUri: "https://example.com/device" })
 * ```
 */
-var Device = class {
-	id;
-	type = "device";
-	config;
-	constructor(config = {}) {
-		this.id = "device";
-		this.config = config;
-	}
-	/** @internal Convert to the internal materialized config shape. */
-	_toMaterialized() {
-		return {
-			id: this.id,
-			type: "device",
-			charset: this.config.charset ?? DEFAULT_CHARSET,
-			userCodeLength: this.config.userCodeLength ?? 8,
-			expiresIn: this.config.expiresIn ?? 900,
-			interval: this.config.interval ?? 5,
-			verificationUri: this.config.verificationUri
-		};
-	}
-};
+function device(config = {}) {
+	return {
+		id: "device",
+		type: "device",
+		charset: config.charset ?? DEFAULT_CHARSET,
+		userCodeLength: config.userCodeLength ?? 8,
+		expiresIn: config.expiresIn ?? 900,
+		interval: config.interval ?? 5,
+		verificationUri: config.verificationUri
+	};
+}
 
 //#endregion
-export { Device };
+export { device };
 //# sourceMappingURL=device.js.map

package/dist/providers/email.d.ts

@@ -1,62 +1,45 @@
+import { EmailConfig } from "../server/types.js";
+import { AnyDataModel, GenericActionCtx } from "convex/server";
+
 //#region src/providers/email.d.ts
-/**
- * Email (magic link / OTP) authentication provider.
- *
- * @module
- */
-/**
- * User-facing configuration for the {@link Email} provider.
- *
- * Use this to wire your email delivery service into Convex Auth's magic-link
- * or OTP flow.
- */
+/** Configuration for the {@link email} provider. */
 interface EmailProviderConfig {
-  /** Sender address (e.g. "My App <noreply@example.com>"). */
+  /** Sender address used for outgoing verification emails. */
   from: string;
-  /** Send the verification email. Receives the Convex action context. */
-  send: (ctx: any, opts: {
+  /** Delivery callback that actually sends the rendered verification email. */
+  send: (ctx: GenericActionCtx<AnyDataModel>, opts: {
     from: string;
     to: string;
     subject: string;
     html: string;
   }) => Promise<void>;
-  /** Override to generate a custom verification token. */
+  /** Optional custom token generator for OTP or magic-link flows. */
   generateVerificationToken?: () => Promise<string>;
-  /** Provider ID override. Defaults to "email". */
+  /** Stable provider identifier used in `signIn("<id>")`. */
   id?: string;
-  /** Token expiration in seconds. Defaults to 86400 (24 hours). */
+  /** Verification token lifetime in seconds. */
   maxAge?: number;
 }
 /**
- * Email provider for magic-link or one-time-code sign-in.
+ * Create an email magic link or OTP provider.
  *
- * Sends verification emails through your `send()` implementation and converts
- * the result into Convex Auth's internal email-provider runtime shape.
+ * @param config - Sender identity and delivery hooks for verification emails.
+ * @returns A configured email provider for `createAuth`.
+ * @throws {Error} When `from` is empty.
  *
  * @example
  * ```ts
- * import { Email } from "@robelest/convex-auth/providers";
+ * import { email } from "@robelest/convex-auth/providers";
  *
- * const email = new Email({
+ * email({
  *   from: "My App <noreply@example.com>",
- *   send: async (_ctx, { to, subject, html }) => {
- *     await resend.emails.send({ from: "noreply@example.com", to, subject, html });
+ *   send: async (_ctx, message) => {
+ *     await resend.emails.send(message);
  *   },
- * });
+ * })
  * ```
  */
-declare class Email {
-  readonly config: EmailProviderConfig;
-  readonly id: string;
-  readonly type: "email";
-  /**
-   * Create an email provider instance.
-   *
-   * @param config - Email transport and provider settings.
-   * @throws {Error} When `config.from` is empty or whitespace-only.
-   */
-  constructor(config: EmailProviderConfig);
-}
+declare function email(config: EmailProviderConfig): EmailConfig;
 //#endregion
-export { Email, EmailProviderConfig };
+export { EmailProviderConfig, email };
 //# sourceMappingURL=email.d.ts.map

package/dist/providers/email.js

@@ -2,70 +2,51 @@ import { defaultMagicLinkEmail } from "../server/templates.js";
 
 //#region src/providers/email.ts
 /**
-* Email (magic link / OTP) authentication provider.
+* Create an email magic link or OTP provider.
 *
-* @module
-*/
-/**
-* Email provider for magic-link or one-time-code sign-in.
-*
-* Sends verification emails through your `send()` implementation and converts
-* the result into Convex Auth's internal email-provider runtime shape.
+* @param config - Sender identity and delivery hooks for verification emails.
+* @returns A configured email provider for `createAuth`.
+* @throws {Error} When `from` is empty.
 *
 * @example
 * ```ts
-* import { Email } from "@robelest/convex-auth/providers";
+* import { email } from "@robelest/convex-auth/providers";
 *
-* const email = new Email({
+* email({
 *   from: "My App <noreply@example.com>",
-*   send: async (_ctx, { to, subject, html }) => {
-*     await resend.emails.send({ from: "noreply@example.com", to, subject, html });
+*   send: async (_ctx, message) => {
+*     await resend.emails.send(message);
 *   },
-* });
+* })
 * ```
 */
-var Email = class {
-	id;
-	type = "email";
-	/**
-	* Create an email provider instance.
-	*
-	* @param config - Email transport and provider settings.
-	* @throws {Error} When `config.from` is empty or whitespace-only.
-	*/
-	constructor(config) {
-		this.config = config;
-		if (config.from.trim().length === 0) throw new Error("Email provider requires a non-empty `from` address (for example, `\"My App <noreply@example.com>\"`).");
-		this.id = config.id ?? "email";
-	}
-	/** @internal */
-	_toMaterialized() {
-		const from = this.config.from.trim();
-		const { send } = this.config;
-		const { generateVerificationToken } = this.config;
-		return {
-			id: this.id,
-			type: "email",
-			name: "Email",
-			from,
-			maxAge: this.config.maxAge ?? 3600 * 24,
-			authorize: void 0,
-			sendVerificationRequest: async ({ identifier, url }, ctx) => {
-				if (!ctx) throw new Error("Email provider requires a Convex action context.");
-				const { host } = new URL(url);
-				await send(ctx, {
-					from,
-					to: identifier,
-					subject: `Sign in to ${host}`,
-					html: defaultMagicLinkEmail(url, host)
-				});
-			},
-			generateVerificationToken,
-			options: { from }
-		};
-	}
-};
+function email(config) {
+	const from = config.from.trim();
+	if (from.length === 0) throw new Error("Email provider requires a non-empty `from` address (for example, `\"My App <noreply@example.com>\"`).");
+	const { send } = config;
+	const { generateVerificationToken } = config;
+	return {
+		id: config.id ?? "email",
+		type: "email",
+		name: "Email",
+		from,
+		maxAge: config.maxAge ?? 3600 * 24,
+		authorize: void 0,
+		sendVerificationRequest: async ({ identifier, url }, ctx) => {
+			if (!ctx) throw new Error("Email provider requires a Convex action context.");
+			const { host } = new URL(url);
+			await send(ctx, {
+				from,
+				to: identifier,
+				subject: `Sign in to ${host}`,
+				html: defaultMagicLinkEmail(url, host)
+			});
+		},
+		generateVerificationToken,
+		options: { from }
+	};
+}
 
 //#endregion
-export { Email };
+export { email };
 //# sourceMappingURL=email.js.map

package/dist/providers/github.d.ts

@@ -0,0 +1,54 @@
+import { OAuthMaterializedConfig } from "../server/types.js";
+
+//#region src/providers/github.d.ts
+/**
+ * GitHub OAuth provider.
+ *
+ * ```ts
+ * import { github } from "@robelest/convex-auth/providers/github";
+ *
+ * github({
+ *   clientId: process.env.AUTH_GITHUB_ID!,
+ *   clientSecret: process.env.AUTH_GITHUB_SECRET!,
+ * })
+ * ```
+ *
+ * @module
+ */
+/** Configuration for the {@link github} provider. */
+interface GitHubConfig {
+  /** OAuth app client ID from GitHub. */
+  clientId: string;
+  /** OAuth app client secret from GitHub. */
+  clientSecret: string;
+  /** Optional callback URL override. Defaults to `CUSTOM_AUTH_SITE_URL` or `CONVEX_SITE_URL` plus `/api/auth/callback/github`. */
+  redirectUri?: string;
+  /** Optional OAuth scopes. Defaults to `user:email`. */
+  scopes?: string[];
+  /** Account-linking strategy for existing users with matching email addresses. */
+  accountLinking?: "verifiedEmail" | "none";
+}
+/**
+ * Create a GitHub OAuth provider.
+ *
+ * GitHub is not OIDC by default, so this wrapper fetches the profile and email
+ * data for you after the OAuth code exchange.
+ *
+ * @param config - GitHub OAuth client settings.
+ * @returns A configured GitHub OAuth provider for `createAuth`.
+ * @throws {Error} When no callback URL can be derived and `redirectUri` is omitted.
+ *
+ * @example
+ * ```ts
+ * import { github } from "@robelest/convex-auth/providers/github";
+ *
+ * github({
+ *   clientId: process.env.AUTH_GITHUB_ID!,
+ *   clientSecret: process.env.AUTH_GITHUB_SECRET!,
+ * })
+ * ```
+ */
+declare function github(config: GitHubConfig): OAuthMaterializedConfig;
+//#endregion
+export { GitHubConfig, github };
+//# sourceMappingURL=github.d.ts.map

package/dist/providers/github.js

@@ -0,0 +1,75 @@
+import { envOptionalString, readConfigSync } from "../server/env.js";
+import { createArcticOAuthClient, createOAuthProvider } from "../server/oauth/factory.js";
+import { GitHub } from "arctic";
+
+//#region src/providers/github.ts
+/**
+* GitHub OAuth provider.
+*
+* ```ts
+* import { github } from "@robelest/convex-auth/providers/github";
+*
+* github({
+*   clientId: process.env.AUTH_GITHUB_ID!,
+*   clientSecret: process.env.AUTH_GITHUB_SECRET!,
+* })
+* ```
+*
+* @module
+*/
+const DEFAULT_SCOPES = ["user:email"];
+/**
+* Create a GitHub OAuth provider.
+*
+* GitHub is not OIDC by default, so this wrapper fetches the profile and email
+* data for you after the OAuth code exchange.
+*
+* @param config - GitHub OAuth client settings.
+* @returns A configured GitHub OAuth provider for `createAuth`.
+* @throws {Error} When no callback URL can be derived and `redirectUri` is omitted.
+*
+* @example
+* ```ts
+* import { github } from "@robelest/convex-auth/providers/github";
+*
+* github({
+*   clientId: process.env.AUTH_GITHUB_ID!,
+*   clientSecret: process.env.AUTH_GITHUB_SECRET!,
+* })
+* ```
+*/
+function github(config) {
+	return createOAuthProvider({
+		id: "github",
+		provider: createArcticOAuthClient(new GitHub(config.clientId, config.clientSecret, config.redirectUri ?? defaultRedirectUri("github")), { pkce: "never" }),
+		scopes: config.scopes ?? DEFAULT_SCOPES,
+		accountLinking: config.accountLinking,
+		profile: async (tokens) => {
+			if (!tokens.accessToken) throw new Error("GitHub OAuth response is missing access_token.");
+			const accessToken = tokens.accessToken;
+			const [userResponse, emailResponse] = await Promise.all([fetch("https://api.github.com/user", { headers: { Authorization: `Bearer ${accessToken}` } }), fetch("https://api.github.com/user/emails", { headers: { Authorization: `Bearer ${accessToken}` } })]);
+			if (!userResponse.ok) throw new Error(`GitHub profile request failed: ${userResponse.status}`);
+			if (!emailResponse.ok) throw new Error(`GitHub email request failed: ${emailResponse.status}`);
+			const user = await userResponse.json();
+			const emails = await emailResponse.json();
+			const primaryEmail = emails.find((email) => email.primary)?.email ?? emails.find((email) => email.verified)?.email ?? user.email ?? void 0;
+			const verifiedEmail = emails.find((email) => email.primary)?.verified ?? emails.find((email) => email.verified)?.verified ?? false;
+			return {
+				id: String(user.id),
+				email: typeof primaryEmail === "string" ? primaryEmail : void 0,
+				emailVerified: verifiedEmail,
+				name: typeof user.name === "string" ? user.name : void 0,
+				image: typeof user.avatar_url === "string" ? user.avatar_url : void 0
+			};
+		}
+	});
+}
+function defaultRedirectUri(providerId) {
+	const rootUrl = readConfigSync(envOptionalString("CUSTOM_AUTH_SITE_URL")) ?? readConfigSync(envOptionalString("CONVEX_SITE_URL"));
+	if (!rootUrl) throw new Error(`Missing CONVEX_SITE_URL while configuring ${providerId} OAuth provider. Set CONVEX_SITE_URL or pass redirectUri explicitly.`);
+	return `${rootUrl}/api/auth/callback/${providerId}`;
+}
+
+//#endregion
+export { github };
+//# sourceMappingURL=github.js.map

package/dist/providers/google.d.ts

@@ -0,0 +1,54 @@
+import { OAuthMaterializedConfig } from "../server/types.js";
+
+//#region src/providers/google.d.ts
+/**
+ * Google OAuth provider.
+ *
+ * ```ts
+ * import { google } from "@robelest/convex-auth/providers/google";
+ *
+ * google({
+ *   clientId: process.env.AUTH_GOOGLE_ID!,
+ *   clientSecret: process.env.AUTH_GOOGLE_SECRET!,
+ * })
+ * ```
+ *
+ * @module
+ */
+/** Configuration for the {@link google} provider. */
+interface GoogleConfig {
+  /** OAuth client ID from the Google Cloud console. */
+  clientId: string;
+  /** OAuth client secret from the Google Cloud console. */
+  clientSecret: string;
+  /** Optional callback URL override. Defaults to `CUSTOM_AUTH_SITE_URL` or `CONVEX_SITE_URL` plus `/api/auth/callback/google`. */
+  redirectUri?: string;
+  /** Optional OAuth scopes. Defaults to `openid profile email`. */
+  scopes?: string[];
+  /** Account-linking strategy for existing users with matching email addresses. */
+  accountLinking?: "verifiedEmail" | "none";
+}
+/**
+ * Create a Google OAuth provider.
+ *
+ * Uses the Google OpenID Connect flow and requests `openid profile email` by
+ * default.
+ *
+ * @param config - Google OAuth client settings.
+ * @returns A configured Google OAuth provider for `createAuth`.
+ * @throws {Error} When no callback URL can be derived and `redirectUri` is omitted.
+ *
+ * @example
+ * ```ts
+ * import { google } from "@robelest/convex-auth/providers/google";
+ *
+ * google({
+ *   clientId: process.env.AUTH_GOOGLE_ID!,
+ *   clientSecret: process.env.AUTH_GOOGLE_SECRET!,
+ * })
+ * ```
+ */
+declare function google(config: GoogleConfig): OAuthMaterializedConfig;
+//#endregion
+export { GoogleConfig, google };
+//# sourceMappingURL=google.d.ts.map