import { n as Result } from "./results-DP3BzoL6.js";
import { a as KnownErrors } from "./known-errors-C-1Klj6h.js";
import { Z as inlineProductSchema } from "./schema-fields-Din3rFg5.js";
import { i as RefreshToken, r as InternalSession, t as AccessToken } from "./sessions-DofA-1Lc.js";
import { n as ProjectPermissionsCrud } from "./project-permissions-kdi675F-.js";
import { n as TeamPermissionsCrud } from "./team-permissions-DqOpaOWh.js";
import { n as ConnectedAccountCrud, t as ConnectedAccountAccessTokenCrud } from "./connected-accounts-D5CKe50A.js";
import { t as ContactChannelsCrud } from "./contact-channels-DW8yQxlc.js";
import { t as CurrentUserCrud } from "./current-user-CflrSNFF.js";
import { t as ItemCrud } from "./items-DlLSlVUD.js";
import { t as NotificationPreferenceCrud } from "./notification-preferences-Bmzr_EOY.js";
import { t as OAuthProviderCrud } from "./oauth-providers-BMkKSSlA.js";
import { t as SessionsCrud } from "./sessions-B7Ko2Ldr.js";
import { t as TeamInvitationCrud } from "./team-invitation-Cyqt9oWw.js";
import { t as TeamMemberProfilesCrud } from "./team-member-profiles-DQ17j6Hg.js";
import { t as TeamsCrud } from "./teams-CQMcBnjM.js";
import { i as HexclaveClientInterface, r as ClientInterfaceOptions } from "./client-interface-DntDnV5l.js";
import { n as AnalyticsQueryResponse, t as AnalyticsQueryOptions } from "./analytics-IjkAsefy.js";
import { a as AdminListSessionReplayChunksResponse, i as AdminListSessionReplayChunksOptions, n as AdminGetSessionReplayChunkEventsResponse, o as AdminListSessionReplaysOptions, r as AdminGetSessionReplayResponse, s as AdminListSessionReplaysResponse, t as AdminGetSessionReplayAllEventsResponse } from "./session-replays-DJ_DzfdJ.js";
import { t as TeamMembershipsCrud } from "./team-memberships-DZHk2A5b.js";
import { n as UsersCrud } from "./users-D-sooDrX.js";
import * as yup$1 from "yup";

//#region src/interface/server-interface.d.ts
type ServerAuthApplicationOptions = (ClientInterfaceOptions & ({
  readonly secretServerKey: string;
} | {
  readonly projectOwnerSession: InternalSession | (() => Promise<string | null>);
}));
declare class HexclaveServerInterface extends HexclaveClientInterface {
  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' | 'lastActiveAt';
    desc?: boolean;
    query?: string;
    excludedEmailDomains?: string[];
    includeRestricted?: boolean;
    teamId?: string;
  } & ({
    includeAnonymous?: boolean;
    onlyAnonymous?: false;
  } | {
    includeAnonymous: true;
    onlyAnonymous: true;
  }))): Promise<UsersCrud['Server']['List']>;
  listServerTeams(options?: {
    userId?: string;
  }): Promise<TeamsCrud['Server']['Read'][]>;
  listServerTeamsPaginated(options?: {
    userId?: string;
    orderBy?: 'createdAt';
    desc?: boolean;
    cursor?: string;
    limit?: number;
    query?: string;
  }): Promise<TeamsCrud['Server']['List']>;
  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;
    emails?: string[];
    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;
  }>;
  queryAnalytics(options: AnalyticsQueryOptions): Promise<AnalyticsQueryResponse>;
  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$1.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[]>>;
  listSessionReplays(params?: AdminListSessionReplaysOptions): Promise<AdminListSessionReplaysResponse>;
  getSessionReplay(sessionReplayId: string): Promise<AdminGetSessionReplayResponse>;
  listSessionReplayChunks(sessionReplayId: string, params?: AdminListSessionReplayChunksOptions): Promise<AdminListSessionReplayChunksResponse>;
  getSessionReplayChunkEvents(sessionReplayId: string, chunkId: string): Promise<AdminGetSessionReplayChunkEventsResponse>;
  getSessionReplayEvents(sessionReplayId: string, options?: {
    offset?: number;
    limit?: number;
  }): Promise<AdminGetSessionReplayAllEventsResponse>;
}
//#endregion
export { ServerAuthApplicationOptions as n, HexclaveServerInterface as t };
//# sourceMappingURL=server-interface-BRumRG5k.d.ts.map