@workos-inc/widgets 1.4.1 → 1.4.2

package/dist/cjs/api/endpoint.d.ts

@@ -0,0 +1,1300 @@
+import type { DataTag, DefinedInitialDataOptions, DefinedUseQueryResult, QueryKey, UndefinedInitialDataOptions, UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult } from "@tanstack/react-query";
+import type { ErrorType, BodyType } from "./widgets-api-client.js";
+export declare const MemberStatus: {
+    readonly Active: "Active";
+    readonly Invited: "Invited";
+    readonly InviteExpired: "InviteExpired";
+    readonly InviteRevoked: "InviteRevoked";
+    readonly NoInvite: "NoInvite";
+};
+export type MemberStatus = (typeof MemberStatus)[keyof typeof MemberStatus];
+export declare const MemberActionsItem: {
+    readonly "edit-role": "edit-role";
+    readonly "resend-invite": "resend-invite";
+    readonly "revoke-invite": "revoke-invite";
+    readonly "revoke-membership": "revoke-membership";
+};
+export type MemberActions = (typeof MemberActionsItem)[keyof typeof MemberActionsItem][];
+export type MemberRolesItem = {
+    name: string;
+    slug: string;
+    /** @nullable */
+    description?: string | null;
+};
+export interface Member {
+    id: string;
+    email: string;
+    emailVerified: boolean;
+    /** @nullable */
+    profilePictureUrl?: string | null;
+    /** @nullable */
+    firstName?: string | null;
+    /** @nullable */
+    lastName?: string | null;
+    createdAt: string;
+    /** @nullable */
+    lastActivityAt?: string | null;
+    status: MemberStatus;
+    actions: MemberActions;
+    /** @nullable */
+    isLoggedInUser?: boolean | null;
+    /** @nullable */
+    roles?: MemberRolesItem[] | null;
+}
+export interface ListMetadata {
+    /** @nullable */
+    before?: string | null;
+    /** @nullable */
+    after?: string | null;
+}
+export interface MemberRole {
+    name: string;
+    slug: string;
+    default: boolean;
+    /** @nullable */
+    description?: string | null;
+}
+export interface RolesAndConfigResponse {
+    roles: MemberRole[];
+    multipleRolesEnabled: boolean;
+}
+export interface OrganizationInfo {
+    id: string;
+    name: string;
+    current: boolean;
+    /** @nullable */
+    favicon?: string | null;
+}
+export interface OrganizationsResponse {
+    data: OrganizationInfo[];
+}
+export interface OAuthProfile {
+    id: string;
+    /** @nullable */
+    email?: string | null;
+    /** @nullable */
+    firstName?: string | null;
+    /** @nullable */
+    lastName?: string | null;
+    /** @nullable */
+    profilePictureUrl?: string | null;
+    /** @nullable */
+    lastLoginAt?: string | null;
+}
+/**
+ * @nullable
+ */
+export type MeOauthProfiles = {
+    AppleOAuth?: OAuthProfile;
+    GithubOAuth?: OAuthProfile;
+    GoogleOAuth?: OAuthProfile;
+    MicrosoftOAuth?: OAuthProfile;
+} | null;
+export interface Me {
+    id: string;
+    email: string;
+    /** @nullable */
+    firstName?: string | null;
+    /** @nullable */
+    lastName?: string | null;
+    /** @nullable */
+    profilePictureUrl?: string | null;
+    /** @nullable */
+    oauthProfiles?: MeOauthProfiles;
+}
+export type CreateTotpFactorResponseAuthenticationFactorAllOfObject = (typeof CreateTotpFactorResponseAuthenticationFactorAllOfObject)[keyof typeof CreateTotpFactorResponseAuthenticationFactorAllOfObject];
+export declare const CreateTotpFactorResponseAuthenticationFactorAllOfObject: {
+    readonly authentication_factor: "authentication_factor";
+};
+export type CreateTotpFactorResponseAuthenticationFactorAllOfType = (typeof CreateTotpFactorResponseAuthenticationFactorAllOfType)[keyof typeof CreateTotpFactorResponseAuthenticationFactorAllOfType];
+export declare const CreateTotpFactorResponseAuthenticationFactorAllOfType: {
+    readonly generic_otp: "generic_otp";
+    readonly sms: "sms";
+    readonly totp: "totp";
+    readonly webauthn: "webauthn";
+};
+/**
+ * @nullable
+ */
+export type CreateTotpFactorResponseAuthenticationFactorAllOfSms = {
+    phone_number: string;
+} | null;
+/**
+ * @nullable
+ */
+export type CreateTotpFactorResponseAuthenticationFactorAllOfTotpAnyOf = {
+    issuer: string;
+    user: string;
+    secret: string;
+    qr_code: string;
+    uri: string;
+} | null;
+/**
+ * @nullable
+ */
+export type CreateTotpFactorResponseAuthenticationFactorAllOfTotpAnyOfTwo = {
+    issuer: string;
+    user: string;
+} | null;
+export type CreateTotpFactorResponseAuthenticationFactorAllOfTotp = CreateTotpFactorResponseAuthenticationFactorAllOfTotpAnyOf | CreateTotpFactorResponseAuthenticationFactorAllOfTotpAnyOfTwo;
+export type CreateTotpFactorResponseAuthenticationFactorAllOf = {
+    object: CreateTotpFactorResponseAuthenticationFactorAllOfObject;
+    id: string;
+    type: CreateTotpFactorResponseAuthenticationFactorAllOfType;
+    /** @nullable */
+    user_id?: string | null;
+    /** @nullable */
+    sms?: CreateTotpFactorResponseAuthenticationFactorAllOfSms;
+    totp?: CreateTotpFactorResponseAuthenticationFactorAllOfTotp;
+};
+export type CreateTotpFactorResponseAuthenticationFactorAllOfEight = {
+    created_at: string;
+    updated_at: string;
+};
+export type CreateTotpFactorResponseAuthenticationFactor = CreateTotpFactorResponseAuthenticationFactorAllOf & CreateTotpFactorResponseAuthenticationFactorAllOfEight & Required<Pick<CreateTotpFactorResponseAuthenticationFactorAllOf & CreateTotpFactorResponseAuthenticationFactorAllOfEight, "object" | "id" | "type" | "created_at" | "updated_at">>;
+export type CreateTotpFactorResponseAuthenticationChallengeAllOfObject = (typeof CreateTotpFactorResponseAuthenticationChallengeAllOfObject)[keyof typeof CreateTotpFactorResponseAuthenticationChallengeAllOfObject];
+export declare const CreateTotpFactorResponseAuthenticationChallengeAllOfObject: {
+    readonly authentication_challenge: "authentication_challenge";
+};
+export type CreateTotpFactorResponseAuthenticationChallengeAllOf = {
+    object: CreateTotpFactorResponseAuthenticationChallengeAllOfObject;
+    id: string;
+    /** @nullable */
+    expires_at?: string | null;
+    /** @nullable */
+    code?: string | null;
+    authentication_factor_id: string;
+};
+export type CreateTotpFactorResponseAuthenticationChallengeAllOfThree = {
+    created_at: string;
+    updated_at: string;
+};
+export type CreateTotpFactorResponseAuthenticationChallenge = CreateTotpFactorResponseAuthenticationChallengeAllOf & CreateTotpFactorResponseAuthenticationChallengeAllOfThree & Required<Pick<CreateTotpFactorResponseAuthenticationChallengeAllOf & CreateTotpFactorResponseAuthenticationChallengeAllOfThree, "object" | "id" | "authentication_factor_id" | "created_at" | "updated_at">>;
+export interface CreateTotpFactorResponse {
+    authenticationFactor: CreateTotpFactorResponseAuthenticationFactor;
+    authenticationChallenge: CreateTotpFactorResponseAuthenticationChallenge;
+}
+export interface VerifyTotpFactorRequest {
+    code: string;
+    authenticationChallengeId: string;
+}
+export type AuthenticationInformationResponseDataVerificationMethodsMfaProvider = (typeof AuthenticationInformationResponseDataVerificationMethodsMfaProvider)[keyof typeof AuthenticationInformationResponseDataVerificationMethodsMfaProvider];
+export declare const AuthenticationInformationResponseDataVerificationMethodsMfaProvider: {
+    readonly MFA: "MFA";
+};
+/**
+ * @nullable
+ */
+export type AuthenticationInformationResponseDataVerificationMethodsMfa = {
+    provider: AuthenticationInformationResponseDataVerificationMethodsMfaProvider;
+    isSetUp: boolean;
+    /** @nullable */
+    lastUsed?: string | null;
+} | null;
+export type AuthenticationInformationResponseDataVerificationMethodsPasswordProvider = (typeof AuthenticationInformationResponseDataVerificationMethodsPasswordProvider)[keyof typeof AuthenticationInformationResponseDataVerificationMethodsPasswordProvider];
+export declare const AuthenticationInformationResponseDataVerificationMethodsPasswordProvider: {
+    readonly Password: "Password";
+};
+/**
+ * @nullable
+ */
+export type AuthenticationInformationResponseDataVerificationMethodsPassword = {
+    provider: AuthenticationInformationResponseDataVerificationMethodsPasswordProvider;
+    isSetUp: boolean;
+    /** @nullable */
+    lastUsed?: string | null;
+    isCurrentSession: boolean;
+} | null;
+export type AuthenticationInformationResponseDataVerificationMethodsPasskeyProvider = (typeof AuthenticationInformationResponseDataVerificationMethodsPasskeyProvider)[keyof typeof AuthenticationInformationResponseDataVerificationMethodsPasskeyProvider];
+export declare const AuthenticationInformationResponseDataVerificationMethodsPasskeyProvider: {
+    readonly Passkey: "Passkey";
+};
+export type AuthenticationInformationResponseDataVerificationMethodsPasskeyPassKeysItem = {
+    id: string;
+};
+/**
+ * @nullable
+ */
+export type AuthenticationInformationResponseDataVerificationMethodsPasskey = {
+    provider: AuthenticationInformationResponseDataVerificationMethodsPasskeyProvider;
+    isSetUp: boolean;
+    /** @nullable */
+    lastUsed?: string | null;
+    passKeys: AuthenticationInformationResponseDataVerificationMethodsPasskeyPassKeysItem[];
+    isCurrentSession: boolean;
+} | null;
+export type AuthenticationInformationResponseDataVerificationMethods = {
+    /** @nullable */
+    Mfa?: AuthenticationInformationResponseDataVerificationMethodsMfa;
+    /** @nullable */
+    Password?: AuthenticationInformationResponseDataVerificationMethodsPassword;
+    /** @nullable */
+    Passkey?: AuthenticationInformationResponseDataVerificationMethodsPasskey;
+};
+export type AuthenticationInformationResponseDataPasswordSettings = {
+    isPasswordNumberRequired: boolean;
+    isPasswordPwnedRequired: boolean;
+    isPasswordSymbolRequired: boolean;
+    isPasswordUppercaseRequired: boolean;
+    passwordMinimumLength: number;
+    passwordMinimumStrength: number;
+};
+export type AuthenticationInformationResponseData = {
+    verificationMethods: AuthenticationInformationResponseDataVerificationMethods;
+    passwordSettings: AuthenticationInformationResponseDataPasswordSettings;
+};
+export interface AuthenticationInformationResponse {
+    data: AuthenticationInformationResponseData;
+}
+export interface CreatePasswordRequest {
+    password: string;
+}
+export interface UpdatePasswordRequest {
+    newPassword: string;
+    currentPassword: string;
+}
+export interface RevokeAllSessionsRequest {
+    currentSessionId: string;
+}
+export type ActiveSessionState = {
+    tag: string;
+    /** @nullable */
+    expiresAt?: string | null;
+};
+/**
+ * @nullable
+ */
+export type ActiveSessionCurrentLocation = {
+    cityName: string;
+    countryISOCode: string;
+} | null;
+export interface ActiveSession {
+    id: string;
+    userlandUserId: string;
+    /** @nullable */
+    ipAddress?: string | null;
+    /** @nullable */
+    userAgent?: string | null;
+    /** @nullable */
+    organizationId?: string | null;
+    state: ActiveSessionState;
+    /** @nullable */
+    currentLocation?: ActiveSessionCurrentLocation;
+    usedSsoAuth: boolean;
+    usedPasswordAuth: boolean;
+    usedPasskeyAuth: boolean;
+    usedAppleOauth: boolean;
+    usedBitbucketOauth: boolean;
+    usedGithubOauth: boolean;
+    usedGitLabOauth: boolean;
+    usedGoogleOauth: boolean;
+    usedLinkedInOauth: boolean;
+    usedImpersonation: boolean;
+    usedMicrosoftOauth: boolean;
+    usedSlackOauth: boolean;
+    usedXeroOauth: boolean;
+    usedMagicAuth: boolean;
+    /** @nullable */
+    impersonatorUserId?: string | null;
+    /** @nullable */
+    impersonatorEmail?: string | null;
+    /** @nullable */
+    impersonationReason?: string | null;
+    /** @nullable */
+    lastActivityAt?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ActiveSessionsResponse {
+    data: ActiveSession[];
+}
+export type SendVerificationResponseType = (typeof SendVerificationResponseType)[keyof typeof SendVerificationResponseType];
+export declare const SendVerificationResponseType: {
+    readonly EmailVerification: "EmailVerification";
+};
+export interface SendVerificationResponse {
+    authenticationChallenge: string;
+    type: SendVerificationResponseType;
+}
+export interface VerifyRequest {
+    code: string;
+    authenticationChallengeId: string;
+}
+export interface VerifyResponse {
+    elevatedAccessToken: string;
+    expiresAt: string;
+}
+export type RegisterPasskeyResponseOptions = {
+    [key: string]: unknown;
+};
+export interface RegisterPasskeyResponse {
+    challengeId: string;
+    options: RegisterPasskeyResponseOptions;
+}
+export type VerifyPasskeyRequestResponse = {
+    [key: string]: unknown;
+};
+export interface VerifyPasskeyRequest {
+    challengeId: string;
+    response: VerifyPasskeyRequestResponse;
+}
+export type OrganizationDomainState = (typeof OrganizationDomainState)[keyof typeof OrganizationDomainState];
+export declare const OrganizationDomainState: {
+    readonly Failed: "Failed";
+    readonly LegacyVerified: "LegacyVerified";
+    readonly Pending: "Pending";
+    readonly Verified: "Verified";
+};
+export type DomainVerificationNameServer = (typeof DomainVerificationNameServer)[keyof typeof DomainVerificationNameServer];
+export declare const DomainVerificationNameServer: {
+    readonly AwsRoute53: "AwsRoute53";
+    readonly GoogleDomains: "GoogleDomains";
+    readonly CloudFlare: "CloudFlare";
+    readonly GoDaddy: "GoDaddy";
+    readonly Other: "Other";
+};
+export interface OrganizationDomain {
+    id: string;
+    domain: string;
+    state: OrganizationDomainState;
+    nameServer: DomainVerificationNameServer;
+    /** @nullable */
+    verificationPrefix?: string | null;
+    /** @nullable */
+    verificationToken?: string | null;
+    /** @nullable */
+    subdomain?: string | null;
+    createdAt: string;
+}
+export interface X509CertificateJSON {
+    id: string;
+    value: string;
+    /** @nullable */
+    notBefore?: string | null;
+    /** @nullable */
+    notAfter?: string | null;
+    /** @nullable */
+    lastExpiryEventSentAt?: string | null;
+}
+export type SsoConnectionSessionJSONState = "Started" | "Authorized" | "Successful" | "Failed" | "Terminated";
+export interface SsoConnectionSessionJSON {
+    id: string;
+    createdAt: string;
+    state: SsoConnectionSessionJSONState;
+}
+export type SsoConnectionAnyOfType = (typeof SsoConnectionAnyOfType)[keyof typeof SsoConnectionAnyOfType];
+export declare const SsoConnectionAnyOfType: {
+    readonly AdfsSaml: "AdfsSaml";
+    readonly Auth0Saml: "Auth0Saml";
+    readonly AzureSaml: "AzureSaml";
+    readonly CasSaml: "CasSaml";
+    readonly ClassLinkSaml: "ClassLinkSaml";
+    readonly CloudflareSaml: "CloudflareSaml";
+    readonly CyberArkSaml: "CyberArkSaml";
+    readonly DuoSaml: "DuoSaml";
+    readonly GenericSaml: "GenericSaml";
+    readonly GoogleSaml: "GoogleSaml";
+    readonly JumpCloudSaml: "JumpCloudSaml";
+    readonly KeycloakSaml: "KeycloakSaml";
+    readonly LastPassSaml: "LastPassSaml";
+    readonly MiniOrangeSaml: "MiniOrangeSaml";
+    readonly NetIqSaml: "NetIqSaml";
+    readonly OktaSaml: "OktaSaml";
+    readonly OneLoginSaml: "OneLoginSaml";
+    readonly OracleSaml: "OracleSaml";
+    readonly PingFederateSaml: "PingFederateSaml";
+    readonly PingOneSaml: "PingOneSaml";
+    readonly RipplingSaml: "RipplingSaml";
+    readonly SalesforceSaml: "SalesforceSaml";
+    readonly ShibbolethGenericSaml: "ShibbolethGenericSaml";
+    readonly ShibbolethSaml: "ShibbolethSaml";
+    readonly SimpleSamlPhpSaml: "SimpleSamlPhpSaml";
+    readonly TestIdp: "TestIdp";
+    readonly VmWareSaml: "VmWareSaml";
+};
+export type SsoConnectionAnyOfState = (typeof SsoConnectionAnyOfState)[keyof typeof SsoConnectionAnyOfState];
+export declare const SsoConnectionAnyOfState: {
+    readonly Inactive: "Inactive";
+    readonly Validating: "Validating";
+    readonly Active: "Active";
+    readonly Deleting: "Deleting";
+};
+export type SsoConnectionAnyOfLatestExpiringCertificate = X509CertificateJSON | null;
+export type SsoConnectionAnyOfLatestExpiredCertificate = X509CertificateJSON | null;
+export type SsoConnectionAnyOfProviderTag = (typeof SsoConnectionAnyOfProviderTag)[keyof typeof SsoConnectionAnyOfProviderTag];
+export declare const SsoConnectionAnyOfProviderTag: {
+    readonly Saml: "Saml";
+};
+export type SsoConnectionAnyOfLastSession = SsoConnectionSessionJSON | null;
+export type SsoConnectionAnyOf = {
+    id: string;
+    type: SsoConnectionAnyOfType;
+    name: string;
+    state: SsoConnectionAnyOfState;
+    x509Certificates: X509CertificateJSON[];
+    latestExpiringCertificate?: SsoConnectionAnyOfLatestExpiringCertificate;
+    latestExpiredCertificate?: SsoConnectionAnyOfLatestExpiredCertificate;
+    createdAt: string;
+    providerTag: SsoConnectionAnyOfProviderTag;
+    lastSession?: SsoConnectionAnyOfLastSession;
+};
+export type SsoConnectionAnyOfEightAllOfState = (typeof SsoConnectionAnyOfEightAllOfState)[keyof typeof SsoConnectionAnyOfEightAllOfState];
+export declare const SsoConnectionAnyOfEightAllOfState: {
+    readonly Inactive: "Inactive";
+    readonly Validating: "Validating";
+    readonly Active: "Active";
+    readonly Deleting: "Deleting";
+};
+export type SsoConnectionAnyOfEightAllOfType = (typeof SsoConnectionAnyOfEightAllOfType)[keyof typeof SsoConnectionAnyOfEightAllOfType];
+export declare const SsoConnectionAnyOfEightAllOfType: {
+    readonly AdpOidc: "AdpOidc";
+    readonly Auth0Migration: "Auth0Migration";
+    readonly EntraIdOidc: "EntraIdOidc";
+    readonly GenericOidc: "GenericOidc";
+    readonly GoogleOidc: "GoogleOidc";
+    readonly OktaOidc: "OktaOidc";
+    readonly LoginGovOidc: "LoginGovOidc";
+};
+export type SsoConnectionAnyOfEightAllOfProviderTag = (typeof SsoConnectionAnyOfEightAllOfProviderTag)[keyof typeof SsoConnectionAnyOfEightAllOfProviderTag];
+export declare const SsoConnectionAnyOfEightAllOfProviderTag: {
+    readonly OpenIdConnect: "OpenIdConnect";
+};
+export type SsoConnectionAnyOfEightAllOfLastSession = SsoConnectionSessionJSON | null;
+export type SsoConnectionAnyOfEightAllOf = {
+    id: string;
+    name: string;
+    state: SsoConnectionAnyOfEightAllOfState;
+    type: SsoConnectionAnyOfEightAllOfType;
+    createdAt: string;
+    providerTag: SsoConnectionAnyOfEightAllOfProviderTag;
+    lastSession?: SsoConnectionAnyOfEightAllOfLastSession;
+};
+export type SsoConnectionAnyOfEightAllOfSix = {
+    x509Certificates?: null;
+    latestExpiringCertificate?: null;
+    latestExpiredCertificate?: null;
+};
+export type SsoConnectionAnyOfEight = SsoConnectionAnyOfEightAllOf & SsoConnectionAnyOfEightAllOfSix & Required<Pick<SsoConnectionAnyOfEightAllOf & SsoConnectionAnyOfEightAllOfSix, "id" | "name" | "state" | "type" | "createdAt" | "providerTag">>;
+export type SsoConnection = SsoConnectionAnyOf | SsoConnectionAnyOfEight;
+export type MembersParams = {
+    search?: string;
+    limit?: string;
+    before?: string;
+    after?: string;
+    role?: string;
+};
+export type Members200 = {
+    data: Member[];
+    listMetadata: ListMetadata;
+};
+export type Members403 = {
+    message: string;
+};
+export type Members404 = {
+    message: string;
+};
+export type Roles403 = {
+    message: string;
+};
+export type Roles404 = {
+    message: string;
+};
+export type RolesAndConfig403 = {
+    message: string;
+};
+export type RolesAndConfig404 = {
+    message: string;
+};
+export type InviteMemberInput = {
+    email: string;
+    /** @nullable */
+    firstName?: string | null;
+    /** @nullable */
+    lastName?: string | null;
+    roles: string[];
+};
+export type InviteMember201 = {
+    success: boolean;
+};
+export type InviteMember400 = {
+    message: string;
+};
+export type InviteMember403 = {
+    message: string;
+};
+export type InviteMember404 = {
+    message: string;
+};
+export type ResendInvite201 = {
+    /** @nullable */
+    id?: string | null;
+    success: boolean;
+};
+export type ResendInvite400 = {
+    message: string;
+};
+export type ResendInvite403 = {
+    message: string;
+};
+export type ResendInvite404 = {
+    message: string;
+};
+export type RevokeInvite200 = {
+    id: string;
+    success: boolean;
+};
+export type RevokeInvite400 = {
+    message: string;
+};
+export type RevokeInvite403 = {
+    message: string;
+};
+export type RevokeInvite404 = {
+    message: string;
+};
+export type RemoveMember200 = {
+    id: string;
+    success: boolean;
+};
+export type RemoveMember400 = {
+    message: string;
+};
+export type RemoveMember403 = {
+    message: string;
+};
+export type RemoveMember404 = {
+    message: string;
+};
+export type UpdateMemberInput = {
+    roles: string[];
+};
+export type UpdateMember200 = {
+    id: string;
+    success: boolean;
+};
+export type UpdateMember400 = {
+    message: string;
+};
+export type UpdateMember403 = {
+    message: string;
+};
+export type UpdateMember404 = {
+    message: string;
+};
+export type Organizations403 = {
+    message: string;
+};
+export type Organizations404 = {
+    message: string;
+};
+export type Me403 = {
+    message: string;
+};
+export type UpdateMeInput = {
+    firstName?: string;
+    lastName?: string;
+};
+export type UpdateMe400 = {
+    message: string;
+};
+export type UpdateMe403 = {
+    message: string;
+};
+export type CreateTotpFactor400 = {
+    message: string;
+};
+export type CreateTotpFactor403 = {
+    message: string;
+};
+export type VerifyTotpFactor200 = {
+    success: boolean;
+};
+export type VerifyTotpFactor400 = {
+    message: string;
+};
+export type VerifyTotpFactor403 = {
+    message: string;
+};
+export type DeleteTotpFactors200 = {
+    success: boolean;
+};
+export type DeleteTotpFactors400 = {
+    message: string;
+};
+export type DeleteTotpFactors403 = {
+    message: string;
+};
+export type AuthenticationInformation403 = {
+    message: string;
+};
+export type CreatePassword201 = {
+    success: boolean;
+};
+export type CreatePassword400 = {
+    message: string;
+};
+export type CreatePassword403 = {
+    message: string;
+};
+export type UpdatePassword201 = {
+    success: boolean;
+};
+export type UpdatePassword400 = {
+    message: string;
+};
+export type UpdatePassword403 = {
+    message: string;
+};
+export type RevokeAllSessions200 = {
+    success: boolean;
+};
+export type RevokeAllSessions400 = {
+    message: string;
+};
+export type RevokeAllSessions403 = {
+    message: string;
+};
+export type RevokeSession200 = {
+    success: boolean;
+};
+export type RevokeSession400 = {
+    message: string;
+};
+export type RevokeSession403 = {
+    message: string;
+};
+export type Sessions403 = {
+    message: string;
+};
+export type SendVerification400 = {
+    message: string;
+};
+export type SendVerification403 = {
+    message: string;
+};
+export type Verify400 = {
+    message: string;
+};
+export type Verify403 = {
+    message: string;
+};
+export type RegisterPasskey400 = {
+    message: string;
+};
+export type RegisterPasskey403 = {
+    message: string;
+};
+export type VerifyPasskey200 = {
+    success: boolean;
+};
+export type VerifyPasskey400 = {
+    message: string;
+};
+export type VerifyPasskey403 = {
+    message: string;
+};
+export type DeletePasskey200 = {
+    success: boolean;
+};
+export type DeletePasskey400 = {
+    message: string;
+};
+export type DeletePasskey403 = {
+    message: string;
+};
+export type ListOrganizationDomains200 = {
+    data: OrganizationDomain[];
+};
+export type ListOrganizationDomains403 = {
+    message: string;
+};
+export type ListOrganizationDomains404 = {
+    message: string;
+};
+export type GenerateAdminPortalLinkParams = {
+    intent: GenerateAdminPortalLinkIntent;
+};
+export type GenerateAdminPortalLinkIntent = (typeof GenerateAdminPortalLinkIntent)[keyof typeof GenerateAdminPortalLinkIntent];
+export declare const GenerateAdminPortalLinkIntent: {
+    readonly domain_verification: "domain_verification";
+    readonly sso: "sso";
+};
+export type GenerateAdminPortalLink201 = {
+    link: string;
+};
+export type GenerateAdminPortalLink403 = {
+    message: string;
+};
+export type GenerateAdminPortalLink404 = {
+    message: string;
+};
+export type GenerateAdminPortalLink500 = {
+    message: string;
+};
+export type DeleteOrganizationDomain403 = {
+    message: string;
+};
+export type DeleteOrganizationDomain404 = {
+    message: string;
+};
+export type ReverifyOrganizationDomain403 = {
+    message: string;
+};
+export type ReverifyOrganizationDomain404 = {
+    message: string;
+};
+export declare const useMembersHook: () => (params?: MembersParams, signal?: AbortSignal) => Promise<Members200>;
+export declare const getMembersQueryKey: (params?: MembersParams) => readonly ["/_widgets/UserManagement/members", ...MembersParams[]];
+export declare const useMembersQueryOptions: <TData = Members200, TError = Members403 | Members404>(params?: MembersParams, options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useMembersHook>>>, TError, TData>>;
+}) => UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useMembersHook>>>, TError, TData> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export type MembersQueryResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useMembersHook>>>>;
+export type MembersQueryError = ErrorType<Members403 | Members404>;
+export declare function useMembers<TData = Awaited<ReturnType<ReturnType<typeof useMembersHook>>>, TError = ErrorType<Members403 | Members404>>(params: undefined | MembersParams, options: {
+    query: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useMembersHook>>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<ReturnType<typeof useMembersHook>>>, TError, Awaited<ReturnType<ReturnType<typeof useMembersHook>>>>, "initialData">;
+}): DefinedUseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export declare function useMembers<TData = Awaited<ReturnType<ReturnType<typeof useMembersHook>>>, TError = ErrorType<Members403 | Members404>>(params?: MembersParams, options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useMembersHook>>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<ReturnType<typeof useMembersHook>>>, TError, Awaited<ReturnType<ReturnType<typeof useMembersHook>>>>, "initialData">;
+}): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export declare function useMembers<TData = Awaited<ReturnType<ReturnType<typeof useMembersHook>>>, TError = ErrorType<Members403 | Members404>>(params?: MembersParams, options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useMembersHook>>>, TError, TData>>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export declare const useRolesHook: () => (signal?: AbortSignal) => Promise<MemberRole[]>;
+export declare const getRolesQueryKey: () => readonly ["/_widgets/UserManagement/roles"];
+export declare const useRolesQueryOptions: <TData = MemberRole[], TError = Roles403 | Roles404>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useRolesHook>>>, TError, TData>>;
+}) => UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useRolesHook>>>, TError, TData> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export type RolesQueryResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useRolesHook>>>>;
+export type RolesQueryError = ErrorType<Roles403 | Roles404>;
+export declare function useRoles<TData = Awaited<ReturnType<ReturnType<typeof useRolesHook>>>, TError = ErrorType<Roles403 | Roles404>>(options: {
+    query: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useRolesHook>>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<ReturnType<typeof useRolesHook>>>, TError, Awaited<ReturnType<ReturnType<typeof useRolesHook>>>>, "initialData">;
+}): DefinedUseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export declare function useRoles<TData = Awaited<ReturnType<ReturnType<typeof useRolesHook>>>, TError = ErrorType<Roles403 | Roles404>>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useRolesHook>>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<ReturnType<typeof useRolesHook>>>, TError, Awaited<ReturnType<ReturnType<typeof useRolesHook>>>>, "initialData">;
+}): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export declare function useRoles<TData = Awaited<ReturnType<ReturnType<typeof useRolesHook>>>, TError = ErrorType<Roles403 | Roles404>>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useRolesHook>>>, TError, TData>>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export declare const useRolesAndConfigHook: () => (signal?: AbortSignal) => Promise<RolesAndConfigResponse>;
+export declare const getRolesAndConfigQueryKey: () => readonly ["/_widgets/UserManagement/roles-and-config"];
+export declare const useRolesAndConfigQueryOptions: <TData = RolesAndConfigResponse, TError = RolesAndConfig403 | RolesAndConfig404>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useRolesAndConfigHook>>>, TError, TData>>;
+}) => UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useRolesAndConfigHook>>>, TError, TData> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export type RolesAndConfigQueryResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useRolesAndConfigHook>>>>;
+export type RolesAndConfigQueryError = ErrorType<RolesAndConfig403 | RolesAndConfig404>;
+export declare function useRolesAndConfig<TData = Awaited<ReturnType<ReturnType<typeof useRolesAndConfigHook>>>, TError = ErrorType<RolesAndConfig403 | RolesAndConfig404>>(options: {
+    query: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useRolesAndConfigHook>>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<ReturnType<typeof useRolesAndConfigHook>>>, TError, Awaited<ReturnType<ReturnType<typeof useRolesAndConfigHook>>>>, "initialData">;
+}): DefinedUseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export declare function useRolesAndConfig<TData = Awaited<ReturnType<ReturnType<typeof useRolesAndConfigHook>>>, TError = ErrorType<RolesAndConfig403 | RolesAndConfig404>>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useRolesAndConfigHook>>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<ReturnType<typeof useRolesAndConfigHook>>>, TError, Awaited<ReturnType<ReturnType<typeof useRolesAndConfigHook>>>>, "initialData">;
+}): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export declare function useRolesAndConfig<TData = Awaited<ReturnType<ReturnType<typeof useRolesAndConfigHook>>>, TError = ErrorType<RolesAndConfig403 | RolesAndConfig404>>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useRolesAndConfigHook>>>, TError, TData>>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export declare const useInviteMemberHook: () => (inviteMemberInput: BodyType<InviteMemberInput>, signal?: AbortSignal) => Promise<InviteMember201>;
+export declare const useInviteMemberMutationOptions: <TError = InviteMember400 | InviteMember403 | InviteMember404, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useInviteMemberHook>>>, TError, {
+        data: BodyType<InviteMemberInput>;
+    }, TContext>;
+}) => UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useInviteMemberHook>>>, TError, {
+    data: BodyType<InviteMemberInput>;
+}, TContext>;
+export type InviteMemberMutationResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useInviteMemberHook>>>>;
+export type InviteMemberMutationBody = BodyType<InviteMemberInput>;
+export type InviteMemberMutationError = ErrorType<InviteMember400 | InviteMember403 | InviteMember404>;
+export declare const useInviteMember: <TError = InviteMember400 | InviteMember403 | InviteMember404, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useInviteMemberHook>>>, TError, {
+        data: BodyType<InviteMemberInput>;
+    }, TContext>;
+}) => UseMutationResult<Awaited<ReturnType<ReturnType<typeof useInviteMemberHook>>>, TError, {
+    data: BodyType<InviteMemberInput>;
+}, TContext>;
+export declare const useResendInviteHook: () => (userId: string, signal?: AbortSignal) => Promise<ResendInvite201>;
+export declare const useResendInviteMutationOptions: <TError = ResendInvite400 | ResendInvite403 | ResendInvite404, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useResendInviteHook>>>, TError, {
+        userId: string;
+    }, TContext>;
+}) => UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useResendInviteHook>>>, TError, {
+    userId: string;
+}, TContext>;
+export type ResendInviteMutationResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useResendInviteHook>>>>;
+export type ResendInviteMutationError = ErrorType<ResendInvite400 | ResendInvite403 | ResendInvite404>;
+export declare const useResendInvite: <TError = ResendInvite400 | ResendInvite403 | ResendInvite404, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useResendInviteHook>>>, TError, {
+        userId: string;
+    }, TContext>;
+}) => UseMutationResult<Awaited<ReturnType<ReturnType<typeof useResendInviteHook>>>, TError, {
+    userId: string;
+}, TContext>;
+export declare const useRevokeInviteHook: () => (userId: string) => Promise<RevokeInvite200>;
+export declare const useRevokeInviteMutationOptions: <TError = RevokeInvite400 | RevokeInvite403 | RevokeInvite404, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useRevokeInviteHook>>>, TError, {
+        userId: string;
+    }, TContext>;
+}) => UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useRevokeInviteHook>>>, TError, {
+    userId: string;
+}, TContext>;
+export type RevokeInviteMutationResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useRevokeInviteHook>>>>;
+export type RevokeInviteMutationError = ErrorType<RevokeInvite400 | RevokeInvite403 | RevokeInvite404>;
+export declare const useRevokeInvite: <TError = RevokeInvite400 | RevokeInvite403 | RevokeInvite404, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useRevokeInviteHook>>>, TError, {
+        userId: string;
+    }, TContext>;
+}) => UseMutationResult<Awaited<ReturnType<ReturnType<typeof useRevokeInviteHook>>>, TError, {
+    userId: string;
+}, TContext>;
+export declare const useRemoveMemberHook: () => (userId: string) => Promise<RemoveMember200>;
+export declare const useRemoveMemberMutationOptions: <TError = RemoveMember400 | RemoveMember403 | RemoveMember404, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useRemoveMemberHook>>>, TError, {
+        userId: string;
+    }, TContext>;
+}) => UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useRemoveMemberHook>>>, TError, {
+    userId: string;
+}, TContext>;
+export type RemoveMemberMutationResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useRemoveMemberHook>>>>;
+export type RemoveMemberMutationError = ErrorType<RemoveMember400 | RemoveMember403 | RemoveMember404>;
+export declare const useRemoveMember: <TError = RemoveMember400 | RemoveMember403 | RemoveMember404, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useRemoveMemberHook>>>, TError, {
+        userId: string;
+    }, TContext>;
+}) => UseMutationResult<Awaited<ReturnType<ReturnType<typeof useRemoveMemberHook>>>, TError, {
+    userId: string;
+}, TContext>;
+export declare const useUpdateMemberHook: () => (userId: string, updateMemberInput: BodyType<UpdateMemberInput>, signal?: AbortSignal) => Promise<UpdateMember200>;
+export declare const useUpdateMemberMutationOptions: <TError = UpdateMember400 | UpdateMember403 | UpdateMember404, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useUpdateMemberHook>>>, TError, {
+        userId: string;
+        data: BodyType<UpdateMemberInput>;
+    }, TContext>;
+}) => UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useUpdateMemberHook>>>, TError, {
+    userId: string;
+    data: BodyType<UpdateMemberInput>;
+}, TContext>;
+export type UpdateMemberMutationResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useUpdateMemberHook>>>>;
+export type UpdateMemberMutationBody = BodyType<UpdateMemberInput>;
+export type UpdateMemberMutationError = ErrorType<UpdateMember400 | UpdateMember403 | UpdateMember404>;
+export declare const useUpdateMember: <TError = UpdateMember400 | UpdateMember403 | UpdateMember404, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useUpdateMemberHook>>>, TError, {
+        userId: string;
+        data: BodyType<UpdateMemberInput>;
+    }, TContext>;
+}) => UseMutationResult<Awaited<ReturnType<ReturnType<typeof useUpdateMemberHook>>>, TError, {
+    userId: string;
+    data: BodyType<UpdateMemberInput>;
+}, TContext>;
+export declare const useOrganizationsHook: () => (signal?: AbortSignal) => Promise<OrganizationsResponse>;
+export declare const getOrganizationsQueryKey: () => readonly ["/_widgets/UserManagement/organizations"];
+export declare const useOrganizationsQueryOptions: <TData = OrganizationsResponse, TError = Organizations403 | Organizations404>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useOrganizationsHook>>>, TError, TData>>;
+}) => UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useOrganizationsHook>>>, TError, TData> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export type OrganizationsQueryResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useOrganizationsHook>>>>;
+export type OrganizationsQueryError = ErrorType<Organizations403 | Organizations404>;
+export declare function useOrganizations<TData = Awaited<ReturnType<ReturnType<typeof useOrganizationsHook>>>, TError = ErrorType<Organizations403 | Organizations404>>(options: {
+    query: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useOrganizationsHook>>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<ReturnType<typeof useOrganizationsHook>>>, TError, Awaited<ReturnType<ReturnType<typeof useOrganizationsHook>>>>, "initialData">;
+}): DefinedUseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export declare function useOrganizations<TData = Awaited<ReturnType<ReturnType<typeof useOrganizationsHook>>>, TError = ErrorType<Organizations403 | Organizations404>>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useOrganizationsHook>>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<ReturnType<typeof useOrganizationsHook>>>, TError, Awaited<ReturnType<ReturnType<typeof useOrganizationsHook>>>>, "initialData">;
+}): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export declare function useOrganizations<TData = Awaited<ReturnType<ReturnType<typeof useOrganizationsHook>>>, TError = ErrorType<Organizations403 | Organizations404>>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useOrganizationsHook>>>, TError, TData>>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export declare const useMeHook: () => (signal?: AbortSignal) => Promise<Me>;
+export declare const getMeQueryKey: () => readonly ["/_widgets/UserProfile/me"];
+export declare const useMeQueryOptions: <TData = Me, TError = Me403>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useMeHook>>>, TError, TData>>;
+}) => UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useMeHook>>>, TError, TData> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export type MeQueryResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useMeHook>>>>;
+export type MeQueryError = ErrorType<Me403>;
+export declare function useMe<TData = Awaited<ReturnType<ReturnType<typeof useMeHook>>>, TError = ErrorType<Me403>>(options: {
+    query: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useMeHook>>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<ReturnType<typeof useMeHook>>>, TError, Awaited<ReturnType<ReturnType<typeof useMeHook>>>>, "initialData">;
+}): DefinedUseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export declare function useMe<TData = Awaited<ReturnType<ReturnType<typeof useMeHook>>>, TError = ErrorType<Me403>>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useMeHook>>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<ReturnType<typeof useMeHook>>>, TError, Awaited<ReturnType<ReturnType<typeof useMeHook>>>>, "initialData">;
+}): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export declare function useMe<TData = Awaited<ReturnType<ReturnType<typeof useMeHook>>>, TError = ErrorType<Me403>>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useMeHook>>>, TError, TData>>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export declare const useUpdateMeHook: () => (updateMeInput: BodyType<UpdateMeInput>, signal?: AbortSignal) => Promise<Me>;
+export declare const useUpdateMeMutationOptions: <TError = UpdateMe400 | UpdateMe403, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useUpdateMeHook>>>, TError, {
+        data: BodyType<UpdateMeInput>;
+    }, TContext>;
+}) => UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useUpdateMeHook>>>, TError, {
+    data: BodyType<UpdateMeInput>;
+}, TContext>;
+export type UpdateMeMutationResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useUpdateMeHook>>>>;
+export type UpdateMeMutationBody = BodyType<UpdateMeInput>;
+export type UpdateMeMutationError = ErrorType<UpdateMe400 | UpdateMe403>;
+export declare const useUpdateMe: <TError = UpdateMe400 | UpdateMe403, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useUpdateMeHook>>>, TError, {
+        data: BodyType<UpdateMeInput>;
+    }, TContext>;
+}) => UseMutationResult<Awaited<ReturnType<ReturnType<typeof useUpdateMeHook>>>, TError, {
+    data: BodyType<UpdateMeInput>;
+}, TContext>;
+export declare const useCreateTotpFactorHook: () => (signal?: AbortSignal) => Promise<CreateTotpFactorResponse>;
+export declare const useCreateTotpFactorMutationOptions: <TError = CreateTotpFactor400 | CreateTotpFactor403, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useCreateTotpFactorHook>>>, TError, void, TContext>;
+}) => UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useCreateTotpFactorHook>>>, TError, void, TContext>;
+export type CreateTotpFactorMutationResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useCreateTotpFactorHook>>>>;
+export type CreateTotpFactorMutationError = ErrorType<CreateTotpFactor400 | CreateTotpFactor403>;
+export declare const useCreateTotpFactor: <TError = CreateTotpFactor400 | CreateTotpFactor403, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useCreateTotpFactorHook>>>, TError, void, TContext>;
+}) => UseMutationResult<Awaited<ReturnType<ReturnType<typeof useCreateTotpFactorHook>>>, TError, void, TContext>;
+export declare const useVerifyTotpFactorHook: () => (verifyTotpFactorRequest: BodyType<VerifyTotpFactorRequest>, signal?: AbortSignal) => Promise<VerifyTotpFactor200>;
+export declare const useVerifyTotpFactorMutationOptions: <TError = VerifyTotpFactor400 | VerifyTotpFactor403, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useVerifyTotpFactorHook>>>, TError, {
+        data: BodyType<VerifyTotpFactorRequest>;
+    }, TContext>;
+}) => UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useVerifyTotpFactorHook>>>, TError, {
+    data: BodyType<VerifyTotpFactorRequest>;
+}, TContext>;
+export type VerifyTotpFactorMutationResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useVerifyTotpFactorHook>>>>;
+export type VerifyTotpFactorMutationBody = BodyType<VerifyTotpFactorRequest>;
+export type VerifyTotpFactorMutationError = ErrorType<VerifyTotpFactor400 | VerifyTotpFactor403>;
+export declare const useVerifyTotpFactor: <TError = VerifyTotpFactor400 | VerifyTotpFactor403, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useVerifyTotpFactorHook>>>, TError, {
+        data: BodyType<VerifyTotpFactorRequest>;
+    }, TContext>;
+}) => UseMutationResult<Awaited<ReturnType<ReturnType<typeof useVerifyTotpFactorHook>>>, TError, {
+    data: BodyType<VerifyTotpFactorRequest>;
+}, TContext>;
+export declare const useDeleteTotpFactorsHook: () => () => Promise<DeleteTotpFactors200>;
+export declare const useDeleteTotpFactorsMutationOptions: <TError = DeleteTotpFactors400 | DeleteTotpFactors403, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useDeleteTotpFactorsHook>>>, TError, void, TContext>;
+}) => UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useDeleteTotpFactorsHook>>>, TError, void, TContext>;
+export type DeleteTotpFactorsMutationResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useDeleteTotpFactorsHook>>>>;
+export type DeleteTotpFactorsMutationError = ErrorType<DeleteTotpFactors400 | DeleteTotpFactors403>;
+export declare const useDeleteTotpFactors: <TError = DeleteTotpFactors400 | DeleteTotpFactors403, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useDeleteTotpFactorsHook>>>, TError, void, TContext>;
+}) => UseMutationResult<Awaited<ReturnType<ReturnType<typeof useDeleteTotpFactorsHook>>>, TError, void, TContext>;
+export declare const useAuthenticationInformationHook: () => (signal?: AbortSignal) => Promise<AuthenticationInformationResponse>;
+export declare const getAuthenticationInformationQueryKey: () => readonly ["/_widgets/UserProfile/authentication-information"];
+export declare const useAuthenticationInformationQueryOptions: <TData = AuthenticationInformationResponse, TError = AuthenticationInformation403>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useAuthenticationInformationHook>>>, TError, TData>>;
+}) => UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useAuthenticationInformationHook>>>, TError, TData> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export type AuthenticationInformationQueryResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useAuthenticationInformationHook>>>>;
+export type AuthenticationInformationQueryError = ErrorType<AuthenticationInformation403>;
+export declare function useAuthenticationInformation<TData = Awaited<ReturnType<ReturnType<typeof useAuthenticationInformationHook>>>, TError = ErrorType<AuthenticationInformation403>>(options: {
+    query: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useAuthenticationInformationHook>>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<ReturnType<typeof useAuthenticationInformationHook>>>, TError, Awaited<ReturnType<ReturnType<typeof useAuthenticationInformationHook>>>>, "initialData">;
+}): DefinedUseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export declare function useAuthenticationInformation<TData = Awaited<ReturnType<ReturnType<typeof useAuthenticationInformationHook>>>, TError = ErrorType<AuthenticationInformation403>>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useAuthenticationInformationHook>>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<ReturnType<typeof useAuthenticationInformationHook>>>, TError, Awaited<ReturnType<ReturnType<typeof useAuthenticationInformationHook>>>>, "initialData">;
+}): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export declare function useAuthenticationInformation<TData = Awaited<ReturnType<ReturnType<typeof useAuthenticationInformationHook>>>, TError = ErrorType<AuthenticationInformation403>>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useAuthenticationInformationHook>>>, TError, TData>>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export declare const useCreatePasswordHook: () => (createPasswordRequest: BodyType<CreatePasswordRequest>, signal?: AbortSignal) => Promise<CreatePassword201>;
+export declare const useCreatePasswordMutationOptions: <TError = CreatePassword400 | CreatePassword403, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useCreatePasswordHook>>>, TError, {
+        data: BodyType<CreatePasswordRequest>;
+    }, TContext>;
+}) => UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useCreatePasswordHook>>>, TError, {
+    data: BodyType<CreatePasswordRequest>;
+}, TContext>;
+export type CreatePasswordMutationResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useCreatePasswordHook>>>>;
+export type CreatePasswordMutationBody = BodyType<CreatePasswordRequest>;
+export type CreatePasswordMutationError = ErrorType<CreatePassword400 | CreatePassword403>;
+export declare const useCreatePassword: <TError = CreatePassword400 | CreatePassword403, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useCreatePasswordHook>>>, TError, {
+        data: BodyType<CreatePasswordRequest>;
+    }, TContext>;
+}) => UseMutationResult<Awaited<ReturnType<ReturnType<typeof useCreatePasswordHook>>>, TError, {
+    data: BodyType<CreatePasswordRequest>;
+}, TContext>;
+export declare const useUpdatePasswordHook: () => (updatePasswordRequest: BodyType<UpdatePasswordRequest>, signal?: AbortSignal) => Promise<UpdatePassword201>;
+export declare const useUpdatePasswordMutationOptions: <TError = UpdatePassword400 | UpdatePassword403, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useUpdatePasswordHook>>>, TError, {
+        data: BodyType<UpdatePasswordRequest>;
+    }, TContext>;
+}) => UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useUpdatePasswordHook>>>, TError, {
+    data: BodyType<UpdatePasswordRequest>;
+}, TContext>;
+export type UpdatePasswordMutationResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useUpdatePasswordHook>>>>;
+export type UpdatePasswordMutationBody = BodyType<UpdatePasswordRequest>;
+export type UpdatePasswordMutationError = ErrorType<UpdatePassword400 | UpdatePassword403>;
+export declare const useUpdatePassword: <TError = UpdatePassword400 | UpdatePassword403, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useUpdatePasswordHook>>>, TError, {
+        data: BodyType<UpdatePasswordRequest>;
+    }, TContext>;
+}) => UseMutationResult<Awaited<ReturnType<ReturnType<typeof useUpdatePasswordHook>>>, TError, {
+    data: BodyType<UpdatePasswordRequest>;
+}, TContext>;
+export declare const useRevokeAllSessionsHook: () => (revokeAllSessionsRequest: BodyType<RevokeAllSessionsRequest>) => Promise<RevokeAllSessions200>;
+export declare const useRevokeAllSessionsMutationOptions: <TError = RevokeAllSessions400 | RevokeAllSessions403, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useRevokeAllSessionsHook>>>, TError, {
+        data: BodyType<RevokeAllSessionsRequest>;
+    }, TContext>;
+}) => UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useRevokeAllSessionsHook>>>, TError, {
+    data: BodyType<RevokeAllSessionsRequest>;
+}, TContext>;
+export type RevokeAllSessionsMutationResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useRevokeAllSessionsHook>>>>;
+export type RevokeAllSessionsMutationBody = BodyType<RevokeAllSessionsRequest>;
+export type RevokeAllSessionsMutationError = ErrorType<RevokeAllSessions400 | RevokeAllSessions403>;
+export declare const useRevokeAllSessions: <TError = RevokeAllSessions400 | RevokeAllSessions403, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useRevokeAllSessionsHook>>>, TError, {
+        data: BodyType<RevokeAllSessionsRequest>;
+    }, TContext>;
+}) => UseMutationResult<Awaited<ReturnType<ReturnType<typeof useRevokeAllSessionsHook>>>, TError, {
+    data: BodyType<RevokeAllSessionsRequest>;
+}, TContext>;
+export declare const useRevokeSessionHook: () => (sessionId: string) => Promise<RevokeSession200>;
+export declare const useRevokeSessionMutationOptions: <TError = RevokeSession400 | RevokeSession403, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useRevokeSessionHook>>>, TError, {
+        sessionId: string;
+    }, TContext>;
+}) => UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useRevokeSessionHook>>>, TError, {
+    sessionId: string;
+}, TContext>;
+export type RevokeSessionMutationResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useRevokeSessionHook>>>>;
+export type RevokeSessionMutationError = ErrorType<RevokeSession400 | RevokeSession403>;
+export declare const useRevokeSession: <TError = RevokeSession400 | RevokeSession403, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useRevokeSessionHook>>>, TError, {
+        sessionId: string;
+    }, TContext>;
+}) => UseMutationResult<Awaited<ReturnType<ReturnType<typeof useRevokeSessionHook>>>, TError, {
+    sessionId: string;
+}, TContext>;
+export declare const useSessionsHook: () => (signal?: AbortSignal) => Promise<ActiveSessionsResponse>;
+export declare const getSessionsQueryKey: () => readonly ["/_widgets/UserProfile/sessions"];
+export declare const useSessionsQueryOptions: <TData = ActiveSessionsResponse, TError = Sessions403>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useSessionsHook>>>, TError, TData>>;
+}) => UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useSessionsHook>>>, TError, TData> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export type SessionsQueryResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useSessionsHook>>>>;
+export type SessionsQueryError = ErrorType<Sessions403>;
+export declare function useSessions<TData = Awaited<ReturnType<ReturnType<typeof useSessionsHook>>>, TError = ErrorType<Sessions403>>(options: {
+    query: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useSessionsHook>>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<ReturnType<typeof useSessionsHook>>>, TError, Awaited<ReturnType<ReturnType<typeof useSessionsHook>>>>, "initialData">;
+}): DefinedUseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export declare function useSessions<TData = Awaited<ReturnType<ReturnType<typeof useSessionsHook>>>, TError = ErrorType<Sessions403>>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useSessionsHook>>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<ReturnType<typeof useSessionsHook>>>, TError, Awaited<ReturnType<ReturnType<typeof useSessionsHook>>>>, "initialData">;
+}): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export declare function useSessions<TData = Awaited<ReturnType<ReturnType<typeof useSessionsHook>>>, TError = ErrorType<Sessions403>>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useSessionsHook>>>, TError, TData>>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export declare const useSendVerificationHook: () => (signal?: AbortSignal) => Promise<SendVerificationResponse>;
+export declare const useSendVerificationMutationOptions: <TError = SendVerification400 | SendVerification403, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useSendVerificationHook>>>, TError, void, TContext>;
+}) => UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useSendVerificationHook>>>, TError, void, TContext>;
+export type SendVerificationMutationResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useSendVerificationHook>>>>;
+export type SendVerificationMutationError = ErrorType<SendVerification400 | SendVerification403>;
+export declare const useSendVerification: <TError = SendVerification400 | SendVerification403, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useSendVerificationHook>>>, TError, void, TContext>;
+}) => UseMutationResult<Awaited<ReturnType<ReturnType<typeof useSendVerificationHook>>>, TError, void, TContext>;
+export declare const useVerifyHook: () => (verifyRequest: BodyType<VerifyRequest>, signal?: AbortSignal) => Promise<VerifyResponse>;
+export declare const useVerifyMutationOptions: <TError = Verify400 | Verify403, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useVerifyHook>>>, TError, {
+        data: BodyType<VerifyRequest>;
+    }, TContext>;
+}) => UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useVerifyHook>>>, TError, {
+    data: BodyType<VerifyRequest>;
+}, TContext>;
+export type VerifyMutationResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useVerifyHook>>>>;
+export type VerifyMutationBody = BodyType<VerifyRequest>;
+export type VerifyMutationError = ErrorType<Verify400 | Verify403>;
+export declare const useVerify: <TError = Verify400 | Verify403, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useVerifyHook>>>, TError, {
+        data: BodyType<VerifyRequest>;
+    }, TContext>;
+}) => UseMutationResult<Awaited<ReturnType<ReturnType<typeof useVerifyHook>>>, TError, {
+    data: BodyType<VerifyRequest>;
+}, TContext>;
+export declare const useRegisterPasskeyHook: () => (signal?: AbortSignal) => Promise<RegisterPasskeyResponse>;
+export declare const useRegisterPasskeyMutationOptions: <TError = RegisterPasskey400 | RegisterPasskey403, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useRegisterPasskeyHook>>>, TError, void, TContext>;
+}) => UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useRegisterPasskeyHook>>>, TError, void, TContext>;
+export type RegisterPasskeyMutationResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useRegisterPasskeyHook>>>>;
+export type RegisterPasskeyMutationError = ErrorType<RegisterPasskey400 | RegisterPasskey403>;
+export declare const useRegisterPasskey: <TError = RegisterPasskey400 | RegisterPasskey403, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useRegisterPasskeyHook>>>, TError, void, TContext>;
+}) => UseMutationResult<Awaited<ReturnType<ReturnType<typeof useRegisterPasskeyHook>>>, TError, void, TContext>;
+export declare const useVerifyPasskeyHook: () => (verifyPasskeyRequest: BodyType<VerifyPasskeyRequest>, signal?: AbortSignal) => Promise<VerifyPasskey200>;
+export declare const useVerifyPasskeyMutationOptions: <TError = VerifyPasskey400 | VerifyPasskey403, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useVerifyPasskeyHook>>>, TError, {
+        data: BodyType<VerifyPasskeyRequest>;
+    }, TContext>;
+}) => UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useVerifyPasskeyHook>>>, TError, {
+    data: BodyType<VerifyPasskeyRequest>;
+}, TContext>;
+export type VerifyPasskeyMutationResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useVerifyPasskeyHook>>>>;
+export type VerifyPasskeyMutationBody = BodyType<VerifyPasskeyRequest>;
+export type VerifyPasskeyMutationError = ErrorType<VerifyPasskey400 | VerifyPasskey403>;
+export declare const useVerifyPasskey: <TError = VerifyPasskey400 | VerifyPasskey403, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useVerifyPasskeyHook>>>, TError, {
+        data: BodyType<VerifyPasskeyRequest>;
+    }, TContext>;
+}) => UseMutationResult<Awaited<ReturnType<ReturnType<typeof useVerifyPasskeyHook>>>, TError, {
+    data: BodyType<VerifyPasskeyRequest>;
+}, TContext>;
+export declare const useDeletePasskeyHook: () => (passkeyId: string) => Promise<DeletePasskey200>;
+export declare const useDeletePasskeyMutationOptions: <TError = DeletePasskey400 | DeletePasskey403, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useDeletePasskeyHook>>>, TError, {
+        passkeyId: string;
+    }, TContext>;
+}) => UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useDeletePasskeyHook>>>, TError, {
+    passkeyId: string;
+}, TContext>;
+export type DeletePasskeyMutationResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useDeletePasskeyHook>>>>;
+export type DeletePasskeyMutationError = ErrorType<DeletePasskey400 | DeletePasskey403>;
+export declare const useDeletePasskey: <TError = DeletePasskey400 | DeletePasskey403, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useDeletePasskeyHook>>>, TError, {
+        passkeyId: string;
+    }, TContext>;
+}) => UseMutationResult<Awaited<ReturnType<ReturnType<typeof useDeletePasskeyHook>>>, TError, {
+    passkeyId: string;
+}, TContext>;
+export declare const useListOrganizationDomainsHook: () => (signal?: AbortSignal) => Promise<ListOrganizationDomains200>;
+export declare const getListOrganizationDomainsQueryKey: () => readonly ["/_widgets/admin-portal/organization-domains"];
+export declare const useListOrganizationDomainsQueryOptions: <TData = ListOrganizationDomains200, TError = ListOrganizationDomains403 | ListOrganizationDomains404>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useListOrganizationDomainsHook>>>, TError, TData>>;
+}) => UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useListOrganizationDomainsHook>>>, TError, TData> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export type ListOrganizationDomainsQueryResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useListOrganizationDomainsHook>>>>;
+export type ListOrganizationDomainsQueryError = ErrorType<ListOrganizationDomains403 | ListOrganizationDomains404>;
+export declare function useListOrganizationDomains<TData = Awaited<ReturnType<ReturnType<typeof useListOrganizationDomainsHook>>>, TError = ErrorType<ListOrganizationDomains403 | ListOrganizationDomains404>>(options: {
+    query: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useListOrganizationDomainsHook>>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<ReturnType<typeof useListOrganizationDomainsHook>>>, TError, Awaited<ReturnType<ReturnType<typeof useListOrganizationDomainsHook>>>>, "initialData">;
+}): DefinedUseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export declare function useListOrganizationDomains<TData = Awaited<ReturnType<ReturnType<typeof useListOrganizationDomainsHook>>>, TError = ErrorType<ListOrganizationDomains403 | ListOrganizationDomains404>>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useListOrganizationDomainsHook>>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<ReturnType<typeof useListOrganizationDomainsHook>>>, TError, Awaited<ReturnType<ReturnType<typeof useListOrganizationDomainsHook>>>>, "initialData">;
+}): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export declare function useListOrganizationDomains<TData = Awaited<ReturnType<ReturnType<typeof useListOrganizationDomainsHook>>>, TError = ErrorType<ListOrganizationDomains403 | ListOrganizationDomains404>>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useListOrganizationDomainsHook>>>, TError, TData>>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export declare const useGenerateAdminPortalLinkHook: () => (params: GenerateAdminPortalLinkParams, signal?: AbortSignal) => Promise<GenerateAdminPortalLink201>;
+export declare const useGenerateAdminPortalLinkMutationOptions: <TError = GenerateAdminPortalLink403 | GenerateAdminPortalLink404 | GenerateAdminPortalLink500, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useGenerateAdminPortalLinkHook>>>, TError, {
+        params: GenerateAdminPortalLinkParams;
+    }, TContext>;
+}) => UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useGenerateAdminPortalLinkHook>>>, TError, {
+    params: GenerateAdminPortalLinkParams;
+}, TContext>;
+export type GenerateAdminPortalLinkMutationResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useGenerateAdminPortalLinkHook>>>>;
+export type GenerateAdminPortalLinkMutationError = ErrorType<GenerateAdminPortalLink403 | GenerateAdminPortalLink404 | GenerateAdminPortalLink500>;
+export declare const useGenerateAdminPortalLink: <TError = GenerateAdminPortalLink403 | GenerateAdminPortalLink404 | GenerateAdminPortalLink500, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useGenerateAdminPortalLinkHook>>>, TError, {
+        params: GenerateAdminPortalLinkParams;
+    }, TContext>;
+}) => UseMutationResult<Awaited<ReturnType<ReturnType<typeof useGenerateAdminPortalLinkHook>>>, TError, {
+    params: GenerateAdminPortalLinkParams;
+}, TContext>;
+export declare const useDeleteOrganizationDomainHook: () => (domainId: string) => Promise<OrganizationDomain>;
+export declare const useDeleteOrganizationDomainMutationOptions: <TError = DeleteOrganizationDomain403 | DeleteOrganizationDomain404, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useDeleteOrganizationDomainHook>>>, TError, {
+        domainId: string;
+    }, TContext>;
+}) => UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useDeleteOrganizationDomainHook>>>, TError, {
+    domainId: string;
+}, TContext>;
+export type DeleteOrganizationDomainMutationResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useDeleteOrganizationDomainHook>>>>;
+export type DeleteOrganizationDomainMutationError = ErrorType<DeleteOrganizationDomain403 | DeleteOrganizationDomain404>;
+export declare const useDeleteOrganizationDomain: <TError = DeleteOrganizationDomain403 | DeleteOrganizationDomain404, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useDeleteOrganizationDomainHook>>>, TError, {
+        domainId: string;
+    }, TContext>;
+}) => UseMutationResult<Awaited<ReturnType<ReturnType<typeof useDeleteOrganizationDomainHook>>>, TError, {
+    domainId: string;
+}, TContext>;
+export declare const useReverifyOrganizationDomainHook: () => (domainId: string, signal?: AbortSignal) => Promise<OrganizationDomain>;
+export declare const useReverifyOrganizationDomainMutationOptions: <TError = ReverifyOrganizationDomain403 | ReverifyOrganizationDomain404, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useReverifyOrganizationDomainHook>>>, TError, {
+        domainId: string;
+    }, TContext>;
+}) => UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useReverifyOrganizationDomainHook>>>, TError, {
+    domainId: string;
+}, TContext>;
+export type ReverifyOrganizationDomainMutationResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useReverifyOrganizationDomainHook>>>>;
+export type ReverifyOrganizationDomainMutationError = ErrorType<ReverifyOrganizationDomain403 | ReverifyOrganizationDomain404>;
+export declare const useReverifyOrganizationDomain: <TError = ReverifyOrganizationDomain403 | ReverifyOrganizationDomain404, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useReverifyOrganizationDomainHook>>>, TError, {
+        domainId: string;
+    }, TContext>;
+}) => UseMutationResult<Awaited<ReturnType<ReturnType<typeof useReverifyOrganizationDomainHook>>>, TError, {
+    domainId: string;
+}, TContext>;
+export declare const useListSsoConnectionsHook: () => (signal?: AbortSignal) => Promise<SsoConnection[]>;
+export declare const getListSsoConnectionsQueryKey: () => readonly ["/_widgets/admin-portal/sso-connections"];
+export declare const useListSsoConnectionsQueryOptions: <TData = SsoConnection[], TError = unknown>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useListSsoConnectionsHook>>>, TError, TData>>;
+}) => UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useListSsoConnectionsHook>>>, TError, TData> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export type ListSsoConnectionsQueryResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useListSsoConnectionsHook>>>>;
+export type ListSsoConnectionsQueryError = ErrorType<unknown>;
+export declare function useListSsoConnections<TData = Awaited<ReturnType<ReturnType<typeof useListSsoConnectionsHook>>>, TError = ErrorType<unknown>>(options: {
+    query: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useListSsoConnectionsHook>>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<ReturnType<typeof useListSsoConnectionsHook>>>, TError, Awaited<ReturnType<ReturnType<typeof useListSsoConnectionsHook>>>>, "initialData">;
+}): DefinedUseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export declare function useListSsoConnections<TData = Awaited<ReturnType<ReturnType<typeof useListSsoConnectionsHook>>>, TError = ErrorType<unknown>>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useListSsoConnectionsHook>>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<ReturnType<typeof useListSsoConnectionsHook>>>, TError, Awaited<ReturnType<ReturnType<typeof useListSsoConnectionsHook>>>>, "initialData">;
+}): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+export declare function useListSsoConnections<TData = Awaited<ReturnType<ReturnType<typeof useListSsoConnectionsHook>>>, TError = ErrorType<unknown>>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useListSsoConnectionsHook>>>, TError, TData>>;
+}): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData>;
+};
+//# sourceMappingURL=endpoint.d.ts.map