@luochuanyuewu/payload-auth 1.8.0

package/dist/better-auth/plugin/utils/set.js

@@ -0,0 +1,84 @@
+/**
+ * Deep-sets a value on an object using a dotted-path string.
+ *
+ * **Path syntax**
+ * ──────────────────────────────────────────────────────────
+ *   token        action
+ *   ------------ ------------------------------------------
+ *   `foo.bar`    create/read plain nested objects
+ *   `foo.bar[]`  *append* `value` to array `foo.bar`
+ *   `foo.[]bar`  *prepend* `value` to array `foo.bar`
+ *   `foo.bar[2]` replace item `2` of `foo.bar`, creating
+ *                empty slots if the index is out of bounds
+ *
+ * Missing objects/arrays are created on the fly.
+ * The function mutates `target` in place and returns it so
+ * you can chain calls.
+ *
+ * @typeParam T – target object type
+ * @typeParam V – value type
+ * @param target   Object to mutate
+ * @param rawPath  Dotted path string (see syntax table)
+ * @param value    Value to set / append / prepend
+ * @returns        The original `target` reference
+ *
+ * @example
+ * const o: Record<string, unknown> = {};
+ * set(o, 'alpha.beta[2].gamma', 42);
+ * // o →
+ * // {
+ * //   alpha: {
+ * //     beta: [
+ * //       ,               // <-- empty slot #0
+ * //       ,               // <-- empty slot #1
+ * //       { gamma: 42 }   // <-- slot #2
+ * //     ]
+ * //   }
+ * // }
+ */ export function set(target, rawPath, value) {
+    if (!rawPath) return target;
+    const tokens = rawPath.split(".");
+    let node = target;
+    for(let i = 0; i < tokens.length; i += 1){
+        const raw = tokens[i];
+        const prepend = raw.startsWith("[]");
+        const append = raw.endsWith("[]");
+        const idxMatch = raw.match(/\[(\d+)]$/);
+        const hasIndex = Boolean(idxMatch);
+        const index = hasIndex ? Number(idxMatch[1]) : -1;
+        const key = prepend ? raw.slice(2) : append ? raw.slice(0, -2) : hasIndex ? raw.slice(0, raw.length - idxMatch[0].length) : raw;
+        const last = i === tokens.length - 1;
+        /* ----- prepend / append ------------------------------------------------ */ if (prepend || append) {
+            if (!Array.isArray(node[key])) node[key] = [];
+            if (last) {
+                prepend ? node[key].unshift(value) : node[key].push(value);
+                return target;
+            }
+            const next = {};
+            prepend ? node[key].unshift(next) : node[key].push(next);
+            node = next;
+            continue;
+        }
+        /* ----- explicit numeric index ----------------------------------------- */ if (hasIndex) {
+            if (!Array.isArray(node[key])) node[key] = [];
+            const arr = node[key];
+            while(arr.length <= index)arr.push(undefined);
+            if (last) {
+                arr[index] = value;
+                return target;
+            }
+            if (arr[index] === undefined) arr[index] = {};
+            node = arr[index];
+            continue;
+        }
+        /* ----- plain object step ---------------------------------------------- */ if (last) {
+            node[key] = value;
+            return target;
+        }
+        if (node[key] === undefined) node[key] = {};
+        node = node[key];
+    }
+    return target;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/better-auth/scripts/generate-types.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=generate-types.d.ts.map

package/dist/better-auth/scripts/generate-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-types.d.ts","sourceRoot":"","sources":["../../../src/better-auth/scripts/generate-types.ts"],"names":[],"mappings":""}

package/dist/better-auth/scripts/generate-types.js

@@ -0,0 +1,225 @@
+import { passkey } from "@better-auth/passkey";
+import { scim } from "@better-auth/scim";
+import { sso } from "@better-auth/sso";
+import { stripe } from "@better-auth/stripe";
+import { emailHarmony, phoneHarmony } from "better-auth-harmony";
+import { getSchema } from "better-auth/db";
+import { nextCookies } from "better-auth/next-js";
+import { admin, anonymous, apiKey, bearer, customSession, deviceAuthorization, emailOTP, genericOAuth, jwt, lastLoginMethod, magicLink, mcp, multiSession, oidcProvider, oneTap, oneTimeToken, openAPI, organization, phoneNumber, twoFactor, username } from "better-auth/plugins";
+import { createAccessControl } from "better-auth/plugins/access";
+import { defaultStatements as defaultAdminStatements } from "better-auth/plugins/admin/access";
+import { defaultStatements as defaultOrganizationStatements } from "better-auth/plugins/organization/access";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import Stripe from "stripe";
+const ac = createAccessControl({
+    ...defaultOrganizationStatements,
+    ...defaultAdminStatements
+});
+const plugins = [
+    username(),
+    admin(),
+    apiKey(),
+    passkey(),
+    emailHarmony(),
+    phoneHarmony(),
+    bearer(),
+    emailOTP({
+        sendVerificationOTP: async ()=>{}
+    }),
+    magicLink({
+        sendMagicLink: async ()=>{}
+    }),
+    phoneNumber({
+        sendOTP: async ()=>{}
+    }),
+    oneTap(),
+    anonymous(),
+    multiSession(),
+    oneTimeToken(),
+    oidcProvider({
+        loginPage: ""
+    }),
+    sso(),
+    genericOAuth({
+        config: [
+            {
+                providerId: "typescript",
+                clientId: "typescript",
+                clientSecret: "typescript"
+            }
+        ]
+    }),
+    openAPI(),
+    organization({
+        teams: {
+            enabled: true
+        },
+        ac,
+        dynamicAccessControl: {
+            enabled: true
+        }
+    }),
+    jwt(),
+    twoFactor(),
+    phoneNumber(),
+    nextCookies(),
+    customSession(async ()=>({})),
+    scim(),
+    mcp({
+        loginPage: ""
+    }),
+    deviceAuthorization(),
+    lastLoginMethod({
+        storeInDatabase: true
+    }),
+    stripe({
+        stripeClient: new Stripe("typescript"),
+        stripeWebhookSecret: "typescript",
+        subscription: {
+            enabled: true,
+            plans: [
+                {
+                    name: "Basic",
+                    priceId: "basic"
+                },
+                {
+                    name: "Pro",
+                    priceId: "pro"
+                },
+                {
+                    name: "Enterprise",
+                    priceId: "enterprise"
+                }
+            ]
+        }
+    })
+];
+const betterAuthConfig = {
+    emailAndPassword: {
+        enabled: true
+    },
+    rateLimit: {
+        enabled: true,
+        storage: "database",
+        max: 5,
+        window: 10
+    },
+    user: {
+        additionalFields: {
+            role: {
+                type: "string",
+                defaultValue: "user",
+                input: false
+            }
+        }
+    },
+    plugins
+};
+const baseSchema = getSchema({
+    ...betterAuthConfig,
+    plugins: []
+});
+const map = (t)=>{
+    if (t === "boolean") return "boolean";
+    if (t === "date") return "Date";
+    if (t === "number") return "number";
+    if (t === "string") return "string";
+    if (t === "number[]") return "number[]";
+    if (t === "string[]") return "string[]";
+    return "unknown";
+};
+const pascal = (s)=>s.split(/[-_]/g).map((p)=>p.charAt(0).toUpperCase() + p.slice(1)).join("");
+const diff = (base, target)=>{
+    const d = {};
+    for (const [m, { fields }] of Object.entries(target)){
+        const added = Object.entries(fields).filter(([k])=>!(k in (base[m]?.fields ?? {})));
+        if (added.length) d[m] = Object.fromEntries(added);
+    }
+    return d;
+};
+const gen = ()=>{
+    let out = "// Auto-generated types. Do not edit.\n\n";
+    const pluginAdds = {};
+    const seen = new Set();
+    for (const pl of plugins){
+        const id = pl.id;
+        if (!id || seen.has(id)) continue;
+        seen.add(id);
+        const adds = diff(baseSchema, getSchema({
+            ...betterAuthConfig,
+            plugins: [
+                pl
+            ]
+        }));
+        for (const [m, f] of Object.entries(adds)){
+            pluginAdds[m] ??= {};
+            pluginAdds[m][id] = f;
+        }
+    }
+    const models = new Set([
+        ...Object.keys(baseSchema),
+        ...Object.keys(pluginAdds)
+    ]);
+    for (const model of models){
+        const P = pascal(model);
+        const base = baseSchema[model]?.fields ?? {};
+        const pluginsForModel = pluginAdds[model] ?? {};
+        const pluginIds = Object.keys(pluginsForModel);
+        if (Object.keys(base).length) {
+            out += `export type Base${P}Fields = {\n`;
+            for (const [k, f] of Object.entries(base))out += `  ${f.fieldName ?? k}${f.required ? "" : "?"}: ${map(f.type)}\n`;
+            out += "}\n\n";
+        }
+        const needPluginMap = pluginIds.length > 1 || Object.keys(base).length;
+        if (needPluginMap && pluginIds.length) {
+            out += `export type ${P}PluginFields = {\n`;
+            for (const [pid, flds] of Object.entries(pluginsForModel)){
+                out += `  ${JSON.stringify(pid)}: {\n`;
+                for (const [k, f] of Object.entries(flds))out += `    ${f.fieldName ?? k}${f.required ? "" : "?"}: ${map(f.type)}\n`;
+                out += "  }\n";
+            }
+            out += "}\n\n";
+        }
+        if (!Object.keys(base).length && pluginIds.length === 1) {
+            const only = pluginIds[0];
+            out += `export type ${P}Fields = {\n`;
+            for (const [k, f] of Object.entries(pluginsForModel[only]))out += `  ${f.fieldName ?? k}${f.required ? "" : "?"}: ${map(f.type)}\n`;
+            out += "}\n\n";
+            out += `export type ${P} = ${P}Fields\n\n`;
+            continue;
+        }
+        const parts = [];
+        if (Object.keys(base).length) parts.push(`Base${P}Fields`);
+        if (pluginIds.length) {
+            const mapName = needPluginMap ? `${P}PluginFields` : undefined;
+            parts.push(...pluginIds.map((id)=>mapName ? `${mapName}[${JSON.stringify(id)}]` : "never" /* not reachable */ ));
+        }
+        out += `export type ${P} = ${parts.join(" & ")}\n\n`;
+    }
+    // Generate union type of plugin identifiers
+    const pluginIdUnion = [
+        ...seen
+    ].map((id)=>JSON.stringify(id)).join(" | ");
+    out += `export type PluginId = ${pluginIdUnion}\n\n`;
+    // Generate full schema mapping
+    out += `export type BetterAuthFullSchema = {\n`;
+    for (const model of models){
+        const P = pascal(model);
+        out += `  ${JSON.stringify(model)}: ${P}\n`;
+    }
+    out += `}\n\n`;
+    // Generate union type of all model names
+    out += `export type ModelKey = keyof BetterAuthFullSchema`;
+    return out;
+};
+const generated = gen();
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+(async ()=>{
+    const file = path.resolve(__dirname, "../generated-types.ts");
+    await fs.writeFile(file, generated, "utf8");
+    console.log(`Generated types written to ${file}`);
+})();
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/better-auth/scripts/generate-types.ts"],"sourcesContent":["import { passkey } from \"@better-auth/passkey\";\nimport { scim } from \"@better-auth/scim\";\nimport { sso } from \"@better-auth/sso\";\nimport { stripe } from \"@better-auth/stripe\";\nimport { emailHarmony, phoneHarmony } from \"better-auth-harmony\";\nimport type { DBFieldAttribute } from \"better-auth/db\";\nimport { getSchema } from \"better-auth/db\";\nimport { nextCookies } from \"better-auth/next-js\";\nimport {\n  admin,\n  anonymous,\n  apiKey,\n  bearer,\n  customSession,\n  deviceAuthorization,\n  emailOTP,\n  genericOAuth,\n  jwt,\n  lastLoginMethod,\n  magicLink,\n  mcp,\n  multiSession,\n  oidcProvider,\n  oneTap,\n  oneTimeToken,\n  openAPI,\n  organization,\n  phoneNumber,\n  twoFactor,\n  username\n} from \"better-auth/plugins\";\nimport { createAccessControl } from \"better-auth/plugins/access\";\nimport { defaultStatements as defaultAdminStatements } from \"better-auth/plugins/admin/access\";\nimport { defaultStatements as defaultOrganizationStatements } from \"better-auth/plugins/organization/access\";\nimport fs from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\n\nimport Stripe from \"stripe\";\nimport type { SanitizedBetterAuthOptions } from \"../types\";\n\nconst ac = createAccessControl({\n  ...defaultOrganizationStatements,\n  ...defaultAdminStatements\n});\n\nconst plugins = [\n  username(),\n  admin(),\n  apiKey(),\n  passkey(),\n  emailHarmony(),\n  phoneHarmony(),\n  bearer(),\n  emailOTP({ sendVerificationOTP: async () => {} }),\n  magicLink({ sendMagicLink: async () => {} }),\n  phoneNumber({ sendOTP: async () => {} }),\n  oneTap(),\n  anonymous(),\n  multiSession(),\n  oneTimeToken(),\n  oidcProvider({ loginPage: \"\" }),\n  sso(),\n  genericOAuth({\n    config: [\n      {\n        providerId: \"typescript\",\n        clientId: \"typescript\",\n        clientSecret: \"typescript\"\n      }\n    ]\n  }),\n  openAPI(),\n  organization({\n    teams: { enabled: true },\n    ac,\n    dynamicAccessControl: {\n      enabled: true\n    }\n  }),\n  jwt(),\n  twoFactor(),\n  phoneNumber(),\n  nextCookies(),\n  customSession(async () => ({})),\n  scim(),\n  mcp({ loginPage: \"\" }),\n  deviceAuthorization(),\n  lastLoginMethod({ storeInDatabase: true }),\n  stripe({\n    stripeClient: new Stripe(\"typescript\"),\n    stripeWebhookSecret: \"typescript\",\n    subscription: {\n      enabled: true,\n      plans: [\n        {\n          name: \"Basic\",\n          priceId: \"basic\"\n        },\n        {\n          name: \"Pro\",\n          priceId: \"pro\"\n        },\n        {\n          name: \"Enterprise\",\n          priceId: \"enterprise\"\n        }\n      ]\n    }\n  })\n  // As of writing this, Polar don't create schema fields, but just in case in the future we leave this here.\n];\n\nconst betterAuthConfig: SanitizedBetterAuthOptions = {\n  emailAndPassword: { enabled: true },\n  rateLimit: { enabled: true, storage: \"database\", max: 5, window: 10 },\n  user: {\n    additionalFields: {\n      role: { type: \"string\", defaultValue: \"user\", input: false }\n    }\n  },\n  plugins\n};\n\nconst baseSchema = getSchema({ ...betterAuthConfig, plugins: [] });\n\ntype Schema = Record<string, { fields: Record<string, DBFieldAttribute> }>;\n\nconst map = (t: string): string => {\n  if (t === \"boolean\") return \"boolean\";\n  if (t === \"date\") return \"Date\";\n  if (t === \"number\") return \"number\";\n  if (t === \"string\") return \"string\";\n  if (t === \"number[]\") return \"number[]\";\n  if (t === \"string[]\") return \"string[]\";\n  return \"unknown\";\n};\n\nconst pascal = (s: string): string =>\n  s\n    .split(/[-_]/g)\n    .map((p) => p.charAt(0).toUpperCase() + p.slice(1))\n    .join(\"\");\n\nconst diff = (\n  base: Schema,\n  target: Schema\n): Record<string, Record<string, DBFieldAttribute>> => {\n  const d: Record<string, Record<string, DBFieldAttribute>> = {};\n  for (const [m, { fields }] of Object.entries(target)) {\n    const added = Object.entries(fields).filter(\n      ([k]) => !(k in (base[m]?.fields ?? {}))\n    );\n    if (added.length) d[m] = Object.fromEntries(added);\n  }\n  return d;\n};\n\nconst gen = (): string => {\n  let out = \"// Auto-generated types. Do not edit.\\n\\n\";\n\n  const pluginAdds: Record<\n    string,\n    Record<string, Record<string, DBFieldAttribute>>\n  > = {};\n  const seen = new Set<string>();\n\n  for (const pl of plugins) {\n    const id = (pl as any).id as string | undefined;\n    if (!id || seen.has(id)) continue;\n    seen.add(id);\n    const adds = diff(\n      baseSchema,\n      getSchema({ ...betterAuthConfig, plugins: [pl] })\n    );\n    for (const [m, f] of Object.entries(adds)) {\n      pluginAdds[m] ??= {};\n      pluginAdds[m][id] = f;\n    }\n  }\n\n  const models = new Set<string>([\n    ...Object.keys(baseSchema),\n    ...Object.keys(pluginAdds)\n  ]);\n\n  for (const model of models) {\n    const P = pascal(model);\n    const base = baseSchema[model]?.fields ?? {};\n    const pluginsForModel = pluginAdds[model] ?? {};\n    const pluginIds = Object.keys(pluginsForModel);\n\n    if (Object.keys(base).length) {\n      out += `export type Base${P}Fields = {\\n`;\n      for (const [k, f] of Object.entries(base))\n        out += `  ${f.fieldName ?? k}${f.required ? \"\" : \"?\"}: ${map(f.type as string)}\\n`;\n      out += \"}\\n\\n\";\n    }\n\n    const needPluginMap = pluginIds.length > 1 || Object.keys(base).length;\n    if (needPluginMap && pluginIds.length) {\n      out += `export type ${P}PluginFields = {\\n`;\n      for (const [pid, flds] of Object.entries(pluginsForModel)) {\n        out += `  ${JSON.stringify(pid)}: {\\n`;\n        for (const [k, f] of Object.entries(flds))\n          out += `    ${f.fieldName ?? k}${f.required ? \"\" : \"?\"}: ${map(f.type as string)}\\n`;\n        out += \"  }\\n\";\n      }\n      out += \"}\\n\\n\";\n    }\n\n    if (!Object.keys(base).length && pluginIds.length === 1) {\n      const only = pluginIds[0];\n      out += `export type ${P}Fields = {\\n`;\n      for (const [k, f] of Object.entries(pluginsForModel[only]))\n        out += `  ${f.fieldName ?? k}${f.required ? \"\" : \"?\"}: ${map(f.type as string)}\\n`;\n      out += \"}\\n\\n\";\n      out += `export type ${P} = ${P}Fields\\n\\n`;\n      continue;\n    }\n\n    const parts: string[] = [];\n    if (Object.keys(base).length) parts.push(`Base${P}Fields`);\n    if (pluginIds.length) {\n      const mapName = needPluginMap ? `${P}PluginFields` : undefined;\n      parts.push(\n        ...pluginIds.map(\n          (id) =>\n            mapName\n              ? `${mapName}[${JSON.stringify(id)}]`\n              : \"never\" /* not reachable */\n        )\n      );\n    }\n    out += `export type ${P} = ${parts.join(\" & \")}\\n\\n`;\n  }\n\n  // Generate union type of plugin identifiers\n  const pluginIdUnion = [...seen].map((id) => JSON.stringify(id)).join(\" | \");\n  out += `export type PluginId = ${pluginIdUnion}\\n\\n`;\n\n  // Generate full schema mapping\n  out += `export type BetterAuthFullSchema = {\\n`;\n  for (const model of models) {\n    const P = pascal(model);\n    out += `  ${JSON.stringify(model)}: ${P}\\n`;\n  }\n  out += `}\\n\\n`;\n\n  // Generate union type of all model names\n  out += `export type ModelKey = keyof BetterAuthFullSchema`;\n\n  return out;\n};\n\nconst generated = gen();\n\nconst __dirname = path.dirname(fileURLToPath(import.meta.url));\n(async () => {\n  const file = path.resolve(__dirname, \"../generated-types.ts\");\n  await fs.writeFile(file, generated, \"utf8\");\n  console.log(`Generated types written to ${file}`);\n})();\n"],"names":["passkey","scim","sso","stripe","emailHarmony","phoneHarmony","getSchema","nextCookies","admin","anonymous","apiKey","bearer","customSession","deviceAuthorization","emailOTP","genericOAuth","jwt","lastLoginMethod","magicLink","mcp","multiSession","oidcProvider","oneTap","oneTimeToken","openAPI","organization","phoneNumber","twoFactor","username","createAccessControl","defaultStatements","defaultAdminStatements","defaultOrganizationStatements","fs","path","fileURLToPath","Stripe","ac","plugins","sendVerificationOTP","sendMagicLink","sendOTP","loginPage","config","providerId","clientId","clientSecret","teams","enabled","dynamicAccessControl","storeInDatabase","stripeClient","stripeWebhookSecret","subscription","plans","name","priceId","betterAuthConfig","emailAndPassword","rateLimit","storage","max","window","user","additionalFields","role","type","defaultValue","input","baseSchema","map","t","pascal","s","split","p","charAt","toUpperCase","slice","join","diff","base","target","d","m","fields","Object","entries","added","filter","k","length","fromEntries","gen","out","pluginAdds","seen","Set","pl","id","has","add","adds","f","models","keys","model","P","pluginsForModel","pluginIds","fieldName","required","needPluginMap","pid","flds","JSON","stringify","only","parts","push","mapName","undefined","pluginIdUnion","generated","__dirname","dirname","url","file","resolve","writeFile","console","log"],"mappings":"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"}

package/dist/better-auth/types.d.ts

@@ -0,0 +1,3 @@
+export * from "./adapter/types";
+export * from "./plugin/types";
+//# sourceMappingURL=types.d.ts.map

package/dist/better-auth/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/better-auth/types.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC"}

package/dist/better-auth/types.js

@@ -0,0 +1,4 @@
+export * from "./adapter/types";
+export * from "./plugin/types";
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9iZXR0ZXItYXV0aC90eXBlcy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9hZGFwdGVyL3R5cGVzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9wbHVnaW4vdHlwZXNcIjtcbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGtCQUFrQjtBQUNoQyxjQUFjLGlCQUFpQiJ9

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./better-auth";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,eAAe,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+// Package exports for payload-auth
+export * from "./better-auth";
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvLyBQYWNrYWdlIGV4cG9ydHMgZm9yIHBheWxvYWQtYXV0aFxuZXhwb3J0ICogZnJvbSBcIi4vYmV0dGVyLWF1dGhcIjtcbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxtQ0FBbUM7QUFDbkMsY0FBYyxnQkFBZ0IifQ==

package/dist/shared/components/icons.d.ts

@@ -0,0 +1,8 @@
+import { ComponentType, SVGProps } from "react";
+export interface ProviderIconProps extends SVGProps<SVGSVGElement> {
+    className?: string;
+    variant?: "default" | "color";
+}
+export type ProviderIcon = ComponentType<ProviderIconProps>;
+export declare const Icons: Record<string, ProviderIcon>;
+//# sourceMappingURL=icons.d.ts.map

package/dist/shared/components/icons.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"icons.d.ts","sourceRoot":"","sources":["../../../src/shared/components/icons.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAEhD,MAAM,WAAW,iBAAkB,SAAQ,QAAQ,CAAC,aAAa,CAAC;IAChE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC;CAC/B;AAED,MAAM,MAAM,YAAY,GAAG,aAAa,CAAC,iBAAiB,CAAC,CAAC;AAE5D,eAAO,MAAM,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAib9C,CAAC"}