export type bigint_like = number | bigint | string;
export declare enum AddressType {
    BASE_PAYMENT_KEY_STAKE_KEY = 0,
    BASE_PAYMENT_SCRIPT_STAKE_KEY = 1,
    BASE_PAYMENT_KEY_STAKE_SCRIPT = 2,
    BASE_PAYMENT_SCRIPT_STAKE_SCRIPT = 3,
    POINTER_KEY = 4,
    POINTER_SCRIPT = 5,
    ENTERPRISE_KEY = 6,
    ENTERPRISE_SCRIPT = 7,
    BYRON = 8,
    REWARD_KEY = 14,
    REWARD_SCRIPT = 15
}
export declare enum CertificateType {
    STAKE_REGISTRATION = 0,
    STAKE_DEREGISTRATION = 1,
    STAKE_DELEGATION = 2,
    STAKE_POOL_REGISTRATION = 3,
    STAKE_POOL_RETIREMENT = 4,
    STAKE_REGISTRATION_CONWAY = 7,
    STAKE_DEREGISTRATION_CONWAY = 8,
    VOTE_DELEGATION = 9,
    STAKE_POOL_AND_DREP_DELEGATION = 10,
    ACCOUNT_REGISTRATION_DELEGATION_TO_STAKE_POOL = 11,
    ACCOUNT_REGISTRATION_DELEGATION_TO_DREP = 12,
    ACCOUNT_REGISTRATION_DELEGATION_TO_STAKE_POOL_AND_DREP = 13,
    AUTHORIZE_COMMITTEE_HOT = 14,
    RESIGN_COMMITTEE_COLD = 15,
    DREP_REGISTRATION = 16,
    DREP_DEREGISTRATION = 17,
    DREP_UPDATE = 18
}
export declare const enum RelayType {
    SINGLE_HOST_IP_ADDR = 0,
    SINGLE_HOST_HOSTNAME = 1,
    MULTI_HOST = 2
}
export declare const HARDENED = 2147483648;
export type BIP32Path = Array<number>;
export type Network = {
    protocolMagic: number;
    networkId: number;
};
export type DeviceOwnedAddress = {
    type: AddressType.BYRON;
    params: AddressParamsByron;
} | {
    type: AddressType.BASE_PAYMENT_KEY_STAKE_KEY | AddressType.BASE_PAYMENT_SCRIPT_STAKE_KEY | AddressType.BASE_PAYMENT_KEY_STAKE_SCRIPT | AddressType.BASE_PAYMENT_SCRIPT_STAKE_SCRIPT;
    params: AddressParamsBase;
} | {
    type: AddressType.ENTERPRISE_KEY | AddressType.ENTERPRISE_SCRIPT;
    params: AddressParamsEnterprise;
} | {
    type: AddressType.POINTER_KEY | AddressType.POINTER_SCRIPT;
    params: AddressParamsPointer;
} | {
    type: AddressType.REWARD_KEY | AddressType.REWARD_SCRIPT;
    params: AddressParamsReward;
};
export type AddressParamsByron = {
    spendingPath: BIP32Path;
};
export type SpendingParams = {
    spendingPath: BIP32Path;
} | {
    spendingScriptHashHex: string;
};
export type AddressParamsBase = SpendingParams & ({
    stakingPath: BIP32Path;
} | {
    stakingKeyHashHex: string;
} | {
    stakingScriptHashHex: string;
});
export type AddressParamsEnterprise = SpendingParams;
export type AddressParamsPointer = SpendingParams & {
    stakingBlockchainPointer: BlockchainPointer;
};
export type AddressParamsReward = {
    stakingPath: BIP32Path;
} | {
    stakingScriptHashHex: string;
};
export type OperationalCertificate = {
    kesPublicKeyHex: string;
    kesPeriod: bigint_like;
    issueCounter: bigint_like;
    coldKeyPath: BIP32Path;
};
export declare enum MessageAddressFieldType {
    ADDRESS = "address",
    KEY_HASH = "key_hash"
}
export type MessageData = {
    messageHex: string;
    signingPath: BIP32Path;
    hashPayload: boolean;
    preferHexDisplay?: boolean;
} & ({
    addressFieldType: MessageAddressFieldType.ADDRESS;
    address: DeviceOwnedAddress;
    network: Network;
} | {
    addressFieldType: MessageAddressFieldType.KEY_HASH;
});
export type CIP36Vote = {
    voteCastDataHex: string;
    witnessPath: BIP32Path;
};
export type TxInput = {
    txHashHex: string;
    outputIndex: number;
    path: BIP32Path | null;
};
export type Token = {
    assetNameHex: string;
    amount: bigint_like;
};
export type AssetGroup = {
    policyIdHex: string;
    tokens: Array<Token>;
};
export declare enum DatumType {
    HASH = 0,
    INLINE = 1
}
export type Datum = {
    type: DatumType.HASH;
    datumHashHex: string;
} | {
    type: DatumType.INLINE;
    datumHex: string;
};
export declare enum TxOutputFormat {
    ARRAY_LEGACY = 0,
    MAP_BABBAGE = 1
}
export type TxOutputAlonzo = {
    format?: TxOutputFormat.ARRAY_LEGACY;
    destination: TxOutputDestination;
    amount: bigint_like;
    tokenBundle?: Array<AssetGroup> | null;
    datumHashHex?: string | null;
};
export type TxOutputBabbage = {
    format: TxOutputFormat.MAP_BABBAGE;
    destination: TxOutputDestination;
    amount: bigint_like;
    tokenBundle?: Array<AssetGroup> | null;
    datum?: Datum | null;
    referenceScriptHex?: string | null;
};
export type TxOutput = TxOutputAlonzo | TxOutputBabbage;
export declare enum TxOutputDestinationType {
    THIRD_PARTY = "third_party",
    DEVICE_OWNED = "device_owned"
}
export type ThirdPartyAddressParams = {
    addressHex: string;
};
export type TxOutputDestination = {
    type: TxOutputDestinationType.THIRD_PARTY;
    params: ThirdPartyAddressParams;
} | {
    type: TxOutputDestinationType.DEVICE_OWNED;
    params: DeviceOwnedAddress;
};
export type BlockchainPointer = {
    blockIndex: number;
    txIndex: number;
    certificateIndex: number;
};
export declare enum PoolKeyType {
    THIRD_PARTY = "third_party",
    DEVICE_OWNED = "device_owned"
}
export type PoolKey = {
    type: PoolKeyType.THIRD_PARTY;
    params: PoolKeyThirdPartyParams;
} | {
    type: PoolKeyType.DEVICE_OWNED;
    params: PoolKeyDeviceOwnedParams;
};
export type PoolKeyThirdPartyParams = {
    keyHashHex: string;
};
export type PoolKeyDeviceOwnedParams = {
    path: BIP32Path;
};
export declare enum PoolOwnerType {
    THIRD_PARTY = "third_party",
    DEVICE_OWNED = "device_owned"
}
export type PoolOwner = {
    type: PoolOwnerType.THIRD_PARTY;
    params: PoolOwnerThirdPartyParams;
} | {
    type: PoolOwnerType.DEVICE_OWNED;
    params: PoolOwnerDeviceOwnedParams;
};
export type PoolOwnerThirdPartyParams = {
    stakingKeyHashHex: string;
};
export type PoolOwnerDeviceOwnedParams = {
    stakingPath: BIP32Path;
};
export declare enum PoolRewardAccountType {
    THIRD_PARTY = "third_party",
    DEVICE_OWNED = "device_owned"
}
export type PoolRewardAccount = {
    type: PoolRewardAccountType.THIRD_PARTY;
    params: PoolRewardAccountThirdPartyParams;
} | {
    type: PoolRewardAccountType.DEVICE_OWNED;
    params: PoolRewardAccountDeviceOwnedParams;
};
export type PoolRewardAccountThirdPartyParams = {
    rewardAccountHex: string;
};
export type PoolRewardAccountDeviceOwnedParams = {
    path: BIP32Path;
};
export type SingleHostIpAddrRelayParams = {
    portNumber?: number | null;
    ipv4?: string | null;
    ipv6?: string | null;
};
export type SingleHostHostnameRelayParams = {
    portNumber?: number | null;
    dnsName: string;
};
export type MultiHostRelayParams = {
    dnsName: string;
};
export type Relay = {
    type: RelayType.SINGLE_HOST_IP_ADDR;
    params: SingleHostIpAddrRelayParams;
} | {
    type: RelayType.SINGLE_HOST_HOSTNAME;
    params: SingleHostHostnameRelayParams;
} | {
    type: RelayType.MULTI_HOST;
    params: MultiHostRelayParams;
};
export type PoolMetadataParams = {
    metadataUrl: string;
    metadataHashHex: string;
};
export type Margin = {
    numerator: bigint_like;
    denominator: bigint_like;
};
export type PoolRegistrationParams = {
    poolKey: PoolKey;
    vrfKeyHashHex: string;
    pledge: bigint_like;
    cost: bigint_like;
    margin: Margin;
    rewardAccount: PoolRewardAccount;
    poolOwners: Array<PoolOwner>;
    relays: Array<Relay>;
    metadata?: PoolMetadataParams | null;
};
export type PoolRetirementParams = {
    poolKeyPath: BIP32Path;
    retirementEpoch: bigint_like;
};
export declare enum CredentialParamsType {
    KEY_PATH = 0,
    KEY_HASH = 1,
    SCRIPT_HASH = 2
}
export type KeyPathCredentialParams = {
    type: CredentialParamsType.KEY_PATH;
    keyPath: BIP32Path;
};
export type KeyHashCredentialParams = {
    type: CredentialParamsType.KEY_HASH;
    keyHashHex: string;
};
export type ScriptHashCredentialParams = {
    type: CredentialParamsType.SCRIPT_HASH;
    scriptHashHex: string;
};
export type CredentialParams = KeyPathCredentialParams | KeyHashCredentialParams | ScriptHashCredentialParams;
export declare enum DRepParamsType {
    KEY_PATH = 0,
    KEY_HASH = 1,
    SCRIPT_HASH = 2,
    ABSTAIN = 3,
    NO_CONFIDENCE = 4
}
export type KeyPathDRepParams = {
    type: DRepParamsType.KEY_PATH;
    keyPath: BIP32Path;
};
export type KeyHashDRepParams = {
    type: DRepParamsType.KEY_HASH;
    keyHashHex: string;
};
export type ScriptHashDRepParams = {
    type: DRepParamsType.SCRIPT_HASH;
    scriptHashHex: string;
};
export type AbstainDRepParams = {
    type: DRepParamsType.ABSTAIN;
};
export type NoConfidenceParams = {
    type: DRepParamsType.NO_CONFIDENCE;
};
export type DRepParams = KeyPathDRepParams | KeyHashDRepParams | ScriptHashDRepParams | AbstainDRepParams | NoConfidenceParams;
export type AnchorParams = {
    url: string;
    hashHex: string;
};
export type StakeRegistrationParams = {
    stakeCredential: CredentialParams;
};
export type StakeRegistrationConwayParams = {
    stakeCredential: CredentialParams;
    deposit: bigint_like;
};
export type StakeDeregistrationParams = {
    stakeCredential: CredentialParams;
};
export type StakeDeregistrationConwayParams = {
    stakeCredential: CredentialParams;
    deposit: bigint_like;
};
export type StakeDelegationParams = {
    stakeCredential: CredentialParams;
    poolKeyHashHex: string;
};
export type VoteDelegationParams = {
    stakeCredential: CredentialParams;
    dRep: DRepParams;
};
export type StakePoolAndDRepDelegationParams = {
    stakeCredential: CredentialParams;
    poolKeyHashHex: string;
    dRep: DRepParams;
};
export type AccountRegistrationDelegationToStakePoolParams = {
    stakeCredential: CredentialParams;
    poolKeyHashHex: string;
    deposit: bigint_like;
};
export type AccountRegistrationDelegationToDRepParams = {
    stakeCredential: CredentialParams;
    dRep: DRepParams;
    deposit: bigint_like;
};
export type AccountRegistrationDelegationToStakePoolAndDRepParams = {
    stakeCredential: CredentialParams;
    poolKeyHashHex: string;
    dRep: DRepParams;
    deposit: bigint_like;
};
export type AuthorizeCommitteeParams = {
    coldCredential: CredentialParams;
    hotCredential: CredentialParams;
};
export type ResignCommitteeParams = {
    coldCredential: CredentialParams;
    anchor?: AnchorParams | null;
};
export type DRepRegistrationParams = {
    dRepCredential: CredentialParams;
    deposit: bigint_like;
    anchor?: AnchorParams | null;
};
export type DRepDeregistrationParams = {
    dRepCredential: CredentialParams;
    deposit: bigint_like;
};
export type DRepUpdateParams = {
    dRepCredential: CredentialParams;
    anchor?: AnchorParams | null;
};
export type Certificate = {
    type: CertificateType.STAKE_REGISTRATION;
    params: StakeRegistrationParams;
} | {
    type: CertificateType.STAKE_DEREGISTRATION;
    params: StakeDeregistrationParams;
} | {
    type: CertificateType.STAKE_REGISTRATION_CONWAY;
    params: StakeRegistrationConwayParams;
} | {
    type: CertificateType.STAKE_DEREGISTRATION_CONWAY;
    params: StakeDeregistrationConwayParams;
} | {
    type: CertificateType.STAKE_DELEGATION;
    params: StakeDelegationParams;
} | {
    type: CertificateType.VOTE_DELEGATION;
    params: VoteDelegationParams;
} | {
    type: CertificateType.STAKE_POOL_AND_DREP_DELEGATION;
    params: StakePoolAndDRepDelegationParams;
} | {
    type: CertificateType.ACCOUNT_REGISTRATION_DELEGATION_TO_STAKE_POOL;
    params: AccountRegistrationDelegationToStakePoolParams;
} | {
    type: CertificateType.ACCOUNT_REGISTRATION_DELEGATION_TO_DREP;
    params: AccountRegistrationDelegationToDRepParams;
} | {
    type: CertificateType.ACCOUNT_REGISTRATION_DELEGATION_TO_STAKE_POOL_AND_DREP;
    params: AccountRegistrationDelegationToStakePoolAndDRepParams;
} | {
    type: CertificateType.AUTHORIZE_COMMITTEE_HOT;
    params: AuthorizeCommitteeParams;
} | {
    type: CertificateType.RESIGN_COMMITTEE_COLD;
    params: ResignCommitteeParams;
} | {
    type: CertificateType.DREP_REGISTRATION;
    params: DRepRegistrationParams;
} | {
    type: CertificateType.DREP_DEREGISTRATION;
    params: DRepDeregistrationParams;
} | {
    type: CertificateType.DREP_UPDATE;
    params: DRepUpdateParams;
} | {
    type: CertificateType.STAKE_POOL_REGISTRATION;
    params: PoolRegistrationParams;
} | {
    type: CertificateType.STAKE_POOL_RETIREMENT;
    params: PoolRetirementParams;
};
export type Withdrawal = {
    stakeCredential: CredentialParams;
    amount: bigint_like;
};
export type Flags = {
    isDebug: boolean;
    isAppXS: boolean;
};
export type Version = {
    major: number;
    minor: number;
    patch: number;
    flags: Flags;
};
export type DeviceCompatibility = {
    isCompatible: boolean;
    recommendedVersion: string | null;
    supportsByronAddressDerivation: boolean;
    supportsMary: boolean;
    supportsCatalystRegistration: boolean;
    supportsCIP36: boolean;
    supportsZeroTtl: boolean;
    supportsPoolRegistrationAsOwner: boolean;
    supportsPoolRegistrationAsOperator: boolean;
    supportsPoolRetirement: boolean;
    supportsNativeScriptHashDerivation: boolean;
    supportsMultisigTransaction: boolean;
    supportsMint: boolean;
    supportsAlonzo: boolean;
    supportsReqSignersInOrdinaryTx: boolean;
    supportsBabbage: boolean;
    supportsCIP36Vote: boolean;
    supportsConway: boolean;
    supportsMultipleVoters: boolean;
    supportsMultipleVotesPerVoter: boolean;
    supportsMessageSigning: boolean;
    supportsUnrestrictedTransaction: boolean;
};
export type Serial = {
    serialHex: string;
};
export type DerivedAddress = {
    addressHex: string;
};
export type ExtendedPublicKey = {
    publicKeyHex: string;
    chainCodeHex: string;
};
export type OperationalCertificateSignature = {
    signatureHex: string;
};
export type SignedMessageData = {
    signatureHex: string;
    signingPublicKeyHex: string;
    addressFieldHex: string;
};
export type SignedCIP36VoteData = {
    dataHashHex: string;
    witnessPath: BIP32Path;
    witnessSignatureHex: string;
};
export type Witness = {
    path: BIP32Path;
    witnessSignatureHex: string;
};
export declare enum TxAuxiliaryDataSupplementType {
    CIP36_REGISTRATION = "cip36_voting_registration"
}
export type TxAuxiliaryDataSupplement = {
    type: TxAuxiliaryDataSupplementType.CIP36_REGISTRATION;
    auxiliaryDataHashHex: string;
    cip36VoteRegistrationSignatureHex: string;
};
export type SignedTransactionData = {
    txHashHex: string;
    witnesses: Array<Witness>;
    auxiliaryDataSupplement: TxAuxiliaryDataSupplement | null;
};
export declare enum TxAuxiliaryDataType {
    ARBITRARY_HASH = "arbitrary_hash",
    CIP36_REGISTRATION = "cip36_registration"
}
export type TxAuxiliaryData = {
    type: TxAuxiliaryDataType.ARBITRARY_HASH;
    params: TxAuxiliaryDataArbitraryHashParams;
} | {
    type: TxAuxiliaryDataType.CIP36_REGISTRATION;
    params: CIP36VoteRegistrationParams;
};
export type TxAuxiliaryDataArbitraryHashParams = {
    hashHex: string;
};
export declare enum CIP36VoteRegistrationFormat {
    CIP_15 = "cip_15",
    CIP_36 = "cip_36"
}
export type CIP36VoteRegistrationParams = {
    format: CIP36VoteRegistrationFormat;
    voteKeyHex?: string;
    voteKeyPath?: BIP32Path;
    delegations?: Array<CIP36VoteDelegation>;
    stakingPath: BIP32Path;
    paymentDestination: TxOutputDestination;
    nonce: bigint_like;
    votingPurpose?: bigint_like;
};
export declare enum CIP36VoteDelegationType {
    PATH = "cip36_vote_key_path",
    KEY = "cip36_vote_key_keyHex"
}
export type CIP36VoteDelegation = {
    type: CIP36VoteDelegationType.PATH;
    voteKeyPath: BIP32Path;
    weight: bigint_like;
} | {
    type: CIP36VoteDelegationType.KEY;
    voteKeyHex: string;
    weight: bigint_like;
};
export declare enum TxRequiredSignerType {
    PATH = "required_signer_path",
    HASH = "required_signer_hash"
}
export type RequiredSigner = {
    type: TxRequiredSignerType.PATH;
    path: BIP32Path;
} | {
    type: TxRequiredSignerType.HASH;
    hashHex: string;
};
export declare enum VoterType {
    COMMITTEE_KEY_HASH = 0,
    COMMITTEE_KEY_PATH = 100,
    COMMITTEE_SCRIPT_HASH = 1,
    DREP_KEY_HASH = 2,
    DREP_KEY_PATH = 102,
    DREP_SCRIPT_HASH = 3,
    STAKE_POOL_KEY_HASH = 4,
    STAKE_POOL_KEY_PATH = 104
}
export type CommitteeKeyHashVoter = {
    type: VoterType.COMMITTEE_KEY_HASH;
    keyHashHex: string;
};
export type CommitteeKeyPathVoter = {
    type: VoterType.COMMITTEE_KEY_PATH;
    keyPath: BIP32Path;
};
export type CommitteeScriptHashVoter = {
    type: VoterType.COMMITTEE_SCRIPT_HASH;
    scriptHashHex: string;
};
export type DRepKeyHashVoter = {
    type: VoterType.DREP_KEY_HASH;
    keyHashHex: string;
};
export type DRepKeyPathVoter = {
    type: VoterType.DREP_KEY_PATH;
    keyPath: BIP32Path;
};
export type DRepScriptHashVoter = {
    type: VoterType.DREP_SCRIPT_HASH;
    scriptHashHex: string;
};
export type StakePoolKeyHashVoter = {
    type: VoterType.STAKE_POOL_KEY_HASH;
    keyHashHex: string;
};
export type StakePoolKeyPathVoter = {
    type: VoterType.STAKE_POOL_KEY_PATH;
    keyPath: BIP32Path;
};
export type Voter = CommitteeKeyHashVoter | CommitteeKeyPathVoter | CommitteeScriptHashVoter | DRepKeyHashVoter | DRepKeyPathVoter | DRepScriptHashVoter | StakePoolKeyHashVoter | StakePoolKeyPathVoter;
export declare enum VoteOption {
    NO = 0,
    YES = 1,
    ABSTAIN = 2
}
export type VotingProcedure = {
    vote: VoteOption;
    anchor?: AnchorParams | null;
};
export type GovActionId = {
    txHashHex: string;
    govActionIndex: number;
};
export type Vote = {
    govActionId: GovActionId;
    votingProcedure: VotingProcedure;
};
export type VoterVotes = {
    voter: Voter;
    votes: Array<Vote>;
};
export type Transaction = {
    network: Network;
    inputs: Array<TxInput>;
    outputs: Array<TxOutput>;
    fee: bigint_like;
    ttl?: bigint_like | null;
    certificates?: Array<Certificate> | null;
    withdrawals?: Array<Withdrawal> | null;
    auxiliaryData?: TxAuxiliaryData | null;
    validityIntervalStart?: bigint_like | null;
    mint?: Array<AssetGroup> | null;
    scriptDataHashHex?: string | null;
    collateralInputs?: Array<TxInput> | null;
    requiredSigners?: Array<RequiredSigner> | null;
    includeNetworkId?: boolean | null;
    collateralOutput?: TxOutput | null;
    totalCollateral?: bigint_like | null;
    referenceInputs?: Array<TxInput> | null;
    votingProcedures?: Array<VoterVotes> | null;
    treasury?: bigint_like | null;
    donation?: bigint_like | null;
};
export declare enum TransactionSigningMode {
    ORDINARY_TRANSACTION = "ordinary_transaction",
    MULTISIG_TRANSACTION = "multisig_transaction",
    POOL_REGISTRATION_AS_OWNER = "pool_registration_as_owner",
    POOL_REGISTRATION_AS_OPERATOR = "pool_registration_as_operator",
    PLUTUS_TRANSACTION = "plutus_transaction",
    UNRESTRICTED_TRANSACTION = "unrestricted_transaction"
}
export type TransactionOptions = {
    tagCborSets?: boolean;
};
export type SignTransactionRequest = {
    tx: Transaction;
    signingMode?: TransactionSigningMode;
    additionalWitnessPaths?: BIP32Path[];
    options?: TransactionOptions;
};
export declare enum NativeScriptType {
    PUBKEY_DEVICE_OWNED = "pubkey_device_owned",
    PUBKEY_THIRD_PARTY = "pubkey_third_party",
    ALL = "all",
    ANY = "any",
    N_OF_K = "n_of_k",
    INVALID_BEFORE = "invalid_before",
    INVALID_HEREAFTER = "invalid_hereafter"
}
export type NativeScript = {
    type: NativeScriptType.PUBKEY_DEVICE_OWNED;
    params: NativeScriptParamsDeviceOwnedPubkey;
} | {
    type: NativeScriptType.PUBKEY_THIRD_PARTY;
    params: NativeScriptParamsThirdPartyPubkey;
} | {
    type: NativeScriptType.ALL;
    params: NativeScriptParamsAll;
} | {
    type: NativeScriptType.ANY;
    params: NativeScriptParamsAny;
} | {
    type: NativeScriptType.N_OF_K;
    params: NativeScriptParamsNofK;
} | {
    type: NativeScriptType.INVALID_BEFORE;
    params: NativeScriptParamsInvalidBefore;
} | {
    type: NativeScriptType.INVALID_HEREAFTER;
    params: NativeScriptParamsInvalidHereafter;
};
export type NativeScriptParamsDeviceOwnedPubkey = {
    path: BIP32Path;
};
export type NativeScriptParamsThirdPartyPubkey = {
    keyHashHex: string;
};
export type NativeScriptParamsAll = {
    scripts: NativeScript[];
};
export type NativeScriptParamsAny = {
    scripts: NativeScript[];
};
export type NativeScriptParamsNofK = {
    requiredCount: number;
    scripts: NativeScript[];
};
export type NativeScriptParamsInvalidBefore = {
    slot: bigint_like;
};
export type NativeScriptParamsInvalidHereafter = {
    slot: bigint_like;
};
export type NativeScriptHash = {
    scriptHashHex: string;
};
export declare enum NativeScriptHashDisplayFormat {
    BECH32 = "bech32",
    POLICY_ID = "policyId"
}
//# sourceMappingURL=public.d.ts.map