import { NotifiService, Types, NotifiEmitterEvents } from '@notifi-network/notifi-graphql';
import { NotifiDataplaneClient, ActivateSmartLinkActionInput, ActivateSmartLinkActionResponse } from '@notifi-network/notifi-dataplane';
import { GraphQLClient } from 'graphql-request';

type AlertFrequency = 'ALWAYS' | 'SINGLE' | 'QUARTER_HOUR' | 'HOURLY' | 'DAILY' | 'THREE_MINUTES';
type ValueItemConfig = Readonly<{
    key: string;
    op: 'lt' | 'lte' | 'eq' | 'gt' | 'gte';
    value: string;
}>;
type ThresholdDirection = 'above' | 'below';
/**@deprecated this is for AP v1 infra, use fusionFilterOptions instead for new infra */
type FilterOptions = Partial<{
    alertFrequency: AlertFrequency;
    directMessageType: string;
    threshold: number;
    delayProcessingUntil: string;
    thresholdDirection: ThresholdDirection;
    values: Readonly<{
        and: ReadonlyArray<ValueItemConfig>;
    } | {
        or: ReadonlyArray<ValueItemConfig>;
    }>;
    tradingPair: string;
}>;

type AptosSignMessageParams = Readonly<{
    walletBlockchain: AptosBlockchain;
    nonce: string;
    signMessage: AptosSignMessageFunction;
}>;
type AptosSignMessageFunction = (message: string, nonce: string) => Promise<{
    signatureHex: `0x${string}`;
    signedMessage: string;
}>;

type CardanoSignMessageParams = Readonly<{
    walletBlockchain: CardanoBlockchain;
    nonce: string;
    signMessage: Uint8SignMessageFunction;
}>;

type CosmosSignMessageParams = Readonly<{
    walletBlockchain: CosmosBlockchain;
    message: string;
    signMessage: CosmosSignMessageFunction;
}>;
type CosmosSignMessageFunction = (message: string) => Promise<{
    signatureBase64: string;
    signedMessage: string;
}>;

type EvmSignMessageParams = Readonly<{
    walletBlockchain: EvmBlockchain;
    nonce: string;
    signMessage: Uint8SignMessageFunction;
}>;

type SolanaSignMessageParams = Readonly<{
    walletBlockchain: SolanaBlockchain;
    nonce: string;
    signMessage: Uint8SignMessageFunction;
    isUsingHardwareWallet?: boolean;
    hardwareLoginPlugin?: {
        signTransaction: (message: string) => Promise<string>;
    };
}>;

type SuiSignMessageParams = Readonly<{
    walletBlockchain: SuiBlockchain;
    nonce: string;
    signMessage: Uint8SignMessageFunction;
}>;

type StorageDriver = Readonly<{
    get: <T>(key: string) => Promise<T | null>;
    set: <T>(key: string, newValue: T | null) => Promise<void>;
    has: (key: string) => Promise<boolean>;
}>;
type GetStorageType<Key extends string, T> = Readonly<{
    [key in `get${Capitalize<Key>}`]: () => Promise<T | null>;
}>;
type SetStorageType<Key extends string, T> = Readonly<{
    [key in `set${Capitalize<Key>}`]: (newValue: T | null) => Promise<void>;
}>;
type HasStorageType<Key extends string> = Readonly<{
    [key in `has${Capitalize<Key>}`]: () => Promise<boolean>;
}>;
type StorageType<Key extends string, T> = GetStorageType<Key, T> & SetStorageType<Key, T> & HasStorageType<Key>;
type Authorization = Readonly<{
    token: string;
    expiry: string;
}>;
type AuthorizationStorage = StorageType<'authorization', Authorization>;
type Roles = ReadonlyArray<string>;
type RolesStorage = StorageType<'roles', Roles>;
type NotifiStorage = AuthorizationStorage & RolesStorage;
declare class NotifiFrontendStorage implements NotifiStorage {
    private _driver;
    constructor(_driver: StorageDriver);
    getAuthorization(): Promise<Authorization | null>;
    setAuthorization(newValue: Authorization | null): Promise<void>;
    hasAuthorization(): Promise<boolean>;
    getRoles(): Promise<Roles | null>;
    setRoles(newValue: Roles | null): Promise<void>;
    hasRoles(): Promise<boolean>;
}

declare const createInMemoryStorageDriver: (config: NotifiFrontendConfiguration) => StorageDriver;

declare const createLocalForageStorageDriver: (config: NotifiFrontendConfiguration) => StorageDriver;

type UserState = Readonly<{
    status: 'loggedOut';
} | {
    status: 'authenticated';
    authorization: Authorization;
    roles: Roles;
} | {
    status: 'expired';
    authorization: Authorization;
}>;
declare class AuthManager {
    private readonly _service;
    private readonly _storage;
    private readonly _configuration;
    private _userState;
    private _clientRandomUuid;
    constructor(_service: NotifiService, _storage: NotifiStorage, _configuration: NotifiFrontendConfiguration);
    get userState(): UserState | null;
    initialize(): Promise<UserState>;
    logOut(): Promise<UserState>;
    logIn(loginParams: LoginParams): Promise<Types.UserFragmentFragment>;
    beginLoginViaTransaction({ walletBlockchain, walletAddress, }: Omit<Types.BeginLogInByTransactionInput, 'dappAddress'>): Promise<Types.BeginLogInByTransactionResult>;
    completeLoginViaTransaction({ walletBlockchain, walletAddress, transactionSignature, }: Omit<Types.CompleteLogInByTransactionInput, 'dappAddress' | 'randomUuid'>): Promise<Types.CompleteLogInByTransactionMutation>;
    private _logInWithWeb3;
    /**@deprecated Use _authWithWeb3 instead, will remove after all BlockchainType has been migrated */
    private _logInLegacy;
    private _handleLogInResult;
}

declare const SIGNING_MESSAGE_WITHOUT_NONCE = "Sign in with Notifi \n\n    No password needed or gas is needed. \n\n    Clicking \u201CApprove\u201D only means you have proved this wallet is owned by you! \n\n    This request will not trigger any transaction or cost any gas fees. \n\n    Use of our website and service is subject to our terms of service and privacy policy.";
declare const SIGNING_MESSAGE = "Sign in with Notifi \n\n    No password needed or gas is needed. \n\n    Clicking \u201CApprove\u201D only means you have proved this wallet is owned by you! \n\n    This request will not trigger any transaction or cost any gas fees. \n\n    Use of our website and service is subject to our terms of service and privacy policy. \n \n 'Nonce:' ";
declare const CHAINS_WITH_LOGIN_WEB3: readonly ["APTOS", "MOVEMENT", "CARDANO", "COSMOS", "OSMOSIS", "NEUTRON", "ELYS", "ARCHWAY", "AXELAR", "AGORIC", "ORAI", "KAVA", "CELESTIA", "NIBIRU", "DYMENSION", "PERSISTENCE", "DYDX", "XION", "SOLANA", "ETHEREUM", "POLYGON", "ARBITRUM", "AVALANCHE", "BINANCE", "BOTANIX", "BOB", "MONAD", "BASE", "BLAST", "CELO", "MANTLE", "SCROLL", "LINEA", "MANTA", "BERACHAIN", "HYPEREVM", "UNICHAIN", "OPTIMISM", "THE_ROOT_NETWORK", "SEI", "SONIC", "INK", "SWELLCHAIN", "HEMI", "CORE_BLOCKCHAIN_MAINNET", "GOAT_NETWORK", "NIBURU_CATACLYSM1", "ROME", "ZKSYNC", "SUI"];
interface BlockchainAuthStrategy {
    authenticate(params: SignMessageParams): Promise<AuthenticateResult>;
    prepareLoginWithWeb3(params: LoginWeb3Params): Promise<{
        signMessageParams: SignMessageParams;
        signingAddress: string;
        signingPubkey: string;
        nonce: string;
    }>;
}
type LoginParams = LoginWeb3Params | Exclude<SignMessageParams, LoginWeb3Params['walletBlockchain']>;
type LoginWeb3Params = CleanedLoginWeb3Params<SignMessageParams>;
type CleanedLoginWeb3Params<T> = T extends {
    walletBlockchain: (typeof CHAINS_WITH_LOGIN_WEB3)[number];
} ? Omit<T, 'nonce' | 'message'> : never;
type SignMessageParams = CosmosSignMessageParams | BtcSignMessageParams | EvmSignMessageParams | AptosSignMessageParams | SolanaSignMessageParams | SuiSignMessageParams | CardanoSignMessageParams | NearSignMessageParams | InjectiveSignMessageParams | OffChainSignMessageParams | UnmaintainedSignMessageParams;
type BtcSignMessageParams = Readonly<{
    walletBlockchain: BtcBlockchain;
    signMessage: Uint8SignMessageFunction;
}>;
type NearSignMessageParams = Readonly<{
    walletBlockchain: 'NEAR';
    signMessage: Uint8SignMessageFunction;
}>;
type InjectiveSignMessageParams = Readonly<{
    walletBlockchain: 'INJECTIVE';
    signMessage: Uint8SignMessageFunction;
}>;
type OffChainSignMessageParams = Readonly<{
    walletBlockchain: 'OFF_CHAIN';
    signIn: OidcSignInFunction;
}>;
type UnmaintainedSignMessageParams = Readonly<{
    walletBlockchain: UnmaintainedBlockchain;
    signMessage: Uint8SignMessageFunction;
}>;
type Uint8SignMessageFunction = (message: Uint8Array) => Promise<Uint8Array>;
type OidcCredentials = {
    oidcProvider: Types.OidcProvider;
    jwt: string;
};
type AuthenticateResult = SignMessageResult | OidcCredentials;
type OidcSignInFunction = () => Promise<OidcCredentials>;
type SignMessageResult = {
    signature: string;
    signedMessage: string;
};
type BeginLoginWithWeb3Props = Omit<Types.BeginLogInWithWeb3Input, 'dappAddress' | 'blockchainType'>;
declare const isLoginWeb3Params: (params: LoginParams) => params is LoginWeb3Params;
declare const beginLogInWithWeb3: (params: BeginLoginWithWeb3Props & {
    service: NotifiService;
    config: NotifiFrontendConfiguration;
}) => Promise<Types.BeginLogInWithWeb3Response>;
declare const getStrategyForBlockchain: (blockchain: Types.BlockchainType, service: NotifiService, config: NotifiFrontendConfiguration) => BlockchainAuthStrategy;

type NotifiTarget = 'email' | 'phoneNumber' | 'telegram' | 'discord' | 'slack' | 'wallet';

type AlterTargetGroupParams = Readonly<{
    name: string;
} & Partial<Record<NotifiTarget, UpdateTargetsParam>>>;
type UpdateTargetsParam = {
    type: 'remove';
} | {
    type: 'delete';
    id: string;
} | {
    type: 'ensure';
    name: string;
};

/**@deprecated use CardConfigItemV2 */
type CardConfigType = CardConfigItemV1;
type BeginLoginProps = Omit<Types.BeginLogInByTransactionInput, 'dappAddress'>;
type CompleteLoginProps = Omit<Types.CompleteLogInByTransactionInput, 'dappAddress' | 'randomUuid'>;
type FindSubscriptionCardParams = Omit<Types.FindTenantConfigInput, 'tenant'>;
declare class NotifiFrontendClient {
    private _configuration;
    private _service;
    private _storage;
    private _authManager;
    constructor(_configuration: NotifiFrontendConfiguration, _service: NotifiService, _storage: NotifiStorage);
    get auth(): AuthManager;
    fetchFusionData(): Promise<Types.FetchFusionDataQuery>;
    getTargetGroups(): Promise<ReadonlyArray<Types.TargetGroupFragmentFragment>>;
    getAlerts(): Promise<ReadonlyArray<Types.AlertFragmentFragment>>;
    ensureFusionAlerts(input: Types.CreateFusionAlertsInput): Promise<Types.CreateFusionAlertsMutation['createFusionAlerts']>;
    deleteAlerts({ ids, }: Readonly<{
        ids: Array<string>;
    }>): Promise<Types.DeleteAlertsMutation['deleteAlerts']>;
    getUnreadNotificationHistoryCount(cardId?: string): Promise<Types.GetUnreadNotificationHistoryCountQuery['unreadNotificationHistoryCount']>;
    /**
     * @returns {string} - The id of the event listener (used to remove the event listener)
     */
    addEventListener<K extends keyof NotifiEmitterEvents>(event: K, callBack: (...args: NotifiEmitterEvents[K]) => void, onError?: (error: unknown) => void, onCompleted?: () => void): string;
    removeEventListener<K extends keyof NotifiEmitterEvents>(event: K, id: string): void;
    getUserSettings(): Promise<Types.GetUserSettingsQuery['userSettings']>;
    getFusionNotificationHistory(variables: Types.GetFusionNotificationHistoryQueryVariables): Promise<Readonly<Types.GetFusionNotificationHistoryQuery['fusionNotificationHistory']>>;
    fetchTenantConfig(variables: FindSubscriptionCardParams): Promise<TenantConfig | TenantConfigV2>;
    sendEmailTargetVerification({ targetId, }: Readonly<{
        targetId: string;
    }>): Promise<string>;
    createDiscordTarget(input: string): Promise<{
        __typename?: "DiscordTarget";
        id: string;
        discordAccountId?: string | undefined;
        discriminator?: string | undefined;
        isConfirmed: boolean;
        username?: string | undefined;
        name?: string | undefined;
        userStatus: Types.DiscordTargetStatus;
        verificationLink?: string | undefined;
        discordServerInviteLink?: string | undefined;
    }>;
    markFusionNotificationHistoryAsRead(input: Types.MarkFusionNotificationHistoryAsReadMutationVariables): Promise<Types.MarkFusionNotificationHistoryAsReadMutation>;
    updateUserSettings(input: Types.UpdateUserSettingsMutationVariables): Promise<Types.UpdateUserSettingsMutation>;
    verifyCbwTarget(input: Types.VerifyCbwTargetMutationVariables): Promise<Types.VerifyCbwTargetMutation>;
    verifyXmtpTargetViaXip42(input: Types.VerifyXmtpTargetViaXip42MutationVariables): Promise<Types.VerifyXmtpTargetViaXip42Mutation>;
    createWebPushTarget(input: Types.CreateWebPushTargetMutationVariables): Promise<Types.CreateWebPushTargetMutation>;
    updateWebPushTarget(input: Types.UpdateWebPushTargetMutationVariables): Promise<Types.UpdateWebPushTargetMutation>;
    deleteWebPushTarget(input: Types.DeleteWebPushTargetMutationVariables): Promise<Types.DeleteWebPushTargetMutation>;
    getWebPushTargets(input: Types.GetWebPushTargetsQueryVariables): Promise<Types.GetWebPushTargetsQuery['webPushTargets']>;
    alterTargetGroup(alterTargetGroupParams: AlterTargetGroupParams): Promise<Types.TargetGroupFragmentFragment>;
    /**
     * ⬇ ⬇ ⬇ ⬇ ⬇ ⬇ ⬇ ⬇ ⬇ ⬇ ⬇
     * ⬇ ⬇ Deprecated methods ⬇ ⬇
     * ⬇ ⬇ ⬇ ⬇ ⬇ ⬇ ⬇ ⬇ ⬇ ⬇ ⬇
     */
    /** @deprecated Use renewTargetGroup instead */
    ensureTargetGroup({ name, emailAddress, phoneNumber, telegramId, discordId, slackId, walletId, }: Readonly<{
        name: string;
        emailAddress?: string;
        phoneNumber?: string;
        telegramId?: string;
        discordId?: string;
        slackId?: string;
        walletId?: string;
    }>): Promise<Types.TargetGroupFragmentFragment>;
    /**
     * @deprecated use alterTargetGroup instead
     * @description !IMPORTANT: the id arguments (telegramId, discordId, slackId, walletId) is the self-defined identity (only within notifi BE). This is NEITHER the user name NOR the user id of associated platform.
     */
    renewTargetGroup({ name, emailAddress, phoneNumber, telegramId, discordId, slackId, walletId, }: Readonly<{
        name: string;
        emailAddress?: string;
        phoneNumber?: string;
        telegramId?: string;
        discordId?: string;
        slackId?: string;
        walletId?: string;
    }>): Promise<Types.TargetGroupFragmentFragment>;
    /**
     * @deprecated all consumers (ensureTargetGroup) are deprecated
     */
    private _updateTargetGroup;
    /**
     * @deprecated Use `deleteAlerts` instead
     */
    deleteAlert({ id, }: Readonly<{
        id: string;
    }>): Promise<void>;
    /**@deprecated Use frontendClient.auth.userState instead */
    get userState(): UserState | null;
    /**@deprecated Use frontendClient.auth.initialize instead */
    initialize(): Promise<UserState>;
    /**@deprecated Use frontendClient.auth.logOut instead */
    logOut(): Promise<UserState>;
    /**@deprecated Use frontendClient.auth.logIn instead */
    logIn(loginParams: LoginParams): Promise<Types.UserFragmentFragment>;
    /**@deprecated Use frontendClient.auth.beginLoginViaTransaction instead */
    beginLoginViaTransaction(props: BeginLoginProps): Promise<Types.BeginLogInByTransactionResult>;
    /**@deprecated Use frontendClient.auth.completeLoginViaTransaction instead */
    completeLoginViaTransaction(props: CompleteLoginProps): Promise<Types.CompleteLogInByTransactionMutation>;
}

type SmartLinkConfig = {
    id: string;
    icon: string;
    tenantName: string;
    bannerImgUrl: string;
    blockchainType: Types.BlockchainType;
    name: string;
    description: string;
    title: string;
    subtitle: string;
    components: (SmartLinkAction | SmartLinkTxt | SmartLinkImg)[];
};
type SmartLinkTxt = {
    type: 'TEXT';
    text: string;
};
type SmartLinkImg = {
    type: 'IMAGE';
    src: string;
    alt: string;
};
type SmartLinkAction = {
    type: 'ACTION';
    id: string;
    inputs: ActionInputParams[];
    label: string /** This is the label that will be displayed on Action button */;
};
type ActionInputParams = ActionInputParamsTextBox<'NUMBER'> | ActionInputParamsTextBox<'TEXT'> | ActionInputParamsCheckBox;
type ActionInputBaseParams = {
    isRequired: boolean;
    id: string;
};
type ActionInputParamsTextBox<T extends 'TEXT' | 'NUMBER'> = ActionInputBaseParams & {
    type: 'TEXTBOX';
    inputType: T;
    placeholder: T extends 'NUMBER' ? number : string;
    default: T extends 'NUMBER' ? number : string;
    constraintType?: T extends 'NUMBER' ? NumberConstraint : StringConstraint;
    prefix?: string;
    suffix?: string;
};
type ActionInputParamsCheckBox = ActionInputBaseParams & {
    type: 'CHECKBOX';
    title: string;
};
type NumberConstraint = {
    min?: number;
    max?: number;
};
type StringConstraint = {
    minLength?: number;
    maxLength?: number;
    pattern?: string /** Regex pattern */;
};
declare const isSmartLinkConfig: (obj: unknown) => obj is SmartLinkConfig;

type SmartLinkConfigWithIsActive = {
    smartLinkConfig: SmartLinkConfig;
    isActive: boolean;
};

declare class NotifiSmartLinkClient {
    private _configuration;
    private _service;
    private _dpService;
    constructor(_configuration: NotifiSmartLinkClientConfig, _service: NotifiService, _dpService: NotifiDataplaneClient);
    fetchSmartLinkConfig(id: string): Promise<SmartLinkConfigWithIsActive>;
    activateSmartLinkAction(args: Omit<ActivateSmartLinkActionInput, 'authParams'>): Promise<ActivateSmartLinkActionResponse>;
}

type RequestConfig = NonNullable<ConstructorParameters<typeof GraphQLClient>[1]>;
declare const instantiateFrontendClient: (tenantId: string, params: UserParams, env?: NotifiEnvironment, storageOption?: NotifiFrontendConfiguration["storageOption"], gqlClientRequestConfig?: RequestConfig, optionHeaders?: Record<string, string>) => NotifiFrontendClient;
declare const newSmartLinkClient: (config: NotifiSmartLinkClientConfig, gqlClientRequestConfig?: RequestConfig) => NotifiSmartLinkClient;

/** ⬇ clientFactory.ts */
/**@deprecated Use instantiateFrontendClient instead */
declare const newFrontendClient: (args: ConfigFactoryInput) => NotifiFrontendClient;
/** ⬇ ensureTargets.ts */
type EnsureTargetFuncFactory = <CreateService, GetService, T extends Readonly<{
    id?: string;
}>>(create: CreateFunc<CreateService, T>, fetch: FetchFunc<GetService, T>, identify: IdentifyFunc<T>, valueTransform?: ValueTransformFunc) => EnsureTargetFunc<CreateService, GetService>;
type CreateFunc<CreateService, T> = (service: CreateService, value: string) => Promise<T>;
type FetchFunc<GetService, T> = (service: GetService) => Promise<Array<T | undefined> | undefined>;
type IdentifyFunc<T> = (arg: T | undefined) => string | undefined;
type ValueTransformFunc = (value: string) => string;
type EnsureTargetFunc<CreateService, GetService> = (service: CreateService & GetService, value: string | undefined) => Promise<string | undefined>;
/** @deprecated Use alterTarget instead */
declare const ensureTarget: EnsureTargetFuncFactory;
/** @deprecated Use alterTarget instead */
declare const ensureEmail: EnsureTargetFunc<Readonly<{
    createEmailTarget: (variables: Types.CreateEmailTargetMutationVariables) => Promise<Types.CreateEmailTargetMutation>;
}>, Readonly<{
    getEmailTargets: (variables: Types.GetEmailTargetsQueryVariables) => Promise<Types.GetEmailTargetsQuery>;
}>>;
/** @deprecated Use alterTarget instead */
declare const ensureSms: EnsureTargetFunc<Readonly<{
    createSmsTarget: (variables: Types.CreateSmsTargetMutationVariables) => Promise<Types.CreateSmsTargetMutation>;
}>, Readonly<{
    getSmsTargets: (variables: Types.GetSmsTargetsQueryVariables) => Promise<Types.GetSmsTargetsQuery>;
}>>;
/** @deprecated Use alterTarget instead */
declare const renewTelegram: EnsureTargetFunc<Readonly<{
    createTelegramTarget: (variables: Types.CreateTelegramTargetMutationVariables) => Promise<Types.CreateTelegramTargetMutation>;
}>, Readonly<{
    getTelegramTargets: (variables: Types.GetTelegramTargetsQueryVariables) => Promise<Types.GetTelegramTargetsQuery>;
}>>;
/** @deprecated Use alterTarget instead */
declare const ensureDiscord: EnsureTargetFunc<Readonly<{
    createDiscordTarget: (variables: Types.CreateDiscordTargetMutationVariables) => Promise<Types.CreateDiscordTargetMutation>;
}>, Readonly<{
    getDiscordTargets: (variables: Types.GetDiscordTargetsQueryVariables) => Promise<Types.GetDiscordTargetsQuery>;
}>>;
/** @deprecated Use alterTarget instead */
declare const ensureSlack: EnsureTargetFunc<Readonly<{
    createSlackChannelTarget: (variables: Types.CreateSlackChannelTargetMutationVariables) => Promise<Types.CreateSlackChannelTargetMutation>;
}>, Readonly<{
    getSlackChannelTargets: (variables: Types.GetSlackChannelTargetsQueryVariables) => Promise<Types.GetSlackChannelTargetsQuery>;
}>>;
/** @deprecated Use alterTarget instead */
declare const ensureWeb3: EnsureTargetFunc<Readonly<{
    createWeb3Target: (variables: Types.CreateWeb3TargetMutationVariables) => Promise<Types.CreateWeb3TargetMutation>;
}>, Readonly<{
    getWeb3Targets: (variables: Types.GetWeb3TargetsQueryVariables) => Promise<Types.GetWeb3TargetsQuery>;
}>>;
/** @deprecated Use alterTarget instead */
declare const ensureTelegram: EnsureTargetFunc<Readonly<{
    createTelegramTarget: (variables: Types.CreateTelegramTargetMutationVariables) => Promise<Types.CreateTelegramTargetMutation>;
}>, Readonly<{
    getTelegramTargets: (variables: Types.GetTelegramTargetsQueryVariables) => Promise<Types.GetTelegramTargetsQuery>;
}>>;

type NumberTypeSelect = 'percentage' | 'integer' | 'price';
type CountryCode = string;
type SmsContactInfo = ContactInfo & Readonly<{
    supportedCountryCodes: ReadonlyArray<CountryCode>;
}>;
/**
 * The difference from `Target` in `NotifiTargetContext` is the use of `sms`
 * instead of `phoneNumber` (as used in `NotifiTargetContext`).
 */
type TenantConfigTarget = 'email' | 'sms' | 'telegram' | 'discord' | 'slack' | 'wallet' | 'browser';
type ContactInfoConfig = Omit<Record<TenantConfigTarget, ContactInfo>, 'sms'> & {
    sms: SmsContactInfo;
};
type TenantConfigV2 = Readonly<{
    cardConfig: CardConfigItemV2;
    fusionEventTopics: Array<TopicMetadata>;
}>;
type TopicMetadata = {
    uiConfig: TopicUiConfig;
    fusionEventDescriptor: Types.FusionEventDescriptor;
};
type CardConfigItemV2 = Readonly<{
    version: 'v2';
    name: string;
    id: string;
    contactInfo: ContactInfoConfig;
    isContactInfoRequired?: boolean;
    eventTypes: Array<TopicUiConfig | LabelUiConfig>;
}>;
type TopicUiConfig = Readonly<{
    name: string;
    type: 'fusion';
    topicGroupName?: string;
    index?: number;
    fusionEventId: string;
    tooltipContent?: string;
    optOutAtSignup?: boolean;
}>;
type LabelUiConfig = Readonly<{
    type: 'label';
    name: string;
    tooltipContent?: string;
    optOutAtSignup?: boolean;
}>;
type ValueOrRef<ValueType> = Readonly<{
    type: 'ref';
    ref: string | null;
}> | Readonly<{
    type: 'value';
    value: ValueType;
}>;
/** ⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇
 *  ⬇⬇⬇⬇ DEPRECATED ⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇
 *  ⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇
 */
/**@deprecated */
type LabelEventTypeItem = LabelUiConfig;
/**@deprecated */
type FusionToggleEventTypeItem = FusionTypeBase & Readonly<{
    selectedUIType: 'TOGGLE';
}>;
/**@deprecated */
type FusionHealthCheckEventTypeItem = FusionTypeBase & Readonly<{
    selectedUIType: 'HEALTH_CHECK';
    healthCheckSubtitle: string;
    numberType: NumberTypeSelect;
    checkRatios: CheckRatio[];
    validInputRange?: ValidInputRange;
}>;
/**@deprecated */
type ValidInputRange = {
    max: number;
    min: number;
};
/**@deprecated */
type FusionMultiThreshholdEventTypeItem = FusionTypeBase & Readonly<{
    selectedUIType: 'MULTI_THRESHOLD';
    numberType: NumberTypeSelect;
    subtitle?: string;
    addThreshholdTitle?: string;
}>;
/**@deprecated */
type FusionEventTypeItem = FusionToggleEventTypeItem | FusionHealthCheckEventTypeItem | FusionMultiThreshholdEventTypeItem;
/**@deprecated */
type BroadcastEventTypeItem = Readonly<{
    type: 'broadcast';
    name: string;
    broadcastId: ValueOrRef<string>;
    tooltipContent?: string;
    optOutAtSignup?: boolean;
    displayNameOverride?: string;
}>;
/**@deprecated */
type HealthCheckEventTypeItem = Readonly<{
    type: 'healthCheck';
    name: string;
    checkRatios: ValueOrRef<CheckRatio[]>;
    alertFrequency: AlertFrequency;
    tooltipContent?: string;
    optOutAtSignup?: boolean;
}>;
/**@deprecated */
type DirectPushEventTypeItem = Readonly<{
    type: 'directPush';
    name: string;
    directPushId: ValueOrRef<string>;
    tooltipContent?: string;
    optOutAtSignup?: boolean;
}>;
/**@deprecated */
type FusionTypeBase = {
    name: string;
    type: 'fusion' | 'fusionToggle';
    topicGroupName?: string;
    index?: number;
    fusionEventId: ValueOrRef<string>;
    sourceAddress: ValueOrRef<string>;
    tooltipContent?: string;
    maintainSourceGroup?: boolean;
    alertFrequency?: AlertFrequency;
    optOutAtSignup?: boolean;
    displayNameOverride?: string;
};
/**@deprecated */
type TradingPairEventTypeItem = Readonly<{
    type: 'tradingPair';
    name: string;
    tooltipContent?: string;
    tradingPairs: ValueOrRef<ReadonlyArray<string>>;
    optOutAtSignup?: boolean;
}>;
/**@deprecated */
type PriceChangeDataSource = 'coingecko';
/**@deprecated */
type PriceChangeEventTypeItem = Readonly<{
    type: 'priceChange';
    name: string;
    tokenIds: ReadonlyArray<string>;
    dataSource: PriceChangeDataSource;
    tooltipContent: string;
    optOutAtSignup?: boolean;
}>;
/**@deprecated */
type WalletBalanceEventTypeItem = Readonly<{
    type: 'walletBalance';
    name: string;
    tooltipContent?: string;
    optOutAtSignup?: boolean;
}>;
/**@deprecated */
type CustomTypeBase = {
    type: 'custom';
    name: string;
    tooltipContent: string;
    sourceType: Types.SourceType;
    filterType: string;
    sourceAddress: ValueOrRef<string>;
    optOutAtSignup?: boolean;
};
/**@deprecated */
type CustomToggleTypeItem = Readonly<{
    filterOptions: FilterOptions;
    selectedUIType: 'TOGGLE';
    optOutAtSignup?: boolean;
}>;
/**@deprecated */
type CustomHealthCheckItem = Readonly<{
    selectedUIType: 'HEALTH_CHECK';
    healthCheckSubtitle: string;
    numberType: NumberTypeSelect;
    alertFrequency: AlertFrequency;
    checkRatios: CheckRatio[];
    optOutAtSignup?: boolean;
}>;
/**@deprecated */
type RatiosBelow = Readonly<{
    type: 'below';
    ratio: number;
}>;
/**@deprecated */
type RatiosAbove = Readonly<{
    type: 'above';
    ratio: number;
}>;
/**@deprecated */
type CheckRatio = RatiosBelow | RatiosAbove;
/**@deprecated */
type CustomTopicTypeItem = CustomTypeBase & (CustomToggleTypeItem | CustomHealthCheckItem);
/**@deprecated */
type XMTPTopicTypeItem = {
    type: 'XMTP';
    name: string;
    tooltipContent: string;
    sourceType?: Types.SourceType;
    filterType: string;
    XMTPTopics: ValueOrRef<ReadonlyArray<string>>;
    optOutAtSignup?: boolean;
};
/**@deprecated */
type EventTypeItem = DirectPushEventTypeItem | BroadcastEventTypeItem | HealthCheckEventTypeItem | TradingPairEventTypeItem | LabelEventTypeItem | PriceChangeEventTypeItem | CustomTopicTypeItem | FusionEventTypeItem | WalletBalanceEventTypeItem | XMTPTopicTypeItem;
/**@deprecated */
type EventTypeConfig = ReadonlyArray<EventTypeItem>;
/**@deprecated */
type InputType = 'WebhookUrlInput' | 'WebhookHeadersInput' | 'DirectPushIdInput' | 'BroadcastIdInput';
/**@deprecated */
type InputItem = Readonly<{
    name: string;
    type: InputType;
}>;
/**@deprecated */
type InputsConfig = ReadonlyArray<InputItem>;
type ContactInfo = Readonly<{
    active: boolean;
}>;
/**@deprecated */
type WebhookHeaders = Readonly<Record<string, string>>;
/**@deprecated */
type WebhookContactInfo = ContactInfo & Readonly<{
    url: ValueOrRef<string>;
    headers: ValueOrRef<WebhookHeaders>;
}>;
/**@deprecated */
type CardConfigItemV1 = Readonly<{
    version: 'v1';
    id: string | null;
    name: string;
    eventTypes: EventTypeConfig;
    inputs: InputsConfig;
    contactInfo: ContactInfoConfig;
    isContactInfoRequired?: boolean;
    titles?: TitleSubtitleConfig;
}>;
/**@deprecated */
type TitleSubtitleConfigInactive = Readonly<{
    active: false;
}>;
/**@deprecated */
type TitleSubtitleConfigActive = Readonly<{
    active: true;
    editView: string;
    previewView: string;
    historyView: string;
    signupView: string;
    expiredView: string;
    alertDetailsView: string;
    verifyWalletsView: string;
}>;
/**@deprecated */
type TitleSubtitleConfig = TitleSubtitleConfigActive | TitleSubtitleConfigInactive;
/**@deprecated */
type FusionEventTopic = {
    uiConfig: FusionEventTypeItem;
    fusionEventDescriptor: Types.FusionEventDescriptor;
};
/**@deprecated */
type TenantConfig = {
    cardConfig: CardConfigType;
    fusionEventTopics: ReadonlyArray<FusionEventTopic>;
};

type FusionEventMetadata = {
    uiConfigOverride?: {
        topicDisplayName?: string;
        historyDisplayName?: string;
        icon?: Types.GenericEventIconHint;
        customIconUrl?: string;
        isSubscriptionValueInputable?: boolean;
        subscriptionValueOrRef?: ValueOrRef<InputObject[]>;
    };
    filters: Array<Filter>;
};
type InputObject = {
    label: string;
    value: string;
};
/**
 * @param name - `string` unique name
 */
type Filter = AlertFilter | FrequencyFilter;
type FilterBase = {
    name: string;
    executionPriority: number;
};
type FrequencyFilter = FilterBase & {
    type: 'FrequencyAlertFilter';
    minimumDurationBetweenTriggersInMinutes: number;
};
type AlertFilter = FilterBase & {
    type: 'AlertFilter';
    userInputParams: UserInputParam<UiType>[];
    staticFilterParams?: Record<string, object | string | number>;
    requiredParserVariables: Array<RequiredParserVariable>;
    description: string;
};
type RequiredParserVariable = {
    variableName: string;
    variableType: ValueType;
    variableDescription: string;
};
type ValueType = 'integer' | 'price' | 'percentage' | 'string' | 'float';
type PrefixAndSuffix = {
    prefix: string;
    suffix: string;
};
/**
 * @param UiType - `radio` or `button` (scalable). Define what component should be rendered in Card topic subscription view.
 * @param defaultValue - The value for default alert subscription
 */
type UserInputParam<T extends UiType> = {
    name: string;
    kind: ValueType;
    uiType: T;
    description: string;
    options: (string | number)[];
    defaultValue: string | number;
    allowCustomInput?: boolean;
    customInputPlaceholder?: string;
    prefixAndSuffix?: PrefixAndSuffix;
    customInputConstraints?: CustomInputConstraints;
};
type CustomInputConstraints = {
    maxDecimalPlaces?: number;
    upperBound?: number;
    lowerBound?: number;
};
type UiType = 'radio' | 'button';
type FusionFilterOptions = {
    version: 1;
    input: Record<Filter['name'], UserInputOptions>;
};
type UserInputOptions = Record<UserInputParam<UiType>['name'], UserInputParam<UiType>['options'][number]>;
/**
 * FusionNotificationHistoryEntry.fusionEventVariables
 */
type HistoryFusionEventVariables = {
    EventData: unknown;
    AlertData: unknown;
    NotifiData: {
        TenantId: string;
        TenantName: string;
        ChangeSignature: string;
        SourceTypeId: string;
        AlertId: string;
        ComparisonValue: string;
        EventTypeId: string;
        TopicHistoryDisplayName: string;
        Blockchain: string;
        PixelUrl: string;
    };
    unsubscribe_url: string;
};

declare const COSMOS_BLOCKCHAINS: readonly ["COSMOS", "OSMOSIS", "NEUTRON", "ELYS", "ARCHWAY", "AXELAR", "AGORIC", "ORAI", "KAVA", "CELESTIA", "NIBIRU", "DYMENSION", "PERSISTENCE", "DYDX", "XION"];
declare const EVM_BLOCKCHAINS: readonly ["ETHEREUM", "POLYGON", "ARBITRUM", "AVALANCHE", "BINANCE", "BOTANIX", "BOB", "MONAD", "BASE", "BLAST", "CELO", "MANTLE", "SCROLL", "LINEA", "MANTA", "BERACHAIN", "HYPEREVM", "UNICHAIN", "OPTIMISM", "THE_ROOT_NETWORK", "SEI", "SONIC", "INK", "SWELLCHAIN", "HEMI", "CORE_BLOCKCHAIN_MAINNET", "GOAT_NETWORK", "NIBURU_CATACLYSM1", "ROME", "ZKSYNC"];
declare const CARDANO_BLOCKCHAINS: readonly ["CARDANO"];
declare const APTOS_BLOCKCHAINS: readonly ["APTOS", "MOVEMENT"];
declare const SOLANA_BLOCKCHAINS: readonly ["SOLANA"];
declare const SUI_BLOCKCHAINS: readonly ["SUI"];
declare const BTC_BLOCKCHAINS: readonly ["BITCOIN", "ARCH"];
declare const UNMAINTAINED_BLOCKCHAINS: readonly ["ACALA", "EVMOS", "ABSTRACT"];
declare const _ALL_BLOCKCHAINS: readonly ["COSMOS", "OSMOSIS", "NEUTRON", "ELYS", "ARCHWAY", "AXELAR", "AGORIC", "ORAI", "KAVA", "CELESTIA", "NIBIRU", "DYMENSION", "PERSISTENCE", "DYDX", "XION", "ETHEREUM", "POLYGON", "ARBITRUM", "AVALANCHE", "BINANCE", "BOTANIX", "BOB", "MONAD", "BASE", "BLAST", "CELO", "MANTLE", "SCROLL", "LINEA", "MANTA", "BERACHAIN", "HYPEREVM", "UNICHAIN", "OPTIMISM", "THE_ROOT_NETWORK", "SEI", "SONIC", "INK", "SWELLCHAIN", "HEMI", "CORE_BLOCKCHAIN_MAINNET", "GOAT_NETWORK", "NIBURU_CATACLYSM1", "ROME", "ZKSYNC", "CARDANO", "APTOS", "MOVEMENT", "BITCOIN", "ARCH", "SOLANA", "SUI", "ACALA", "EVMOS", "ABSTRACT", "OFF_CHAIN", "NEAR", "INJECTIVE", "UNSPECIFIED"];
type Blockchain = (typeof _ALL_BLOCKCHAINS)[number];
type UnmaintainedBlockchain = (typeof UNMAINTAINED_BLOCKCHAINS)[number];
declare function isUnmaintainedBlockchain(blockchain: Blockchain): blockchain is UnmaintainedBlockchain;
declare function isUsingUnmaintainedBlockchain<T extends {
    walletBlockchain: Blockchain;
}>(params: T): params is Extract<T, {
    walletBlockchain: UnmaintainedBlockchain;
}>;
type CosmosBlockchain = (typeof COSMOS_BLOCKCHAINS)[number];
declare function isCosmosBlockchain(blockchain: Blockchain): blockchain is CosmosBlockchain;
declare function isUsingCosmosBlockchain<T extends {
    walletBlockchain: Blockchain;
}>(params: T): params is Extract<T, {
    walletBlockchain: CosmosBlockchain;
}>;
type EvmBlockchain = (typeof EVM_BLOCKCHAINS)[number];
declare function isEvmBlockchain(blockchain: Blockchain): blockchain is EvmBlockchain;
declare function isUsingEvmBlockchain<T extends {
    walletBlockchain: Blockchain;
}>(params: T): params is Extract<T, {
    walletBlockchain: EvmBlockchain;
}>;
type AptosBlockchain = (typeof APTOS_BLOCKCHAINS)[number];
declare function isAptosBlockchain(blockchain: Blockchain): blockchain is AptosBlockchain;
declare function isUsingAptosBlockchain<T extends {
    walletBlockchain: Blockchain;
}>(params: T): params is Extract<T, {
    walletBlockchain: AptosBlockchain;
}>;
type BtcBlockchain = (typeof BTC_BLOCKCHAINS)[number];
declare function isBtcBlockchain(blockchain: Blockchain): blockchain is BtcBlockchain;
declare function isUsingBtcBlockchain<T extends {
    walletBlockchain: Blockchain;
}>(params: T): params is Extract<T, {
    walletBlockchain: BtcBlockchain;
}>;
type SolanaBlockchain = (typeof SOLANA_BLOCKCHAINS)[number];
declare function isSolanaBlockchain(blockchain: Blockchain): blockchain is SolanaBlockchain;
declare function isUsingSolanaBlockchain<T extends {
    walletBlockchain: Blockchain;
}>(params: T): params is Extract<T, {
    walletBlockchain: SolanaBlockchain;
}>;
type SuiBlockchain = (typeof SUI_BLOCKCHAINS)[number];
declare function isSuiBlockchain(blockchain: Blockchain): blockchain is SuiBlockchain;
declare function isUsingSuiBlockchain<T extends {
    walletBlockchain: Blockchain;
}>(params: T): params is Extract<T, {
    walletBlockchain: SuiBlockchain;
}>;
type CardanoBlockchain = (typeof CARDANO_BLOCKCHAINS)[number];
declare function isCardanoBlockchain(blockchain: Blockchain): blockchain is CardanoBlockchain;
declare function isUsingCardanoBlockchain<T extends {
    walletBlockchain: Blockchain;
}>(params: T): params is Extract<T, {
    walletBlockchain: CardanoBlockchain;
}>;

/**
 * =============================================================================
 * Why we need both `UserParams` and `AuthParams`
 * =============================================================================
 *
 * At first glance, `UserParams` and `AuthParams` may look redundant—
 * both describe information about a user's blockchain wallet.
 * However, they are defined from **two fundamentally different perspectives**:
 *
 * -----------------------------------------------------------------------------
 * 1. `UserParams`: Grouped by `walletBlockchain` (chain-based classification)
 * -----------------------------------------------------------------------------
 * - Each supported blockchain (e.g., SOLANA, EVM, APTOS, COSMOS, etc.)
 *   gets its own specific structure under `UserParams`.
 * - This allows us to define *chain-specific* behaviors and requirements,
 *   even when some fields may be shared.
 * - Example:
 *     - `SolanaUserParams` and `EvmUserParams` both contain `walletPublicKey`
 *     - `CosmosUserParams` has two *distinct shapes* for the same chain
 * - So even for the same `walletBlockchain`, the structure may vary!
 *
 * -----------------------------------------------------------------------------
 * 2. `AuthParams`: Grouped by data structure (field-based classification)
 * -----------------------------------------------------------------------------
 * - Represents authentication input grouped by the *shape of the object*,
 *   not by which chain it's for.
 * - This is useful for extracting behavior based on *what data is present*,
 *   not which blockchain it belongs to.
 * - Example:
 *     - All objects with `walletPublicKey + accountAddress` fall under
 *       `BlockchainAuthParamsWithPublicKeyAndAddress`, regardless of chain.
 *     - Off-chain login (`userAccount`) always maps to `OidcAuthParams`
 *
 * -----------------------------------------------------------------------------
 * Summary:
 * -----------------------------------------------------------------------------
 * - `UserParams` answers: **"What does a user look like on this chain?"**
 * - `AuthParams` answers: **"What kind of auth strategy does this object represent?"**
 *
 * The need to handle:
 *   - multiple data shapes per chain (e.g., Cosmos),
 *   - and common shapes across chains,
 * makes it impossible to use just one classification axis.
 * Thus, **both type groups are necessary** for type safety, flexibility, and clarity.
 */
/** Keeps internal in purpose. If needed, use Typescript Extract.
 *  e.g. Extract<AuthParams, { walletPublicKey: string }> */
type BlockchainAuthParamsWithPublicKey = {
    walletBlockchain: EvmBlockchain | 'SOLANA' | 'CARDANO';
    walletPublicKey: string;
};
/** NOTE: Extract<AuthParams, { delegatedAddress: string }> */
type BlockchainAuthParamsWithDelegate = {
    walletBlockchain: CosmosBlockchain;
    delegatedAddress: string;
    delegatedPublicKey: string;
    delegatorAddress: string;
};
/** NOTE: Extract<AuthParams, { authenticationKey: string }> */
type BlockchainAuthParamsWithPublicKeyAndAddress = {
    walletBlockchain: Exclude<Types.BlockchainType, EvmBlockchain | 'SOLANA' | 'OFF_CHAIN' | 'UNSPECIFIED'>;
    walletPublicKey: string;
    accountAddress: string;
};
/** NOTE: Extract<AuthParams, { userAccount: string }> */
type OidcAuthParams = {
    walletBlockchain: 'OFF_CHAIN';
    userAccount: string;
};
type AuthParams = BlockchainAuthParamsWithPublicKey | BlockchainAuthParamsWithPublicKeyAndAddress | BlockchainAuthParamsWithDelegate | OidcAuthParams;
type SolanaUserParams = Readonly<{
    walletBlockchain: 'SOLANA';
    walletPublicKey: string;
    hardwareLoginPlugin?: {
        /**
         * @deprecated Use signTransaction() instead. We no longer have to send a txn, and instead simply rely on the signed TX as we can verify this on Notifi Services.
         */
        sendMessage?: (message: string) => Promise<string>;
        signTransaction: (message: string) => Promise<string>;
    };
}>;
type EvmUserParams = Readonly<{
    walletBlockchain: EvmBlockchain;
    walletPublicKey: string;
}>;
type AptosUserParams = Readonly<{
    walletBlockchain: AptosBlockchain;
    accountAddress: string;
    walletPublicKey: string;
}>;
type BtcUserParams = Readonly<{
    walletBlockchain: BtcBlockchain;
    accountAddress: string;
    walletPublicKey: string;
}>;
type InjectiveUserParams = Readonly<{
    walletBlockchain: 'INJECTIVE';
    accountAddress: string;
    walletPublicKey: string;
}>;
type CosmosUserParams = Readonly<{
    walletBlockchain: CosmosBlockchain;
    accountAddress: string;
    walletPublicKey: string;
}> | Readonly<{
    walletBlockchain: CosmosBlockchain;
    walletPublicKey: string;
    signingAddress: string;
    signingPubkey: string;
}>;
type UnmaintainedUserParams = Readonly<{
    walletBlockchain: UnmaintainedBlockchain;
    accountAddress: string;
    walletPublicKey: string;
}>;
type NearUserParams = Readonly<{
    walletBlockchain: 'NEAR';
    accountAddress: string;
    walletPublicKey: string;
}>;
type CardanoUserParams = Readonly<{
    walletBlockchain: 'CARDANO';
    walletPublicKey: string;
}>;
type SuiUserParams = Readonly<{
    walletBlockchain: 'SUI';
    accountAddress: string;
    walletPublicKey: string;
}>;
type OffChainUserParams = Readonly<{
    walletBlockchain: 'OFF_CHAIN';
    userAccount: string;
}>;
type UserParams = SolanaUserParams | EvmUserParams | AptosUserParams | NearUserParams | CardanoUserParams | SuiUserParams | CosmosUserParams | OffChainUserParams | UnmaintainedUserParams | BtcUserParams | InjectiveUserParams;
declare const checkIsConfigWithPublicKeyAndAddress: <T extends AuthParams>(config: T) => config is Extract<T, BlockchainAuthParamsWithPublicKeyAndAddress>;
declare const checkIsConfigWithPublicKey: <T extends AuthParams>(config: T) => config is Extract<T, BlockchainAuthParamsWithPublicKey>;
declare const checkIsConfigWithDelegate: <T extends AuthParams>(config: T) => config is Extract<T, BlockchainAuthParamsWithDelegate>;
declare const checkIsConfigWithOidc: <T extends AuthParams>(config: T) => config is Extract<T, OidcAuthParams>;

type NotifiEnvironment = 'Production' | 'Staging' | 'Development' | 'Local';
declare const envUrl: (env?: NotifiEnvironment, endpointType?: "websocket" | "http", endpoint?: "notifi-graphql" | "notifi-dataplane") => string;

/** Initializes the NotifiFrontendClient with the given configuration. */
type NotifiFrontendConfiguration = AuthParams & Readonly<{
    env?: NotifiEnvironment;
    tenantId: string;
    storageOption?: Readonly<{
        driverType?: 'LocalForage' | 'InMemory';
    }>;
}>;
/** Initializes the NotifiSmartLinkClient with the given configuration. */
type NotifiSmartLinkClientConfig = {
    env?: NotifiEnvironment;
    authParams?: AuthParams;
};

/**@deprecated Use NotifiFrontendConfiguration instead */
type NotifiEnvironmentConfiguration = Readonly<{
    env?: NotifiEnvironment;
    tenantId: string;
    storageOption?: Readonly<{
        driverType?: 'LocalForage' | 'InMemory';
    }>;
}>;
/**@deprecated Extract from AuthParm instead */
type NotifiConfigWithPublicKey = Extract<NotifiFrontendConfiguration, {
    walletPublicKey: string;
} & {
    accountAddress?: never;
}>;
/**@deprecated Extract from AuthParm instead */
type NotifiConfigWithPublicKeyAndAddress = Extract<NotifiFrontendConfiguration, {
    accountAddress: string;
}>;
/**@deprecated Extract from AuthParm instead */
type NotifiConfigWithDelegate = Extract<NotifiFrontendConfiguration, {
    delegatedAddress: string;
}>;
/**@deprecated No longer need to use configFactory, use instantiateFrontendClient instead */
type ConfigFactoryInput = ConfigFactoryInputPublicKeyAndAddress | ConfigFactoryInputPublicKey | ConfigFactoryInputDelegated | ConfigFactoryInputOidc;
/**@deprecated No longer need to use configFactory, use instantiateFrontendClient instead */
type ConfigFactoryInputDelegated = {
    account: Readonly<{
        address: string;
        publicKey: string;
        delegatorAddress: string;
    }>;
    tenantId: string;
    env?: NotifiEnvironment;
    walletBlockchain: NotifiConfigWithDelegate['walletBlockchain'];
    storageOption?: NotifiFrontendConfiguration['storageOption'];
};
/**@deprecated No longer need to use configFactory, use instantiateFrontendClient instead */
type ConfigFactoryInputPublicKeyAndAddress = {
    account: Readonly<{
        address: string;
        publicKey: string;
    }>;
    tenantId: string;
    env?: NotifiEnvironment;
    walletBlockchain: NotifiConfigWithPublicKeyAndAddress['walletBlockchain'];
    storageOption?: NotifiFrontendConfiguration['storageOption'];
};
/**@deprecated No longer need to use configFactory, use instantiateFrontendClient instead */
type ConfigFactoryInputPublicKey = {
    account: Readonly<{
        publicKey: string;
    }>;
    tenantId: string;
    env?: NotifiEnvironment;
    walletBlockchain: NotifiConfigWithPublicKey['walletBlockchain'];
    storageOption?: NotifiFrontendConfiguration['storageOption'];
};
/**@deprecated No longer need to use configFactory, use instantiateFrontendClient instead */
type ConfigFactoryInputOidc = {
    account: Readonly<{
        userAccount: string;
    }>;
    tenantId: string;
    env?: NotifiEnvironment;
    walletBlockchain: 'OFF_CHAIN';
    storageOption?: NotifiFrontendConfiguration['storageOption'];
};
/**@deprecated No longer need to use configFactory, use instantiateFrontendClient instead */
type FrontendClientConfigFactory<T extends NotifiFrontendConfiguration> = (args: T extends NotifiConfigWithPublicKeyAndAddress ? ConfigFactoryInputPublicKeyAndAddress : T extends NotifiConfigWithDelegate ? ConfigFactoryInputDelegated : T extends NotifiConfigWithPublicKey ? ConfigFactoryInputPublicKey : ConfigFactoryInputOidc) => NotifiFrontendConfiguration;
/**@deprecated Legacy type only for backward compatibility. Use `LoginParamsWithUserParams` in `notifi-react` instead. */
type WalletWithSignParams = LoginParams & UserParams;
/**@deprecated No longer need to use configFactory, use instantiateFrontendClient instead */
declare const newFrontendConfig: (config: ConfigFactoryInput) => NotifiFrontendConfiguration;

declare const notNullOrEmpty: <T>(item: T | undefined | null) => item is T;

type ResolveFunc<T> = (name: string, valueOrRef: ValueOrRef<T>, inputs: Record<string, unknown>) => T;
declare const resolveStringRef: ResolveFunc<string>;
declare const resolveNumberRef: ResolveFunc<number>;
declare const resolveStringArrayRef: ResolveFunc<readonly string[]>;
declare const resolveCheckRatioArrayRef: ResolveFunc<readonly CheckRatio[]>;
declare const resolveObjectArrayRef: ResolveFunc<readonly InputObject[]>;

/**
 * @description Returns an array of the object's keys with the correct type.
 * @example
 * const destinations: Record<FormField, string> = { email: 'email', phoneNumber: 'phoneNumber' };
 * const keys = objectKeys(destinations); // type of Keys is FormField[] instead of string[] (which is the default type of Object.keys)
 */
declare const objectKeys: <T extends Record<keyof T, unknown>>(object: T) => (keyof T)[];
type DeepPartialReadonly<T> = T extends object ? Readonly<{
    [Key in keyof T]?: DeepPartialReadonly<T[Key]>;
}> : T;

declare const normalizeHexString: (input: string) => string;

declare const parseTenantConfig: (dataJson: string) => CardConfigItemV2 | CardConfigItemV1;

/**
 * Base class for all Notifi errors
 */
declare class NotifiError extends Error {
    readonly errorType: string;
    readonly code: string;
    readonly timestamp: number;
    readonly cause?: unknown;
    constructor(message: string, errorType: string, code: string, cause?: unknown);
    /** Type guard: validate Payload Error (includes __typename) */
    private static isPayloadError;
    /** Convert Payload Error to NotifiError using mapping */
    private static fromPayloadError;
    /** Main entry point: convert any error to NotifiError */
    static from(e: unknown): NotifiError;
    /**
     * Check payload errors and throw if exists
     * @throws {NotifiError} if payload contains errors
     */
    static throwIfPayloadError<T extends {
        errors?: ReadonlyArray<{
            __typename: string;
            message: string;
        } | null> | null;
    }>(payload: T): T;
}
/**
 * Error for unknown/unclassified errors
 */
declare class NotifiUnknownError extends NotifiError {
    constructor(message: string, code: string, cause?: unknown);
}
/**
 * Error for target-related issues
 */
declare class NotifiTargetError extends NotifiError {
    constructor(message: string, code: string, cause?: unknown);
}
/**
 * Error for authentication-related issues
 */
declare class NotifiAuthenticationError extends NotifiError {
    constructor(message: string, code: string, cause?: unknown);
}
/**
 * Error for validation-related issues
 */
declare class NotifiValidationError extends NotifiError {
    constructor(message: string, code: string, cause?: unknown);
}
/**
 * Error type constructor
 */
type ErrorConstructor = new (message: string, code: string, cause?: unknown) => NotifiError;
/**
 * Mapping from GraphQL __typename to NotifiError subclass
 */
declare const ERROR_TYPE_MAP: Record<string, ErrorConstructor>;

export { APTOS_BLOCKCHAINS, type ActionInputParams, type ActionInputParamsCheckBox, type ActionInputParamsTextBox, type AlertFilter, type AlertFrequency, type AptosBlockchain, type AptosUserParams, AuthManager, type AuthParams, type AuthenticateResult, type Authorization, type AuthorizationStorage, BTC_BLOCKCHAINS, type BlockchainAuthParamsWithDelegate, type BlockchainAuthParamsWithPublicKey, type BlockchainAuthParamsWithPublicKeyAndAddress, type BlockchainAuthStrategy, type BroadcastEventTypeItem, type BtcBlockchain, type BtcUserParams, CARDANO_BLOCKCHAINS, CHAINS_WITH_LOGIN_WEB3, COSMOS_BLOCKCHAINS, type CardConfigItemV1, type CardConfigItemV2, type CardConfigType, type CardanoBlockchain, type CardanoUserParams, type CheckRatio, type ConfigFactoryInput, type ConfigFactoryInputDelegated, type ConfigFactoryInputOidc, type ConfigFactoryInputPublicKey, type ConfigFactoryInputPublicKeyAndAddress, type ContactInfo, type ContactInfoConfig, type CosmosBlockchain, type CosmosUserParams, type CountryCode, type CreateFunc, type CustomHealthCheckItem, type CustomInputConstraints, type CustomToggleTypeItem, type CustomTopicTypeItem, type CustomTypeBase, type DeepPartialReadonly, type DirectPushEventTypeItem, ERROR_TYPE_MAP, EVM_BLOCKCHAINS, type EventTypeConfig, type EventTypeItem, type EvmBlockchain, type EvmUserParams, type FetchFunc, type Filter, type FilterBase, type FilterOptions, type FrequencyFilter, type FrontendClientConfigFactory, type FusionEventMetadata, type FusionEventTopic, type FusionEventTypeItem, type FusionFilterOptions, type FusionHealthCheckEventTypeItem, type FusionMultiThreshholdEventTypeItem, type FusionToggleEventTypeItem, type FusionTypeBase, type GetStorageType, type HasStorageType, type HealthCheckEventTypeItem, type HistoryFusionEventVariables, type IdentifyFunc, type InjectiveUserParams, type InputItem, type InputObject, type InputType, type InputsConfig, type LabelEventTypeItem, type LabelUiConfig, type LoginParams, type LoginWeb3Params, type NearUserParams, NotifiAuthenticationError, type NotifiEnvironment, type NotifiEnvironmentConfiguration, NotifiError, NotifiFrontendClient, type NotifiFrontendConfiguration, NotifiFrontendStorage, NotifiSmartLinkClient, type NotifiSmartLinkClientConfig, type NotifiStorage, NotifiTargetError, NotifiUnknownError, NotifiValidationError, type NumberTypeSelect, type OffChainUserParams, type OidcAuthParams, type OidcCredentials, type OidcSignInFunction, type PrefixAndSuffix, type PriceChangeDataSource, type PriceChangeEventTypeItem, type RequiredParserVariable, type Roles, type RolesStorage, SIGNING_MESSAGE, SIGNING_MESSAGE_WITHOUT_NONCE, SOLANA_BLOCKCHAINS, SUI_BLOCKCHAINS, type SetStorageType, type SignMessageParams, type SignMessageResult, type SmartLinkAction, type SmartLinkConfig, type SmartLinkImg, type SmartLinkTxt, type SmsContactInfo, type SolanaBlockchain, type SolanaUserParams, type StorageDriver, type StorageType, type SuiBlockchain, type SuiUserParams, type TenantConfig, type TenantConfigTarget, type TenantConfigV2, type ThresholdDirection, type TitleSubtitleConfig, type TitleSubtitleConfigActive, type TitleSubtitleConfigInactive, type TopicMetadata, type TopicUiConfig, type TradingPairEventTypeItem, UNMAINTAINED_BLOCKCHAINS, type UiType, type Uint8SignMessageFunction, type UnmaintainedBlockchain, type UnmaintainedUserParams, type UserInputOptions, type UserInputParam, type UserParams, type UserState, type ValidInputRange, type ValueItemConfig, type ValueOrRef, type ValueTransformFunc, type ValueType, type WalletBalanceEventTypeItem, type WalletWithSignParams, type WebhookContactInfo, type WebhookHeaders, type XMTPTopicTypeItem, beginLogInWithWeb3, checkIsConfigWithDelegate, checkIsConfigWithOidc, checkIsConfigWithPublicKey, checkIsConfigWithPublicKeyAndAddress, createInMemoryStorageDriver, createLocalForageStorageDriver, ensureDiscord, ensureEmail, ensureSlack, ensureSms, ensureTarget, ensureTelegram, ensureWeb3, envUrl, getStrategyForBlockchain, instantiateFrontendClient, isAptosBlockchain, isBtcBlockchain, isCardanoBlockchain, isCosmosBlockchain, isEvmBlockchain, isLoginWeb3Params, isSmartLinkConfig, isSolanaBlockchain, isSuiBlockchain, isUnmaintainedBlockchain, isUsingAptosBlockchain, isUsingBtcBlockchain, isUsingCardanoBlockchain, isUsingCosmosBlockchain, isUsingEvmBlockchain, isUsingSolanaBlockchain, isUsingSuiBlockchain, isUsingUnmaintainedBlockchain, newFrontendClient, newFrontendConfig, newSmartLinkClient, normalizeHexString, notNullOrEmpty, objectKeys, parseTenantConfig, renewTelegram, resolveCheckRatioArrayRef, resolveNumberRef, resolveObjectArrayRef, resolveStringArrayRef, resolveStringRef };