export type ParachainId = number;
export type HexString = `0x${string}`;
export declare enum RouteType {
    GMP = "gmp",
    FUNGIBLE = "fungible"
}
export declare enum Environment {
    LOCAL = "local",
    DEVNET = "devnet",
    TESTNET = "testnet",
    MAINNET = "mainnet"
}
export declare enum Network {
    EVM = "evm",
    SUBSTRATE = "substrate",
    BITCOIN = "btc"
}
export declare enum SecurityModel {
    MPC = "mpc"
}
export type Domain = {
    id: number;
    caipId: string;
    chainId: number;
    name: string;
    iconUrl?: string;
    type: Network;
    parachainId?: ParachainId;
    feeAddress?: string;
};
export type Resource = EvmResource | SubstrateResource | BitcoinResource;
export declare enum ResourceType {
    FUNGIBLE = "fungible",
    NON_FUNGIBLE = "nonfungible",
    PERMISSIONED_GENERIC = "permissionedGeneric",
    PERMISSIONLESS_GENERIC = "permissionlessGeneric",
    SEMI_FUNGIBLE = "semifungible"
}
interface BaseResource {
    resourceId: string;
    caip19: string;
    type: ResourceType;
    iconUrl?: string;
    native?: boolean;
    burnable?: boolean;
    symbol?: string;
    decimals?: number;
}
export type EvmResource = BaseResource & {
    address: string;
};
export declare enum FeeHandlerType {
    TWAP = "twap",
    BASIC = "basic",
    PERCENTAGE = "percentage"
}
export type XcmMultiAssetIdType = {
    concrete: {
        parents: number;
        interior: 'here' | {
            x3: Array<{
                parachain: number;
            } | {
                generalKey: [number, string];
            }>;
        };
    };
};
export type BitcoinResource = BaseResource & {
    address: string;
    script: string;
    tweak: string;
    feeAmount?: number;
};
export type SubstrateResource = BaseResource & {
    assetID?: number;
    assetName: string;
    xcmMultiAssetId: XcmMultiAssetIdType;
};
export type Route = {
    fromDomain: Domain;
    toDomain: Domain;
    resource: Resource;
    feeHandler?: FeeHandler;
};
export type TransferStatus = 'pending' | 'executed' | 'failed';
export type TransferStatusResponse = {
    status: TransferStatus;
    explorerUrl: string;
    fromDomainId: number;
    toDomainId: number;
    sourceHash: string;
    destinationHash: string;
    depositNonce: number;
};
export interface BaseConfig<T> {
    id: number;
    chainId: number;
    caipId: string;
    name: string;
    type: T;
    bridge: string;
    nativeTokenSymbol: string;
    nativeTokenFullName: string;
    nativeTokenDecimals: bigint;
    startBlock: bigint;
    blockConfirmations: number;
    resources: Array<Resource>;
}
export type FeeHandler = {
    type: FeeHandlerType;
    address: string;
};
export interface EthereumConfig extends BaseConfig<Network.EVM> {
    handlers: Array<Handler>;
    nativeTokenAdapter: string;
    feeRouter: string;
    feeHandlers: Array<FeeHandler>;
}
export interface SubstrateConfig extends BaseConfig<Network.SUBSTRATE> {
    handlers: Array<Handler>;
    parachainId: ParachainId;
}
export interface BitcoinConfig extends BaseConfig<Network.BITCOIN> {
    feeAddress: string;
}
export type SygmaDomainConfig = EthereumConfig | SubstrateConfig | BitcoinConfig;
export type IndexerRoutesResponse = {
    routes: RouteIndexerType[];
};
export type Handler = {
    type: ResourceType;
    address: string;
};
export interface SygmaConfig {
    domains: Array<EthereumConfig | SubstrateConfig | BitcoinConfig>;
}
export type RouteIndexerType = {
    fromDomainId: string;
    toDomainId: string;
    resourceId: string;
    type: RouteType;
};
export type DomainMetadata = {
    url: string;
};
export type EnvironmentMetadata = {
    [key: number]: DomainMetadata;
};
export type Domainlike = string | number | Domain;
export interface Eip1193Provider {
    request(request: {
        method: string;
        params?: Array<unknown> | Record<string, unknown>;
    }): Promise<unknown>;
}
export {};
//# sourceMappingURL=types.d.ts.map