@tokenite/shared 1.0.1

package/dist/catalog/models/types.js

@@ -0,0 +1,45 @@
+const slugify = (s) => s.toLowerCase().replace(/\./g, '-').replace(/\s+/g, '-');
+export const defineFamily = (prefix, entries) => {
+    const out = {};
+    for (const key in entries) {
+        const [tiers, capabilities] = entries[key];
+        const displayName = `${prefix}${humanize(key)}`;
+        out[key] = {
+            __tag: 'model',
+            slug: slugify(displayName),
+            displayName,
+            tiers,
+            capabilities,
+        };
+    }
+    return out;
+};
+export const humanize = (key) => {
+    const parts = key.split('_').filter((p) => p.length > 0);
+    const out = [];
+    let numBuf = [];
+    const flush = () => {
+        if (numBuf.length) {
+            out.push(numBuf.join('.'));
+            numBuf = [];
+        }
+    };
+    for (const p of parts) {
+        if (/^\d+$/.test(p))
+            numBuf.push(p);
+        else {
+            flush();
+            out.push(p);
+        }
+    }
+    flush();
+    return out.join(' ');
+};
+export const model = (displayName, tiers, capabilities) => ({
+    __tag: 'model',
+    slug: slugify(displayName),
+    displayName,
+    tiers,
+    capabilities,
+});
+//# sourceMappingURL=types.js.map

package/dist/catalog/providers/anthropic.d.ts

@@ -0,0 +1,2 @@
+export declare const anthropic: import("./types.js").Provider;
+//# sourceMappingURL=anthropic.d.ts.map

package/dist/catalog/providers/anthropic.js

@@ -0,0 +1,13 @@
+import { defineProvider } from './types.js';
+export const anthropic = defineProvider({
+    displayName: 'Anthropic',
+    color: '#d97706',
+    logoUrl: '/providers/anthropic.svg',
+    logoStyle: 'symbol',
+    flavor: 'anthropic',
+    baseUrl: 'https://api.anthropic.com',
+    auth: { kind: 'header', name: 'x-api-key' },
+    defaultHeaders: { 'anthropic-version': '2023-06-01' },
+    keyPrefixHints: ['sk-ant-'],
+});
+//# sourceMappingURL=anthropic.js.map

package/dist/catalog/providers/bedrock.d.ts

@@ -0,0 +1,2 @@
+export declare const bedrock: import("./types.js").Provider;
+//# sourceMappingURL=bedrock.d.ts.map

package/dist/catalog/providers/bedrock.js

@@ -0,0 +1,20 @@
+import { defineProvider } from './types.js';
+const adaptToBedrock = (_flavorPath, body, model) => {
+    const { model: _, ...rest } = body;
+    return {
+        path: `/model/${encodeURIComponent(model)}/invoke`,
+        body: { ...rest, anthropic_version: 'bedrock-2023-05-31' },
+    };
+};
+export const bedrock = defineProvider({
+    displayName: 'Bedrock',
+    color: '#ff9900',
+    logoUrl: '/providers/bedrock.svg',
+    logoStyle: 'symbol',
+    flavor: 'anthropic',
+    baseUrl: 'https://bedrock-runtime.us-east-1.amazonaws.com',
+    auth: { kind: 'sigv4', service: 'bedrock', defaultRegion: 'us-east-1' },
+    keyPrefixHints: ['AKIA'],
+    adaptRequest: adaptToBedrock,
+});
+//# sourceMappingURL=bedrock.js.map

package/dist/catalog/providers/google.d.ts

@@ -0,0 +1,2 @@
+export declare const google: import("./types.js").Provider;
+//# sourceMappingURL=google.d.ts.map

package/dist/catalog/providers/google.js

@@ -0,0 +1,12 @@
+import { defineProvider } from './types.js';
+export const google = defineProvider({
+    displayName: 'Gemini',
+    color: '#4285f4',
+    logoUrl: '/providers/google.svg',
+    logoStyle: 'symbol',
+    flavor: 'gemini',
+    baseUrl: 'https://generativelanguage.googleapis.com',
+    auth: { kind: 'query', param: 'key' },
+    keyPrefixHints: ['AIza'],
+});
+//# sourceMappingURL=google.js.map

package/dist/catalog/providers/grok.d.ts

@@ -0,0 +1,2 @@
+export declare const grok: import("./types.js").Provider;
+//# sourceMappingURL=grok.d.ts.map

package/dist/catalog/providers/grok.js

@@ -0,0 +1,12 @@
+import { defineProvider } from './types.js';
+export const grok = defineProvider({
+    displayName: 'Grok',
+    color: '#000000',
+    logoUrl: '/providers/grok.svg',
+    logoStyle: 'symbol',
+    flavor: 'openai',
+    baseUrl: 'https://api.x.ai',
+    auth: { kind: 'header', name: 'authorization', format: (key) => `Bearer ${key}` },
+    keyPrefixHints: ['xai-'],
+});
+//# sourceMappingURL=grok.js.map

package/dist/catalog/providers/index.d.ts

@@ -0,0 +1,17 @@
+import type { Provider } from './types.js';
+export { type Provider, type ProviderAuth, defineProvider } from './types.js';
+export declare const PROVIDERS: {
+    readonly anthropic: Provider;
+    readonly openai: Provider;
+    readonly google: Provider;
+    readonly grok: Provider;
+    readonly bedrock: Provider;
+};
+export type ProviderId = keyof typeof PROVIDERS;
+export declare const PROVIDER_IDS: [ProviderId, ...ProviderId[]];
+export declare const providerName: (p: Provider) => ProviderId;
+export declare const getProvider: (id: ProviderId) => Provider;
+export declare const tryGetProvider: (id: string) => Provider | null;
+export declare const listProviders: () => readonly Provider[];
+export declare const guessProviderFromKey: (apiKey: string) => ProviderId | null;
+//# sourceMappingURL=index.d.ts.map

package/dist/catalog/providers/index.js

@@ -0,0 +1,28 @@
+import { anthropic } from './anthropic.js';
+import { openai } from './openai.js';
+import { google } from './google.js';
+import { grok } from './grok.js';
+import { bedrock } from './bedrock.js';
+export { defineProvider } from './types.js';
+export const PROVIDERS = {
+    anthropic,
+    openai,
+    google,
+    grok,
+    bedrock,
+};
+export const PROVIDER_IDS = Object.keys(PROVIDERS);
+const PROVIDER_NAME = new Map(Object.entries(PROVIDERS).map(([k, v]) => [v, k]));
+export const providerName = (p) => PROVIDER_NAME.get(p);
+export const getProvider = (id) => PROVIDERS[id];
+export const tryGetProvider = (id) => PROVIDERS[id] ?? null;
+export const listProviders = () => Object.values(PROVIDERS);
+export const guessProviderFromKey = (apiKey) => {
+    for (const id of PROVIDER_IDS) {
+        const hints = PROVIDERS[id].keyPrefixHints;
+        if (hints?.some((prefix) => apiKey.startsWith(prefix)))
+            return id;
+    }
+    return null;
+};
+//# sourceMappingURL=index.js.map

package/dist/catalog/providers/openai.d.ts

@@ -0,0 +1,2 @@
+export declare const openai: import("./types.js").Provider;
+//# sourceMappingURL=openai.d.ts.map

package/dist/catalog/providers/openai.js

@@ -0,0 +1,12 @@
+import { defineProvider } from './types.js';
+export const openai = defineProvider({
+    displayName: 'OpenAI',
+    color: '#10a37f',
+    logoUrl: '/providers/openai.svg',
+    logoStyle: 'symbol',
+    flavor: 'openai',
+    baseUrl: 'https://api.openai.com',
+    auth: { kind: 'header', name: 'authorization', format: (key) => `Bearer ${key}` },
+    keyPrefixHints: ['sk-proj-', 'sk-'],
+});
+//# sourceMappingURL=openai.js.map

package/dist/catalog/providers/types.d.ts

@@ -0,0 +1,32 @@
+import type { FlavorId } from '../flavors/index.js';
+export type ProviderAuth = {
+    readonly kind: 'header';
+    readonly name: string;
+    readonly format?: (key: string) => string;
+} | {
+    readonly kind: 'query';
+    readonly param: string;
+} | {
+    readonly kind: 'sigv4';
+    readonly service: string;
+    readonly defaultRegion: string;
+};
+export type RequestShape = {
+    readonly path: string;
+    readonly body: Readonly<Record<string, unknown>>;
+};
+export type Provider = {
+    readonly __tag: 'provider';
+    readonly displayName: string;
+    readonly color: string;
+    readonly logoUrl: string;
+    readonly logoStyle: 'symbol' | 'wordmark';
+    readonly flavor: FlavorId;
+    readonly baseUrl: string;
+    readonly auth: ProviderAuth;
+    readonly defaultHeaders?: Readonly<Record<string, string>>;
+    readonly keyPrefixHints?: readonly string[];
+    readonly adaptRequest?: (flavorPath: string, flavorBody: Readonly<Record<string, unknown>>, vendorModelName: string) => RequestShape;
+};
+export declare const defineProvider: <T extends Provider>(p: Omit<T, "__tag">) => T;
+//# sourceMappingURL=types.d.ts.map

package/dist/catalog/providers/types.js

@@ -0,0 +1,2 @@
+export const defineProvider = (p) => ({ __tag: 'provider', ...p });
+//# sourceMappingURL=types.js.map

package/dist/catalog/tiers.d.ts

@@ -0,0 +1,12 @@
+export type Tier = {
+    readonly __tag: 'tier';
+};
+export declare const TIERS: {
+    readonly cheap: Tier;
+    readonly fast: Tier;
+    readonly smart: Tier;
+    readonly reasoning: Tier;
+};
+export type TierId = keyof typeof TIERS;
+export declare const tierName: (t: Tier) => TierId;
+//# sourceMappingURL=tiers.d.ts.map

package/dist/catalog/tiers.js

@@ -0,0 +1,9 @@
+export const TIERS = {
+    cheap: {},
+    fast: {},
+    smart: {},
+    reasoning: {},
+};
+const TIER_NAME = new Map(Object.entries(TIERS).map(([k, v]) => [v, k]));
+export const tierName = (t) => TIER_NAME.get(t);
+//# sourceMappingURL=tiers.js.map

package/dist/config.d.ts

@@ -0,0 +1,3 @@
+export declare const requireEnv: (name: string, fallback?: string) => string;
+export declare const optionalEnv: (name: string) => string | undefined;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -0,0 +1,11 @@
+const isProduction = () => process.env['NODE_ENV'] === 'production';
+export const requireEnv = (name, fallback) => {
+    const value = process.env[name];
+    if (value)
+        return value;
+    if (fallback && !isProduction())
+        return fallback;
+    throw new Error(`Missing required environment variable: ${name}`);
+};
+export const optionalEnv = (name) => process.env[name];
+//# sourceMappingURL=config.js.map

package/dist/constants.d.ts

@@ -0,0 +1,31 @@
+export declare const rateLimits: {
+    readonly login: {
+        readonly maxRequests: 5;
+        readonly windowSeconds: 900;
+        readonly keyPrefix: "login";
+    };
+    readonly register: {
+        readonly maxRequests: 3;
+        readonly windowSeconds: 3600;
+        readonly keyPrefix: "register";
+    };
+    readonly token: {
+        readonly maxRequests: 10;
+        readonly windowSeconds: 3600;
+        readonly keyPrefix: "token";
+    };
+    readonly keys: {
+        readonly maxRequests: 20;
+        readonly windowSeconds: 3600;
+        readonly keyPrefix: "keys";
+    };
+    readonly apps: {
+        readonly maxRequests: 10;
+        readonly windowSeconds: 3600;
+        readonly keyPrefix: "apps";
+    };
+};
+export declare const ACCESS_TOKEN_LIFETIME_DAYS = 30;
+export declare const OAUTH_CODE_TTL_SECONDS = 300;
+export declare const TOKEN_CACHE_TTL_SECONDS = 300;
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.js

@@ -0,0 +1,11 @@
+export const rateLimits = {
+    login: { maxRequests: 5, windowSeconds: 900, keyPrefix: 'login' },
+    register: { maxRequests: 3, windowSeconds: 3600, keyPrefix: 'register' },
+    token: { maxRequests: 10, windowSeconds: 3600, keyPrefix: 'token' },
+    keys: { maxRequests: 20, windowSeconds: 3600, keyPrefix: 'keys' },
+    apps: { maxRequests: 10, windowSeconds: 3600, keyPrefix: 'apps' },
+};
+export const ACCESS_TOKEN_LIFETIME_DAYS = 30;
+export const OAUTH_CODE_TTL_SECONDS = 300;
+export const TOKEN_CACHE_TTL_SECONDS = 300;
+//# sourceMappingURL=constants.js.map

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+export { type Result, ok, err, type AppError } from './result.js';
+export { providerSchema, type Provider, } from './schemas/provider.js';
+export { userSchema, createUserRequest, userResponse, type User, type CreateUserRequest, type UserResponse, } from './schemas/user.js';
+export { accountTypeSchema, accountSchema, createAccountRequest, updateAccountRequest, type AccountType, type Account, type CreateAccountRequest, type UpdateAccountRequest, } from './schemas/account.js';
+export { accountRoleSchema, accountMemberSchema, hasAtLeastRole, type AccountRole, type AccountMember, } from './schemas/account-member.js';
+export { accountInvitationSchema, createInvitationRequest, invitationWithClaimUrl, type AccountInvitation, type CreateInvitationRequest, type InvitationWithClaimUrl, } from './schemas/account-invitation.js';
+export { appSchema, createAppRequest, updateAppRequest, appResponse, modelStrategySchema, tierSchema, type App, type CreateAppRequest, type UpdateAppRequest, type AppResponse, type ModelStrategy, type RequiredTier, } from './schemas/app.js';
+export { apiKeySchema, addApiKeyRequest, apiKeyResponse, type ApiKey, type AddApiKeyRequest, type ApiKeyResponse, } from './schemas/api-key.js';
+export { sponsoredApiKeySchema, addSponsoredApiKeyRequest, sponsoredApiKeyResponse, sponsoredKeyConsumerSchema, type SponsoredApiKey, type AddSponsoredApiKeyRequest, type SponsoredApiKeyResponse, type SponsoredKeyConsumer, } from './schemas/sponsored-api-key.js';
+export { budgetSchema, type Budget, DEBT_TOLERANCE_USD, isBudgetAvailable, remainingBudget, } from './schemas/budget.js';
+export { accessTokenSchema, authorizeAppRequest, updateConnectionRequest, connectionResponse, type AccessToken, type AuthorizeAppRequest, type UpdateConnectionRequest, type ConnectionResponse, } from './schemas/access-token.js';
+export { usageLogSchema, type UsageLog, PLATFORM_FEE_RATE, calculatePlatformFee, calculateTotalDebit, } from './schemas/usage.js';
+export { errorResponseSchema, errorSourceSchema, proxyErrorCodes, providerErrorCodes, apiErrorCodes, type ErrorResponse, type ErrorSource, type ProxyErrorCode, type ProviderErrorCode, type ApiErrorCode, type ErrorCode, } from './schemas/error.js';
+export { proxyUsageSchema, proxySuccessSchema, proxyResponseSchema, type ProxyUsage, type ProxySuccess, type ProxyResponse, } from './schemas/proxy-response.js';
+export { discoverySchema, type Discovery, } from './schemas/discovery.js';
+export { CliLoopbackHost, cliLoginParamsSchema, cliLoginMintRequestSchema, cliLoginMintResponseSchema, cliLoginExchangeRequestSchema, cliLoginExchangeResponseSchema, type CliLoginParams, type CliLoginMintRequest, type CliLoginMintResponse, type CliLoginExchangeRequest, type CliLoginExchangeResponse, } from './schemas/cli-login.js';
+export { requireEnv, optionalEnv } from './config.js';
+export { safeParseJson } from './parse.js';
+export { rateLimits, ACCESS_TOKEN_LIFETIME_DAYS, OAUTH_CODE_TTL_SECONDS, TOKEN_CACHE_TTL_SECONDS } from './constants.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,20 @@
+export { ok, err } from './result.js';
+export { providerSchema, } from './schemas/provider.js';
+export { userSchema, createUserRequest, userResponse, } from './schemas/user.js';
+export { accountTypeSchema, accountSchema, createAccountRequest, updateAccountRequest, } from './schemas/account.js';
+export { accountRoleSchema, accountMemberSchema, hasAtLeastRole, } from './schemas/account-member.js';
+export { accountInvitationSchema, createInvitationRequest, invitationWithClaimUrl, } from './schemas/account-invitation.js';
+export { appSchema, createAppRequest, updateAppRequest, appResponse, modelStrategySchema, tierSchema, } from './schemas/app.js';
+export { apiKeySchema, addApiKeyRequest, apiKeyResponse, } from './schemas/api-key.js';
+export { sponsoredApiKeySchema, addSponsoredApiKeyRequest, sponsoredApiKeyResponse, sponsoredKeyConsumerSchema, } from './schemas/sponsored-api-key.js';
+export { budgetSchema, DEBT_TOLERANCE_USD, isBudgetAvailable, remainingBudget, } from './schemas/budget.js';
+export { accessTokenSchema, authorizeAppRequest, updateConnectionRequest, connectionResponse, } from './schemas/access-token.js';
+export { usageLogSchema, PLATFORM_FEE_RATE, calculatePlatformFee, calculateTotalDebit, } from './schemas/usage.js';
+export { errorResponseSchema, errorSourceSchema, proxyErrorCodes, providerErrorCodes, apiErrorCodes, } from './schemas/error.js';
+export { proxyUsageSchema, proxySuccessSchema, proxyResponseSchema, } from './schemas/proxy-response.js';
+export { discoverySchema, } from './schemas/discovery.js';
+export { CliLoopbackHost, cliLoginParamsSchema, cliLoginMintRequestSchema, cliLoginMintResponseSchema, cliLoginExchangeRequestSchema, cliLoginExchangeResponseSchema, } from './schemas/cli-login.js';
+export { requireEnv, optionalEnv } from './config.js';
+export { safeParseJson } from './parse.js';
+export { rateLimits, ACCESS_TOKEN_LIFETIME_DAYS, OAUTH_CODE_TTL_SECONDS, TOKEN_CACHE_TTL_SECONDS } from './constants.js';
+//# sourceMappingURL=index.js.map

package/dist/parse.d.ts

@@ -0,0 +1,2 @@
+export declare const safeParseJson: (text: string) => Record<string, unknown> | null;
+//# sourceMappingURL=parse.d.ts.map

package/dist/parse.js

@@ -0,0 +1,12 @@
+export const safeParseJson = (text) => {
+    try {
+        const parsed = JSON.parse(text);
+        if (typeof parsed === 'object' && parsed !== null)
+            return parsed;
+        return null;
+    }
+    catch {
+        return null;
+    }
+};
+//# sourceMappingURL=parse.js.map

package/dist/providers/index.d.ts

@@ -0,0 +1,3 @@
+export { PROVIDERS, PROVIDER_IDS, type Provider, type ProviderAuth, type ProviderId, getProvider, tryGetProvider, listProviders, providerName, guessProviderFromKey, } from '../catalog/providers/index.js';
+export { type UsageInfo, type UsageExtractor, type RequestedModelExtractor, type ErrorBody, type FlavorHandler, type FlavorId, getFlavor, } from '../catalog/flavors/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/providers/index.js

@@ -0,0 +1,3 @@
+export { PROVIDERS, PROVIDER_IDS, getProvider, tryGetProvider, listProviders, providerName, guessProviderFromKey, } from '../catalog/providers/index.js';
+export { getFlavor, } from '../catalog/flavors/index.js';
+//# sourceMappingURL=index.js.map

package/dist/result.d.ts

@@ -0,0 +1,18 @@
+import type { ErrorCode } from './schemas/error-codes.js';
+export type Result<T, E = AppError> = {
+    readonly ok: true;
+    readonly data: T;
+} | {
+    readonly ok: false;
+    readonly error: E;
+};
+export type AppError = {
+    readonly code: ErrorCode;
+    readonly message: string;
+    readonly status: number;
+    readonly source?: 'proxy' | 'provider';
+    readonly details?: Record<string, unknown>;
+};
+export declare const ok: <T>(data: T) => Result<T, never>;
+export declare const err: <E = AppError>(error: E) => Result<never, E>;
+//# sourceMappingURL=result.d.ts.map

package/dist/result.js

@@ -0,0 +1,9 @@
+export const ok = (data) => ({
+    ok: true,
+    data,
+});
+export const err = (error) => ({
+    ok: false,
+    error,
+});
+//# sourceMappingURL=result.js.map

package/dist/schemas/access-token.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+export declare const accessTokenSchema: z.ZodObject<{
+    id: z.ZodString;
+    userId: z.ZodString;
+    appId: z.ZodString;
+    tokenHash: z.ZodString;
+    budgetLimit: z.ZodNumber;
+    budgetSpent: z.ZodDefault<z.ZodNumber>;
+    isRevoked: z.ZodDefault<z.ZodBoolean>;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type AccessToken = z.infer<typeof accessTokenSchema>;
+export declare const authorizeAppRequest: z.ZodObject<{
+    appId: z.ZodString;
+    budgetLimit: z.ZodNumber;
+}, z.core.$strip>;
+export type AuthorizeAppRequest = z.infer<typeof authorizeAppRequest>;
+export declare const updateConnectionRequest: z.ZodObject<{
+    budgetLimit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type UpdateConnectionRequest = z.infer<typeof updateConnectionRequest>;
+export declare const connectionResponse: z.ZodObject<{
+    id: z.ZodString;
+    createdAt: z.ZodString;
+    userId: z.ZodString;
+    appId: z.ZodString;
+    budgetLimit: z.ZodNumber;
+    budgetSpent: z.ZodDefault<z.ZodNumber>;
+    isRevoked: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ConnectionResponse = z.infer<typeof connectionResponse>;
+//# sourceMappingURL=access-token.d.ts.map

package/dist/schemas/access-token.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+export const accessTokenSchema = z.object({
+    id: z.string().uuid(),
+    userId: z.string().uuid(),
+    appId: z.string().uuid(),
+    tokenHash: z.string(),
+    budgetLimit: z.number().positive(),
+    budgetSpent: z.number().default(0),
+    isRevoked: z.boolean().default(false),
+    createdAt: z.string().datetime(),
+});
+export const authorizeAppRequest = z.object({
+    appId: z.string().uuid(),
+    budgetLimit: z.number().positive(),
+});
+export const updateConnectionRequest = z.object({
+    budgetLimit: z.number().positive().optional(),
+});
+export const connectionResponse = accessTokenSchema.omit({ tokenHash: true });
+//# sourceMappingURL=access-token.js.map

package/dist/schemas/account-invitation.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+export declare const accountInvitationSchema: z.ZodObject<{
+    id: z.ZodString;
+    accountId: z.ZodString;
+    email: z.ZodString;
+    role: z.ZodEnum<{
+        owner: "owner";
+        member: "member";
+    }>;
+    invitedByUserId: z.ZodString;
+    expiresAt: z.ZodString;
+    acceptedAt: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type AccountInvitation = z.infer<typeof accountInvitationSchema>;
+export declare const createInvitationRequest: z.ZodObject<{
+    email: z.ZodString;
+    role: z.ZodDefault<z.ZodEnum<{
+        owner: "owner";
+        member: "member";
+    }>>;
+}, z.core.$strip>;
+export type CreateInvitationRequest = z.infer<typeof createInvitationRequest>;
+export declare const invitationWithClaimUrl: z.ZodObject<{
+    id: z.ZodString;
+    accountId: z.ZodString;
+    email: z.ZodString;
+    role: z.ZodEnum<{
+        owner: "owner";
+        member: "member";
+    }>;
+    invitedByUserId: z.ZodString;
+    expiresAt: z.ZodString;
+    acceptedAt: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+    claimUrl: z.ZodString;
+}, z.core.$strip>;
+export type InvitationWithClaimUrl = z.infer<typeof invitationWithClaimUrl>;
+//# sourceMappingURL=account-invitation.d.ts.map

package/dist/schemas/account-invitation.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { accountRoleSchema } from './account-member.js';
+export const accountInvitationSchema = z.object({
+    id: z.string().uuid(),
+    accountId: z.string().uuid(),
+    email: z.string().email(),
+    role: accountRoleSchema,
+    invitedByUserId: z.string().uuid(),
+    expiresAt: z.string().datetime(),
+    acceptedAt: z.string().datetime().nullable(),
+    createdAt: z.string().datetime(),
+});
+export const createInvitationRequest = z.object({
+    email: z.string().email(),
+    role: accountRoleSchema.default('member'),
+});
+export const invitationWithClaimUrl = accountInvitationSchema.extend({
+    claimUrl: z.string().url(),
+});
+//# sourceMappingURL=account-invitation.js.map

package/dist/schemas/account-member.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export declare const accountRoleSchema: z.ZodEnum<{
+    owner: "owner";
+    member: "member";
+}>;
+export type AccountRole = z.infer<typeof accountRoleSchema>;
+export declare const accountMemberSchema: z.ZodObject<{
+    accountId: z.ZodString;
+    userId: z.ZodString;
+    role: z.ZodEnum<{
+        owner: "owner";
+        member: "member";
+    }>;
+    monthlyCapUsd: z.ZodNullable<z.ZodNumber>;
+    joinedAt: z.ZodString;
+}, z.core.$strip>;
+export type AccountMember = z.infer<typeof accountMemberSchema>;
+export declare const hasAtLeastRole: (actual: AccountRole, required: AccountRole) => boolean;
+//# sourceMappingURL=account-member.d.ts.map

package/dist/schemas/account-member.js

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+export const accountRoleSchema = z.enum(['owner', 'member']);
+export const accountMemberSchema = z.object({
+    accountId: z.string().uuid(),
+    userId: z.string().uuid(),
+    role: accountRoleSchema,
+    monthlyCapUsd: z.number().nullable(),
+    joinedAt: z.string().datetime(),
+});
+const roleRank = {
+    member: 0,
+    owner: 1,
+};
+export const hasAtLeastRole = (actual, required) => roleRank[actual] >= roleRank[required];
+//# sourceMappingURL=account-member.js.map

package/dist/schemas/account.d.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+export declare const accountTypeSchema: z.ZodEnum<{
+    personal: "personal";
+    business: "business";
+}>;
+export type AccountType = z.infer<typeof accountTypeSchema>;
+export declare const poolResetPeriodSchema: z.ZodNullable<z.ZodEnum<{
+    monthly: "monthly";
+}>>;
+export type PoolResetPeriod = z.infer<typeof poolResetPeriodSchema>;
+export declare const accountSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+        personal: "personal";
+        business: "business";
+    }>;
+    name: z.ZodString;
+    ownerUserId: z.ZodString;
+    poolBudgetLimitUsd: z.ZodNullable<z.ZodNumber>;
+    poolBudgetSpentUsd: z.ZodDefault<z.ZodNumber>;
+    poolResetPeriod: z.ZodNullable<z.ZodEnum<{
+        monthly: "monthly";
+    }>>;
+    poolLastResetAt: z.ZodNullable<z.ZodString>;
+    deletedAt: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type Account = z.infer<typeof accountSchema>;
+export declare const createAccountRequest: z.ZodObject<{
+    type: z.ZodEnum<{
+        personal: "personal";
+        business: "business";
+    }>;
+    name: z.ZodString;
+}, z.core.$strip>;
+export type CreateAccountRequest = z.infer<typeof createAccountRequest>;
+export declare const updateAccountRequest: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    poolBudgetLimitUsd: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    poolResetPeriod: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        monthly: "monthly";
+    }>>>;
+}, z.core.$strip>;
+export type UpdateAccountRequest = z.infer<typeof updateAccountRequest>;
+//# sourceMappingURL=account.d.ts.map

package/dist/schemas/account.js

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export const accountTypeSchema = z.enum(['personal', 'business']);
+export const poolResetPeriodSchema = z.enum(['monthly']).nullable();
+export const accountSchema = z.object({
+    id: z.string().uuid(),
+    type: accountTypeSchema,
+    name: z.string().min(1).max(100),
+    ownerUserId: z.string().uuid(),
+    poolBudgetLimitUsd: z.number().nullable(),
+    poolBudgetSpentUsd: z.number().default(0),
+    poolResetPeriod: poolResetPeriodSchema,
+    poolLastResetAt: z.string().datetime().nullable(),
+    deletedAt: z.string().datetime().nullable(),
+    createdAt: z.string().datetime(),
+});
+export const createAccountRequest = z.object({
+    type: accountTypeSchema,
+    name: z.string().min(1).max(100),
+});
+export const updateAccountRequest = z.object({
+    name: z.string().min(1).max(100).optional(),
+    poolBudgetLimitUsd: z.number().nonnegative().nullable().optional(),
+    poolResetPeriod: poolResetPeriodSchema.optional(),
+});
+//# sourceMappingURL=account.js.map