import { Result } from "../utils/results.js";
import { KnownErrors } from "../known-errors.js";
import { inlineProductSchema } from "../schema-fields.js";
import { AccessToken, InternalSession, RefreshToken } from "../sessions.js";
import { ProjectPermissionsCrud } from "./crud/project-permissions.js";
import { TeamPermissionsCrud } from "./crud/team-permissions.js";
import { ConnectedAccountAccessTokenCrud, ConnectedAccountCrud } from "./crud/connected-accounts.js";
import { ContactChannelsCrud } from "./crud/contact-channels.js";
import { CurrentUserCrud } from "./crud/current-user.js";
import { ItemCrud } from "./crud/items.js";
import { NotificationPreferenceCrud } from "./crud/notification-preferences.js";
import { OAuthProviderCrud } from "./crud/oauth-providers.js";
import { SessionsCrud } from "./crud/sessions.js";
import { TeamInvitationCrud } from "./crud/team-invitation.js";
import { TeamMemberProfilesCrud } from "./crud/team-member-profiles.js";
import { TeamsCrud } from "./crud/teams.js";
import { ClientInterfaceOptions, StackClientInterface } from "./client-interface.js";
import { TeamMembershipsCrud } from "./crud/team-memberships.js";
import { UsersCrud } from "./crud/users.js";
import * as yup from "yup";

//#region src/interface/server-interface.d.ts
type ServerAuthApplicationOptions = (ClientInterfaceOptions & ({
  readonly secretServerKey: string;
} | {
  readonly projectOwnerSession: InternalSession | (() => Promise<string | null>);
}));
declare class StackServerInterface extends StackClientInterface {
  options: ServerAuthApplicationOptions;
  constructor(options: ServerAuthApplicationOptions);
  protected sendServerRequest(path: string, options: RequestInit, session: InternalSession | null, requestType?: "server" | "admin"): Promise<Response & {
    usedTokens: {
      accessToken: AccessToken;
      refreshToken: RefreshToken | null;
    } | null;
  }>;
  getCustomerBilling(customerType: "user" | "team", customerId: string, session: InternalSession | null): Promise<{
    has_customer: boolean;
    default_payment_method: {
      id: string;
      brand: string | null;
      last4: string | null;
      exp_month: number | null;
      exp_year: number | null;
    } | null;
  }>;
  createCustomerPaymentMethodSetupIntent(customerType: "user" | "team", customerId: string, session: InternalSession | null): Promise<{
    client_secret: string;
    stripe_account_id: string;
  }>;
  setDefaultCustomerPaymentMethodFromSetupIntent(customerType: "user" | "team", customerId: string, setupIntentId: string, session: InternalSession | null): Promise<{
    default_payment_method: {
      id: string;
      brand: string | null;
      last4: string | null;
      exp_month: number | null;
      exp_year: number | null;
    };
  }>;
  protected sendServerRequestAndCatchKnownError<E extends typeof KnownErrors[keyof KnownErrors]>(path: string, requestOptions: RequestInit, tokenStoreOrNull: InternalSession | null, errorsToCatch: readonly E[]): Promise<Result<Response & {
    usedTokens: {
      accessToken: AccessToken;
      refreshToken: RefreshToken | null;
    } | null;
  }, InstanceType<E>>>;
  createServerUser(data: UsersCrud['Server']['Create']): Promise<UsersCrud['Server']['Read']>;
  getServerUserByToken(session: InternalSession): Promise<CurrentUserCrud['Server']['Read'] | null>;
  getServerUserById(userId: string): Promise<Result<UsersCrud['Server']['Read']>>;
  listServerTeamInvitations(options: {
    teamId: string;
  }): Promise<TeamInvitationCrud['Server']['Read'][]>;
  revokeServerTeamInvitation(invitationId: string, teamId: string): Promise<void>;
  listServerTeamMemberProfiles(options: {
    teamId: string;
  }): Promise<TeamMemberProfilesCrud['Server']['Read'][]>;
  getServerTeamMemberProfile(options: {
    teamId: string;
    userId: string;
  }): Promise<TeamMemberProfilesCrud['Client']['Read']>;
  listServerTeamPermissions(options: {
    userId?: string;
    teamId?: string;
    recursive: boolean;
  }, session: InternalSession | null): Promise<TeamPermissionsCrud['Server']['Read'][]>;
  listServerProjectPermissions(options: {
    userId?: string;
    recursive: boolean;
  }, session: InternalSession | null): Promise<ProjectPermissionsCrud['Server']['Read'][]>;
  listServerUsers(options: ({
    cursor?: string;
    limit?: number;
    orderBy?: 'signedUpAt';
    desc?: boolean;
    query?: string;
    includeRestricted?: boolean;
  } & ({
    includeAnonymous?: boolean;
    onlyAnonymous?: false;
  } | {
    includeAnonymous: true;
    onlyAnonymous: true;
  }))): Promise<UsersCrud['Server']['List']>;
  listServerTeams(options?: {
    userId?: string;
  }): Promise<TeamsCrud['Server']['Read'][]>;
  getServerTeam(teamId: string): Promise<TeamsCrud['Server']['Read']>;
  listServerTeamUsers(teamId: string): Promise<UsersCrud['Server']['Read'][]>;
  createServerTeam(data: TeamsCrud['Server']['Create']): Promise<TeamsCrud['Server']['Read']>;
  updateServerTeam(teamId: string, data: TeamsCrud['Server']['Update']): Promise<TeamsCrud['Server']['Read']>;
  deleteServerTeam(teamId: string): Promise<void>;
  addServerUserToTeam(options: {
    userId: string;
    teamId: string;
  }): Promise<TeamMembershipsCrud['Server']['Read']>;
  removeServerUserFromTeam(options: {
    userId: string;
    teamId: string;
  }): Promise<void>;
  listServerUserTeamInvitations(userId: string): Promise<TeamInvitationCrud['Server']['Read'][]>;
  acceptServerTeamInvitationById(invitationId: string, userId: string): Promise<void>;
  updateServerUser(userId: string, update: UsersCrud['Server']['Update']): Promise<UsersCrud['Server']['Read']>;
  createServerProviderAccessToken(userId: string, provider: string, scope: string): Promise<ConnectedAccountAccessTokenCrud['Server']['Read']>;
  /**
   * Get access token for a specific connected account by provider ID and provider account ID.
   * This is the preferred method when dealing with multiple accounts of the same provider.
   */
  createServerProviderAccessTokenByAccount(userId: string, providerId: string, providerAccountId: string, scope: string): Promise<ConnectedAccountAccessTokenCrud['Server']['Read']>;
  /**
   * List all connected accounts for a user.
   */
  listServerConnectedAccounts(userId: string): Promise<ConnectedAccountCrud['Server']['List']>;
  createServerUserSession(userId: string, expiresInMillis: number, isImpersonation: boolean): Promise<{
    accessToken: string;
    refreshToken: string;
  }>;
  leaveServerTeam(options: {
    teamId: string;
    userId: string;
  }): Promise<void>;
  updateServerTeamMemberProfile(options: {
    teamId: string;
    userId: string;
    profile: TeamMemberProfilesCrud['Server']['Update'];
  }): Promise<void>;
  grantServerTeamUserPermission(teamId: string, userId: string, permissionId: string): Promise<void>;
  grantServerProjectPermission(userId: string, permissionId: string): Promise<void>;
  revokeServerTeamUserPermission(teamId: string, userId: string, permissionId: string): Promise<void>;
  revokeServerProjectPermission(userId: string, permissionId: string): Promise<void>;
  deleteServerUser(userId: string): Promise<void>;
  createServerContactChannel(data: ContactChannelsCrud['Server']['Create']): Promise<ContactChannelsCrud['Server']['Read']>;
  updateServerContactChannel(userId: string, contactChannelId: string, data: ContactChannelsCrud['Server']['Update']): Promise<ContactChannelsCrud['Server']['Read']>;
  deleteServerContactChannel(userId: string, contactChannelId: string): Promise<void>;
  listServerContactChannels(userId: string): Promise<ContactChannelsCrud['Server']['Read'][]>;
  listServerNotificationCategories(userId: string): Promise<NotificationPreferenceCrud['Server']['Read'][]>;
  setServerNotificationsEnabled(userId: string, notificationCategoryId: string, enabled: boolean): Promise<void>;
  sendServerContactChannelVerificationEmail(userId: string, contactChannelId: string, callbackUrl: string): Promise<void>;
  listServerSessions(userId: string): Promise<SessionsCrud['Server']['List']>;
  deleteServerSession(sessionId: string): Promise<void>;
  sendServerTeamInvitation(options: {
    email: string;
    teamId: string;
    callbackUrl: string;
  }): Promise<void>;
  updatePassword(options: {
    oldPassword: string;
    newPassword: string;
  }): Promise<KnownErrors["PasswordConfirmationMismatch"] | KnownErrors["PasswordRequirementsNotMet"] | undefined>;
  createServerOAuthProvider(data: OAuthProviderCrud['Server']['Create']): Promise<OAuthProviderCrud['Server']['Read']>;
  listServerOAuthProviders(options?: {
    user_id?: string;
  }): Promise<OAuthProviderCrud['Server']['Read'][]>;
  updateServerOAuthProvider(userId: string, providerId: string, data: OAuthProviderCrud['Server']['Update']): Promise<OAuthProviderCrud['Server']['Read']>;
  deleteServerOAuthProvider(userId: string, providerId: string): Promise<void>;
  sendEmail(options: {
    userIds?: string[];
    allUsers?: true;
    themeId?: string | null | false;
    html?: string;
    subject?: string;
    notificationCategoryName?: string;
    templateId?: string;
    variables?: Record<string, any>;
    draftId?: string;
    scheduledAt?: Date;
  }): Promise<Result<void, KnownErrors["RequiresCustomEmailServer"] | KnownErrors["SchemaError"] | KnownErrors["UserIdDoesNotExist"]>>;
  getEmailDeliveryInfo(): Promise<{
    stats: {
      hour: {
        sent: number;
        bounced: number;
        marked_as_spam: number;
      };
      day: {
        sent: number;
        bounced: number;
        marked_as_spam: number;
      };
      week: {
        sent: number;
        bounced: number;
        marked_as_spam: number;
      };
      month: {
        sent: number;
        bounced: number;
        marked_as_spam: number;
      };
    };
    capacity: {
      rate_per_second: number;
      boost_multiplier: number;
      penalty_factor: number;
      is_boost_active: boolean;
      boost_expires_at: string | null;
    };
  }>;
  activateEmailCapacityBoost(): Promise<{
    expires_at: string;
  }>;
  updateItemQuantity(options: ({
    itemId: string;
    userId: string;
  } | {
    itemId: string;
    teamId: string;
  } | {
    itemId: string;
    customCustomerId: string;
  }), data: ItemCrud['Server']['Update']): Promise<void>;
  grantProduct(options: {
    customerType: "user" | "team" | "custom";
    customerId: string;
    productId?: string;
    product?: yup.InferType<typeof inlineProductSchema>;
    quantity?: number;
  }): Promise<void>;
  getDataVaultStoreValue(secret: string, storeId: string, key: string): Promise<string | null>;
  setDataVaultStoreValue(secret: string, storeId: string, key: string, value: string): Promise<void>;
  initiateServerPasskeyRegistration(userId: string): Promise<Result<{
    options_json: any;
    code: string;
  }, KnownErrors[]>>;
}
//#endregion
export { ServerAuthApplicationOptions, StackServerInterface };
//# sourceMappingURL=server-interface.d.ts.map