declare function update(data: {
  displayName?: string;
  clientMetadata?: Json;
  selectedTeamId?: string | null;
  profileImageUrl?: string | null;
}): Promise<void>;

await user.update({
  displayName: "New Display Name",
  clientMetadata: {
    address: "123 Main St",
  },
});

declare function getTeam(id: string): Promise<Team | null>;

const team = await user.getTeam("teamId");

declare function useTeam(id: string): Team | null;

const team = user.useTeam("teamId");

declare function listTeams(): Promise<Team[]>;

const teams = await user.listTeams();

declare function useTeams(): Team[];

const teams = user.useTeams();

declare function setSelectedTeam(team: Team | null): Promise<void>;

const team = await user.getTeam("team_id_123");
await user.setSelectedTeam(team);

declare function createTeam(data: {
  displayName: string;
  profileImageUrl?: string | null;
}): Promise<Team>;

const team = await user.createTeam({
  displayName: "New Team",
  profileImageUrl: "https://example.com/profile.jpg",
});

declare function leaveTeam(team: Team): Promise<void>;

await user.leaveTeam(team);

declare function getTeamProfile(team: Team): Promise<EditableTeamMemberProfile>;

const profile = await user.getTeamProfile(team);

declare function useTeamProfile(team: Team): EditableTeamMemberProfile;

const profile = user.useTeamProfile(team);

declare function hasPermission(scope: Team, permissionId: string): Promise<boolean>;

const hasPermission = await user.hasPermission(team, "permissionId");

declare function getPermission(scope: Team, permissionId: string, options?: { recursive?: boolean }): Promise<TeamPermission | null>;

const permission = await user.getPermission(team, "read_secret_info");

declare function usePermission(scope: Team, permissionId: string, options?: { recursive?: boolean }): TeamPermission | null;

const permission = user.usePermission(team, "read_secret_info");

declare function listPermissions(scope: Team, options?: { recursive?: boolean }): Promise<TeamPermission[]>;

const permissions = await user.listPermissions(team);

declare function usePermissions(scope: Team, options?: { recursive?: boolean }): TeamPermission[];

const permissions = user.usePermissions(team);

declare function listContactChannels(): Promise<ContactChannel[]>;

const contactChannels = await user.listContactChannels();

declare function useContactChannels(): ContactChannel[];

const contactChannels = user.useContactChannels();

declare function createApiKey(options: {
  description: string;
  expiresAt: Date | null;
  isPublic?: boolean;
}): Promise<UserApiKeyFirstView>;

const apiKey = await user.createApiKey({
  description: "Backend integration",
  expiresAt: new Date(Date.now() + 90 * 24 * 60 * 60 * 1000), // 90 days
  isPublic: false,
});

// Save the API key value securely, as it won't be retrievable later
console.log("API Key:", apiKey.value);

declare function listApiKeys(): Promise<UserApiKey[]>;

const apiKeys = await user.listApiKeys();
console.log(`You have ${apiKeys.length} API keys`);

// Find keys that are about to expire
const soonToExpire = apiKeys.filter(key => 
  key.expiresAt && key.expiresAt.getTime() - Date.now() < 7 * 24 * 60 * 60 * 1000
);

declare function useApiKeys(): UserApiKey[];

function ApiKeysList() {
  const user = useUser();
  const apiKeys = user.useApiKeys();
  
  return (
    <div>
      <h2>Your API Keys ({apiKeys.length})</h2>
      <ul>
        {apiKeys.map(key => (
          <li key={key.id}>
            {key.description} - Last four: {key.value.lastFour}
            {key.isValid() ? ' (valid)' : ` (invalid: ${key.whyInvalid()})`}
          </li>
        ))}
      </ul>
    </div>
  );
}

declare function updatePassword(data: {
  oldPassword: string;
  newPassword: string;
}): Promise<void>;

const result = await user.updatePassword({
  oldPassword: "currentPassword",
  newPassword: "newPassword",
});
if (result.status === "error") {
  console.error("Error updating password", result.error);
} else {
  console.log("Password updated");
}

declare function getAuthHeaders(): Promise<Record<string, string>>;

// client
const res = await fetch("https://api.example.com", {
  headers: {
    ...await stackApp.getAuthHeaders()
    // you can also add your own headers here
  },
});

// server
function handleRequest(req: Request) {
  const user = await stackServerApp.getUser({ tokenStore: req });
  return new Response("Welcome, " + user.displayName);
}

declare function getAuthJson(): Promise<{ accessToken: string | null }>;

// client
const res = await rpcCall(rpcEndpoint, {
  data: {
    auth: await stackApp.getAuthJson(),
  },
});

// server
function handleRequest(data) {
  const user = await stackServerApp.getUser({ tokenStore: data.auth });
  return new Response("Welcome, " + user.displayName);
}

declare function signOut(options?: { redirectUrl?: string }): Promise<void>;

await user.signOut();

declare function delete(): Promise<void>;

await user.delete();

declare function update(data: {
  displayName?: string;
  profileImageUrl?: string | null;
  primaryEmail?: string,
  primaryEmailVerified?: boolean,
  primaryEmailAuthEnabled?: boolean,
  password?: string;
  selectedTeamId?: string | null;
  clientMetadata?: Json;
  clientReadOnlyMetadata?: Json;
  serverMetadata?: Json;
}): Promise<void>;

await serverUser.update({
  displayName: "Updated Display Name",
  password: "newSecurePassword",
  serverMetadata: {
    internalNote: "Confidential information",
  },
});

declare function listContactChannels(): Promise<ServerContactChannel[]>;

const contactChannels = await serverUser.listContactChannels();

declare function grantPermission(scope: Team, permissionId: string): Promise<void>;

await serverUser.grantPermission(team, "read_secret_info");

declare function revokePermission(scope: Team, permissionId: string): Promise<void>;

await serverUser.revokePermission(team, "read_secret_info");

declare function createApiKey(options: {
  description: string;
  expiresAt: Date | null;
  isPublic?: boolean;
}): Promise<UserApiKeyFirstView>;

const apiKey = await serverUser.createApiKey({
  description: "Backend integration",
  expiresAt: new Date(Date.now() + 90 * 24 * 60 * 60 * 1000), // 90 days
  isPublic: false,
});

// Save the API key value securely, as it won't be retrievable later
console.log("API Key:", apiKey.value);

declare function listApiKeys(): Promise<UserApiKey[]>;

const apiKeys = await serverUser.listApiKeys();
console.log(`You have ${apiKeys.length} API keys`);

// Find keys that are about to expire
const soonToExpire = apiKeys.filter(key => 
  key.expiresAt && key.expiresAt.getTime() - Date.now() < 7 * 24 * 60 * 60 * 1000
);

declare function useApiKeys(): UserApiKey[];

function ApiKeysList() {
  const user = useUser();
  const apiKeys = user.useApiKeys();
  
  return (
    <div>
      <h2>Your API Keys ({apiKeys.length})</h2>
      <ul>
        {apiKeys.map(key => (
          <li key={key.id}>
            {key.description} - Last four: {key.value.lastFour}
            {key.isValid() ? ' (valid)' : ` (invalid: ${key.whyInvalid()})`}
          </li>
        ))}
      </ul>
    </div>
  );
}

declare function createCheckoutUrl(options: {
  productId: string;
}): Promise<string>;

const checkoutUrl = await user.createCheckoutUrl({
  productId: "prod_premium_plan",
});

// Redirect user to checkout
window.location.href = checkoutUrl;

declare function getItem(itemId: string): Promise<Item>;

const credits = await user.getItem("credits");
console.log(`User has ${credits.quantity} credits`);
console.log(`Non-negative quantity: ${credits.nonNegativeQuantity}`);

declare function useItem(itemId: string): Item;

function CreditsDisplay() {
  const user = useUser();
  const credits = user.useItem("credits");
  
  return (
    <div>
      <h3>Available Credits: {credits.quantity}</h3>
      <p>Display Name: {credits.displayName}</p>
    </div>
  );
}