import { AxiosError, AxiosInstance, AxiosRequestConfig, AxiosRequestHeaders, AxiosProgressEvent } from 'axios';

interface ApiResponse<TData = object> {
    status: boolean;
    data: TData;
    message?: string;
}

interface BaseError {
    message: string;
    error?: string;
    statusCode: number;
}

type ApiServiceError = AxiosError<BaseError, unknown>;

interface PaginatedResponse<TData = object> {
    data: TData;
    meta: {
        currentPage: number;
        itemsPerPage: number;
        totalItems: number;
        totalPages: number;
    };
}

type BaseServiceOptions = {
    axiosInstance?: AxiosInstance;
    apiUrl: string;
};
declare class BaseService {
    private axiosInstance;
    protected apiUrl: string;
    protected coreApiServicePrefix: string;
    protected coreApiUrl: string;
    constructor(opts: BaseServiceOptions);
    protected beforeQuery(params?: object): Promise<void>;
    protected beforeMutation(data: object): Promise<void>;
    get<TRes, TParams extends object = NonNullable<unknown>>(url: string, params?: TParams, options?: AxiosRequestConfig<TParams>): Promise<TRes>;
    post<TRes, TVars extends object>(url: string, data: TVars, config?: AxiosRequestConfig<TVars>): Promise<TRes>;
    put<TRes, TVars extends object>(url: string, data: TVars, config?: AxiosRequestConfig<TVars>): Promise<TRes>;
    patch<TRes, TVars extends object>(url: string, data: TVars): Promise<TRes>;
    delete<TRes, TParams extends object = NonNullable<unknown>>(url: string, params?: TParams, config?: AxiosRequestConfig): Promise<TRes>;
}

interface AppIds {
    [key: string]: string;
}
declare const APP_ID: AppIds;
declare const DEFAULT_APP_ID: string;

declare const DEFAULT_ORG_ID = "00000000-0000-0000-0000-000000000000";

declare const DEVICE_LEVELS: {
    level: number;
    label: string;
    color: string;
    bgColor: string;
}[];

declare const ENCRYPTED_STORAGE_KEYS: {
    accessToken: string;
    bitToken: string;
    refreshToken: string;
    chainItNftWalletAddress: string;
    codeVerifier: string;
    state: string;
    sessionToken: string;
    expiresIn: string;
    idToken: string;
    hasProfile: string;
    introPassed: string;
    deviceId: string;
    mintPlatform: string;
    isLoggingDisabled: string;
    incodeUserId: string;
    organizationId: string;
    themeMode: string;
    shippingDetails: string;
    authStep: string;
    authEmails: string;
    incodeInterviewId: string;
    incodeToken: string;
    selfCustodyWalletAddress: string;
    selfCustodyWalletMnemonic: string;
    selfCustodyWalletPrivateKey: string;
};

declare const BEING_ID_LEVELS: {
    level: number;
    label: string;
    description: string;
}[];
declare const HARDWARE_LEVELS: {
    level: number;
    label: string;
    color: string;
    bgColor: string;
}[];

interface ApplicationData {
    id: string;
}

interface OldAttachmentData {
    id: string;
    mimeType: string;
    docType: AttachmentDocType;
    classification: AttachmentClassification;
    name: string;
    description: string;
}
interface AttachmentData {
    docId: string;
    mimeType: string;
    docType: AttachmentDocType;
    classification: AttachmentClassification;
    name: string;
    description: string;
    url: string;
    thumbUrl: string;
    isMain?: boolean;
}
type AttachmentDocType = 'PHOTO' | 'PDF';
declare enum AttachmentType {
    TokenDocument = "TOKEN_DOCUMENT",
    TokenPhoto = "TOKEN_PHOTO",
    VerificationPhoto = "VERIFICATION_PHOTO",
    WitnessPhoto = "WITNESS_PHOTO"
}
declare enum AttachmentClassification {
    Face = "FACE",
    GovtId = "GOVTID",
    FaceAndGovtId = "FACEANDGOVTID",
    QrCode = "QRCODE",
    AssetPhoto = "ASSET_PHOTO",
    AssetVerificationPhoto = "ASSET_VERIFICATION_PHOTO",
    AssetWitnessPhoto = "ASSET_WITNESS_PHOTO",
    ServicePhoto = "SERVICE_PHOTO",
    ServiceVerificationPhoto = "SERVICE_VERIFICATION_PHOTO",
    ServiceWitnessPhoto = "SERVICE_WITNESS_PHOTO",
    Other = "OTHER",
    AssetDocument = "ASSET_DOCUMENT",
    ServiceDocument = "SERVICE_DOCUMENT"
}
interface CreateAttachmentInputData {
    mimeType: string;
    docType: AttachmentDocType;
    classification: AttachmentClassification;
    name: string;
    description: string;
    data?: string;
    isMain?: boolean;
}
interface CreateQrAttachmentInputData {
    docType: AttachmentDocType;
    classification: AttachmentClassification;
    data: string;
    name?: string;
    description?: string;
}
interface UpdateAttachmentInputData {
    mimeType?: string;
    docType?: AttachmentDocType;
    classification: AttachmentClassification;
    name?: string;
    description?: string;
    docId: string;
    data?: string;
    isMain?: boolean;
}
interface UploadedAttachmentData {
    mimeType: string;
    docType: AttachmentDocType;
    classification: AttachmentClassification;
    docId: string;
    name: string;
    description: string;
    url?: string;
    isMain: boolean;
}
declare enum EAttachmentUploadStatus {
    New = "NEW",
    Uploaded = "UPLOADED",
    Error = "ERROR"
}

declare enum UserTypeEnum {
    EndUser = "end-user",
    Admin = "admin"
}
declare enum ProfileTypeEnum {
    Buyer = "buyer",
    Seller = "seller",
    Creator = "creator"
}
declare enum UserRoleEnum {
    SuperUser = "super_user",
    AdminUser = "admin_user",
    SystemUser = "system_user",
    BusinessUser = "business_user",
    MarketingUser = "marketing_user",
    CustomerSupportUser = "cust_support_user",
    TechSupportUser = "tech_support_user",
    ProductUser = "product_user",
    Client = "client",
    Official = "official",
    FirstOrgUser = "first_org_user",
    Member = "member"
}
declare enum UserRoleIdEnum {
    Client = 1,
    Official = 2,
    FirstOrgUser = 3,
    Member = 4,
    Inspector = 5,
    Buyer = 6,
    Seller = 6
}
declare enum VerifyCredentialTypeEnum {
    Pin = "PIN",
    Otp = "OTP",
    Face = "FACE",
    Fyc = "FYC"
}
declare enum SocialMediaSiteTypeEnum {
    Facebook = "Facebook",
    Twitter = "Twitter",
    Instagram = "Instagram",
    LinkedIn = "LinkedIn",
    Youtube = "Youtube",
    Github = "Github",
    Reddit = "Reddit",
    Pinterest = "Pinterest",
    Tumbler = "Tumbler"
}
declare enum PaymentTypeEnum {
    BankAccount = "BankAccount",
    NetBanking = "NetBanking",
    Card = "Card",
    Paypal = "Paypal"
}
declare enum AddressTypeEnum {
    Home = "Home",
    Office = "Office",
    Warehouse = "Warehouse",
    Company = "Company",
    Factory = "Factory",
    Others = "Others"
}
declare enum DocumentStatusEnum {
    Pending = "Pending",
    Verified = "Verified",
    Rejected = "Rejected"
}
declare enum SellerTypeEnum {
    Individual = "Individual",
    Company = "Company"
}
declare enum ConsentActionTypesEnum {
    Privacy = "privacy",
    Age = "age"
}

interface BaseAddress {
    name: string;
    type: AddressTypeEnum;
    address: string;
    city: string;
    state: string;
    zip: string;
    country: string;
}
interface UserAddress extends BaseAddress {
    id: string;
    userId: string;
    isMain: boolean;
    isDefault: boolean;
    phoneNumber?: string;
}
interface ShippingAddress extends UserAddress {
    profileId: string;
    phoneNumber: string;
    shipInternationally?: boolean;
}

declare enum BeingLevelEnum {
    GovWitness = 1,
    GovRealId = 2,
    SecGovId = 3,
    WitnessConfirm = 4,
    MultiEvents = 5,
    Human = 6
}
interface BeingIdHistory$1 {
    level: number;
    timestamp: string;
}
interface BeingId {
    userId: string;
    updatedAt: string;
    level: number;
    history: BeingIdHistory$1[];
}

interface BitDocument {
    id: string;
    profileId: string;
    typeId: number;
    userId: string;
    number: string;
    status: DocumentStatusEnum;
    createdAt: string;
    updatedAt: string;
    attachments: AttachmentData[];
}
declare enum EGovIdType {
    Unknown = "Unknown",
    Passport = "Passport",
    Visa = "Visa",
    DriverLicense = "Drivers License",
    IdCard = "Identification Card",
    Permit = "Permit",
    Currency = "Currency",
    ResidenceDoc = "Residence Document",
    TravelDoc = "Travel Document",
    BirthCert = "Birth Certificate",
    VehicleReg = "Vehicle Registration",
    Other = "Other",
    WeaponLicense = "Weapon License",
    TribalId = "Tribal Identification",
    VoterId = "Voter Identification",
    Military = "Military",
    TaxId = "Tax Identification",
    FederalId = "Federal ID",
    MedicalCard = "Medical Card"
}
declare enum EFycCheckStatus {
    Ok = "OK",
    Fail = "FAIL",
    Unknown = "UNKNOWN"
}
interface FycDocument {
    userId: string;
    govIdType: EGovIdType;
    sessionId: string;
    govIdName: string;
    govIdDescription: string;
    totalScoreStatus: EFycCheckStatus;
    livenessScoreStatus: EFycCheckStatus;
    faceRecognitionScoreStatus: EFycCheckStatus;
    incodeIdValidationScoreStatus: EFycCheckStatus;
    idOcrValidationScoreStatus: EFycCheckStatus;
    governmentScoreStatus: EFycCheckStatus;
    expireAt: string;
}

interface DocumentTypePhotoRequirement {
    id: number;
    name: string;
}
interface ChainItDocumentType {
    id: number;
    name: string;
    photoRequirements: DocumentTypePhotoRequirement[];
}

interface UserOrganization {
    userId: string;
    orgId: string;
    startedAt: string;
    jobTitle: string;
    endedAt: string;
}

interface PaymentTypeInfoData {
    bankName?: string;
    accountNumber?: string;
    routingNumber?: string;
    nameOnCard?: string;
    cardNumber?: string;
    cvv?: string;
    expiryDate?: string;
    username?: string;
    email?: string;
}
interface PaymentInfo {
    id: string;
    userId: string;
    type: PaymentTypeEnum;
    data: PaymentTypeInfoData;
    createdAt: Date;
    updatedAt: Date;
    profileId: string;
    isDefault: boolean;
}

interface WithAddress {
    address: AddressService;
}
type SearchAddressesRequest = PagedRequest<{
    userId?: string;
    name?: string;
    address?: string;
}>;
type ListAddressesRequest = FilteredRequest<{
    userId?: string;
    name?: string;
    address?: string;
}>;
interface AddAddressRequest {
    userId: string;
    type: AddressTypeEnum;
    name: string;
    address: string;
    city: string;
    state: string;
    zip: string;
    country: string;
    isMain: boolean;
}
interface EditAddressRequest {
    userId: string;
    type: AddressTypeEnum;
    name: string;
    address: string;
    city: string;
    state: string;
    zip: string;
    country: string;
    isMain: boolean;
    id: string;
}

type AddressServiceOptions = BaseServiceOptions & {
    userType: UserTypeEnum;
};
declare class AddressService extends BaseService {
    protected addressApiUrl: string;
    constructor(opts: AddressServiceOptions);
    searchAddresses(req: SearchAddressesRequest): Promise<PagedResponse<UserAddress>>;
    listAddresses(req: ListAddressesRequest): Promise<UserAddress[]>;
    addAddress(req: AddAddressRequest): Promise<UserAddress>;
    getMainAddress(): Promise<UserAddress>;
    getAddressById(id: string): Promise<UserAddress>;
    editAddress(id: string, req: EditAddressRequest): Promise<UserAddress>;
    removeAddress(id: string): Promise<void>;
}

interface WithPaymentDetails {
    paymentDetails: PaymentDetailsService;
}
type ListPaymentDetailsRequest = FilteredRequest<{
    userId?: string;
    paymentDetailId?: string;
}>;
interface AddPaymentDetailRequest {
    paymentDetailId?: string;
    profileId: string;
    userId?: string;
    type?: PaymentTypeEnum;
    data?: PaymentTypeInfoData;
    isDefault: boolean;
}
interface EditPaymentDetailRequest {
    paymentDetailId: string;
    profileId: string;
    type: PaymentTypeEnum;
    data: PaymentTypeInfoData;
    isDefault: boolean;
}

type PaymentDetailsServiceOptions = BaseServiceOptions & {
    profileApiUrl: string;
};
declare class PaymentDetailsService extends BaseService {
    private profileApiUrl;
    constructor(opts: PaymentDetailsServiceOptions);
    listPaymentDetails(profileId: string, req: ListPaymentDetailsRequest): Promise<PaymentInfo[]>;
    addPaymentDetails(profileId: string, req: AddPaymentDetailRequest): Promise<PaymentInfo>;
    getDefaultPaymentDetails(profileId: string): Promise<PaymentInfo>;
    getPaymentDetailsById(profileId: string, paymentDetailId: string): Promise<PaymentInfo>;
    editPaymentDetails(profileId: string, paymentDetailId: string, req: EditPaymentDetailRequest): Promise<PaymentInfo>;
    removePaymentDetails(profileId: string, paymentDetailId: string): Promise<void>;
}

type ListProfilesRequest = FilteredRequest<{
    userId?: string;
    appName?: string;
}>;
interface EditProfileRequest {
    id: string;
    isDefault: boolean;
}
interface AddProfileRequest {
    userId: string;
    appName: string;
    isDefault: boolean;
}
type AddShippingAddressRequest = AddAddressRequest & {
    addressId?: string;
    profileId?: string;
    phoneNumber: string;
    shipInternationally: boolean;
    id?: string;
    isDefault: boolean;
    isMain?: boolean;
};

type ProfileServiceOptions = BaseServiceOptions & {
    profileType: ProfileTypeEnum;
};
declare class ProfileService<TProfile extends Profile> extends BaseService {
    protected profileApiUrl: string;
    constructor(opts: ProfileServiceOptions);
    listProfiles(req: ListProfilesRequest): Promise<TProfile[]>;
    getDefaultProfile(): Promise<TProfile>;
    getProfileById(id: string): Promise<TProfile>;
    editProfile(id: string, req: EditProfileRequest): Promise<TProfile>;
    removeProfile(id: string): Promise<void>;
    addProfile(req: AddProfileRequest): Promise<TProfile>;
}

interface WithShippingAddress {
    shippingAddress: ShippingAddressService;
}
type ListShippingAddressesRequest = FilteredRequest<{
    userId?: string;
    addressId?: string;
}>;
interface ProfileAddShippingAddressRequest {
    addressId?: string;
    profileId?: string;
    isDefault: boolean;
    phoneNumber: string;
    userId?: string;
    type?: AddressTypeEnum;
    name?: string;
    address?: string;
    city?: string;
    state?: string;
    zip?: string;
    country?: string;
    isMain?: boolean;
    shipInternationally: boolean;
}
interface EditShippingAddressRequest {
    id?: string;
    addressId: string;
    profileId: string;
    isDefault: boolean;
    phoneNumber?: string;
    type: AddressTypeEnum;
    name: string;
    address: string;
    city: string;
    state: string;
    zip: string;
    country: string;
    isMain: boolean;
    shipInternationally?: boolean;
}

type ShippingAddressServiceOptions = BaseServiceOptions & {
    profileApiUrl: string;
};
declare class ShippingAddressService extends BaseService {
    private profileApiUrl;
    constructor(opts: ShippingAddressServiceOptions);
    listShippingAddresses(profileId: string, req: ListShippingAddressesRequest): Promise<ShippingAddress[]>;
    addShippingAddress(profileId: string, req: ProfileAddShippingAddressRequest): Promise<ShippingAddress>;
    getDefaultShippingAddress(profileId: string): Promise<ShippingAddress>;
    getShippingAddressById(profileId: string, addressId: string): Promise<ShippingAddress>;
    editShippingAddress(profileId: string, addressId: string, req: EditShippingAddressRequest): Promise<ShippingAddress>;
    removeShippingAddress(profileId: string, addressId: string): Promise<void>;
}

type EditBuyerProfileRequest = EditProfileRequest;
type AddBuyerProfileRequest = AddProfileRequest;
declare class BuyerProfileService extends ProfileService<BuyerProfile> implements WithPaymentDetails, WithShippingAddress {
    paymentDetails: PaymentDetailsService;
    shippingAddress: ShippingAddressService;
    constructor(opts: BaseServiceOptions);
    editProfile(id: string, req: EditBuyerProfileRequest): Promise<BuyerProfile>;
    addProfile(req: AddBuyerProfileRequest): Promise<BuyerProfile>;
    getBuyerProfile(): Promise<GetBuyerProfileRes>;
    getBuyerProfilebyId(buyerId: string): Promise<GetBuyerProfileRes>;
    getBuyerAddresses(profileId: string): Promise<CreateShippingAddressesRes[]>;
    getBuyerPaymentDetails(profileId: string): Promise<CreatePaymentRes[]>;
    createBuyerProfile(payload: CreateBuyerProfilePayload): Promise<GetBuyerProfileRes>;
    updateBuyerProfile(payload: CreateBuyerProfilePayload): Promise<GetBuyerProfileRes>;
    addBuyerAddress(payload: AddShippingAddressRequest): Promise<CreateShippingAddressesRes>;
    addBuyerPaymentDetails(payload: CreatePaymentPayload): Promise<CreatePaymentRes>;
    updateBuyerAddress(payload: AddShippingAddressRequest): Promise<CreateShippingAddressesRes>;
    deleteBuyerAddress(payload: {
        profileId: string;
        addressId: string;
    }): Promise<unknown>;
    updateBuyerPaymentDetails(payload: any): Promise<CreatePaymentRes>;
    deleteBuyerPaymentDetails(payload: any): Promise<unknown>;
}

type EditCreatorProfileRequest = EditProfileRequest & Partial<CreatorProfile>;
type AddCreatorProfileRequest = AddProfileRequest & Partial<CreatorProfile>;
declare class CreatorProfileService extends ProfileService<CreatorProfile> {
    constructor(opts: BaseServiceOptions);
    editProfile(id: string, req: EditCreatorProfileRequest): Promise<CreatorProfile>;
    addProfile(req: AddCreatorProfileRequest): Promise<CreatorProfile>;
}

type SearchDocumentTypesRequest = PagedRequest<{
    name?: string;
}>;
type ListDocumentTypesRequest = FilteredRequest<{
    name?: string;
}>;

declare class DocumentTypesService extends BaseService {
    protected dtApiUrl: string;
    constructor(opts: BaseServiceOptions);
    searchDocumentTypes(req: SearchDocumentTypesRequest): Promise<PagedResponse<ChainItDocumentType>>;
    listDocumentTypes(req: ListDocumentTypesRequest): Promise<ChainItDocumentType[]>;
}

interface WithDocumentsService {
    documents: DocumentsService;
}
type ListDocumentsRequest = FilteredRequest<{
    docId?: string;
    userId?: string;
    typeId?: string;
    status?: DocumentStatusEnum;
}>;
interface BitDocumentAttachmentData {
    name: string;
    data?: string;
    url?: string;
}
interface AddDocumentRequest {
    docId?: string;
    profileId: string;
    userId?: string;
    typeId?: number;
    number: string;
    attachments?: BitDocumentAttachmentData[];
}
interface EditDocumentRequest {
    docId: string;
    profileId: string;
    typeId: number;
    number: string;
    attachments: BitDocumentAttachmentData[];
}

type DocumentsServiceOptions = BaseServiceOptions & {
    profileApiUrl: string;
};
declare class DocumentsService extends BaseService {
    private profileApiUrl;
    constructor(opts: DocumentsServiceOptions);
    listDocuments(profileId: string, req: ListDocumentsRequest): Promise<BitDocument[]>;
    addDocument(profileId: string, req: AddDocumentRequest): Promise<BitDocument>;
    getDocumentById(profileId: string, docId: string): Promise<BitDocument>;
    editDocument(profileId: string, docId: string, req: EditDocumentRequest): Promise<BitDocument>;
    removeDocument(profileId: string, docId: string): Promise<void>;
}

declare enum FeedbackEnum {
    EXCELLENT = "EXCELLENT",
    GOOD = "GOOD",
    POOR = "POOR",
    VERY_POOR = "VERY POOR"
}
interface AddFeedbackRequest {
    type: FeedbackEnum;
    comment: string;
}
interface Feedback {
    id: string;
    userId: string;
    type: FeedbackEnum;
    comment: string;
    createdAt: string;
    updatedBy: string;
    updatedAt: string;
}

declare class FeedbackService extends BaseService {
    private feedbackApiUrl;
    constructor(opts: BaseServiceOptions);
    addFeedback(req: AddFeedbackRequest): Promise<Feedback>;
}

interface Invite {
    id: string;
    type?: {
        description?: string;
    };
    email: string;
    appName: string;
    orgId: string;
    jobTitle?: string;
    roleIds: string[];
    firstName?: string;
    lastName?: string;
    phone?: string;
    userId?: string;
    createdAt: string;
}
interface InvitationTicketClaims {
    id: string;
    email: string;
    iat: number;
    exp: number;
}

type SearchRolesRequest = PagedRequest<{
    name?: string;
}>;
interface Role {
    id: string;
    name: any;
    friendlyName: string;
    description: string;
}

type RoleServiceOptions = BaseServiceOptions & {
    userType: UserTypeEnum;
};
declare class RoleService extends BaseService {
    protected rolesApiUrl: string;
    constructor(opts: RoleServiceOptions);
    searchRoles(req?: SearchRolesRequest): Promise<PagedResponse<Role>>;
}

type EditSellerProfileRequest = EditProfileRequest & Partial<SellerProfile>;
type AddSellerProfileRequest = AddProfileRequest & Partial<SellerProfile>;
declare class SellerProfileService extends ProfileService<SellerProfile> implements WithPaymentDetails, WithShippingAddress, WithDocumentsService {
    paymentDetails: PaymentDetailsService;
    shippingAddress: ShippingAddressService;
    documents: DocumentsService;
    constructor(opts: BaseServiceOptions);
    getSellerProfileByUserId(userId: string): Promise<GetSellerProfileRes[]>;
    getSellerDocuments(profileId: string): Promise<CreateSellerDocumentRes[]>;
    addSellerDocument(req: CreateSellerDocumentPayload): Promise<CreateSellerDocumentRes>;
    updateSellerDocument(req: CreateSellerDocumentPayload): Promise<CreateSellerDocumentRes>;
    getSellerAddress(profileId: string): Promise<ShippingAddress[]>;
    getSellerDefaultPaymentDetails(profileId: string): Promise<CreatePaymentRes>;
    editProfile(id: string, req: EditSellerProfileRequest): Promise<SellerProfile>;
    addProfile(req: AddSellerProfileRequest): Promise<SellerProfile>;
    deleteSellerAddress(profileId: string, addressId: string): Promise<unknown>;
    addSellerAddress(req: ProfileAddShippingAddressRequest): Promise<CreateShippingAddressesRes>;
    editSellerAddress(req: EditShippingAddressRequest): Promise<unknown>;
}

type SearchUsersRequest = PagedRequest<{
    name?: string;
    username?: string;
    email?: string;
    phone?: string;
    emailVerified?: boolean;
    phoneVerified?: boolean;
    appNames?: string[];
    organizationIds?: string[];
    roleIds?: string[];
    includeRoles?: boolean;
    showSoftDeleted?: boolean;
    $resolveImages?: boolean;
    isActive?: boolean;
    showAllOrgUserType?: boolean;
}>;
type ListUsersRequest = FilteredRequest<{
    name?: string;
    username?: string;
    email?: string;
    phone?: string;
    emailVerified?: boolean;
    phoneVerified?: boolean;
    appNames?: string[];
    organizationIds?: string[];
    roleIds?: string[];
    includeRoles?: boolean;
    showSoftDeleted?: boolean;
    $resolveImages?: boolean;
}>;
interface EditUserRequest {
    id: string;
    username?: string;
    firstName?: string;
    lastName?: string;
    middleName?: string;
    avatarUrl?: string | null;
    avatar?: string | null;
    dateOfBirth?: string;
    phone?: string;
}
interface GetUserRolesResponse {
    global: Array<UserRoleEnum>;
    apps: {
        [key: string]: any;
    };
    orgs: {
        [key: string]: any;
    };
}
interface ChangeEmailRequest {
    email: string;
}
interface VerifyEmailRequest {
    ticket: string;
}
interface VerifyPhoneRequest {
    code: string;
}
interface UserRoleDataRequest {
    userId: string;
    roleId: number;
    appName: string;
    orgId: string;
}
interface ManageUserRolesRequest {
    roles: UserRoleDataRequest[];
}
interface ChangePhoneRequest {
    phone: string;
}
interface VerifyCredentialsRequest {
    type: VerifyCredentialTypeEnum;
    faceCredentials: {
        email: string;
        photo: string;
    };
    otpCredentials: object;
    pinCredentials: object;
    fycCredentials: {
        userId: string;
        transactionId: string;
        token: string;
    };
}
interface VerifyCredentialsResponse {
    status: boolean;
    data: {
        token?: string;
    };
}
interface VerifyCredentialsWitnessRequest {
    transactionId: string;
    token: string;
}
interface VerifyCredentialsWitnessResponse extends VerifyCredentialsResponse {
    userId: string;
}
interface SetBeingIdRequest {
    userId: string;
    level: number;
    timestamp: string;
}
interface RecalculateBeingIdRequest {
    userId: string;
    sessionId?: number;
    forceLevel?: boolean;
}
interface CompleteFycOnboardingRequest {
    sessionId: string;
    userId: string;
}
type SearchOrgsRequest = PagedRequest<Partial<UserOrganization>>;
type SearchOrgsResponse = PagedResponse<UserOrganization>;
type ConsentActionRequest = {
    type: ConsentActionTypesEnum;
    isAccepted: boolean;
    biometricsId: string;
    incodeSession: string;
};
interface ConsentActionResponse extends ConsentActionRequest {
    id: string;
}
interface ExportListUsersRequest extends ListUsersRequest {
    reportType: FileTypeEnum;
}
interface FycDocumentsRequest extends FilterParams {
    userId?: string;
    govIdType?: EGovIdType;
}
type SearchUserDocumentsRequest = PagedRequest<{
    userId?: string;
    typeId?: string;
    status?: DocumentStatusEnum;
}>;
interface ListUserDocumentsRequest extends FilterParams {
    userId?: string;
    typeId?: string;
    status?: DocumentStatusEnum;
}
interface ShareUserDeepLinkRequest extends FilterParams {
    to?: {
        email: string;
        name?: string;
    }[];
}
declare enum InviteTypeEnum {
    Internal = "INTERNAL",
    External = "EXTERNAL"
}
interface ListInvitesRequest extends FilterParams {
    email?: string;
    appName?: string;
    orgId?: string;
    userIds?: string[];
    type?: InviteTypeEnum;
}
interface ShareableInfo {
    all: boolean;
    who: {
        age: boolean;
        dateOfBirth: boolean;
        fullName: boolean;
        firstName: boolean;
        middleName: boolean;
        lastName: boolean;
        beingIdHistory: true;
    };
    what: any;
    where: {
        fullAddress: boolean;
        city: boolean;
        state: boolean;
        country: boolean;
        addressOnId: true;
    };
    tokens: {
        currentlyOwned: boolean;
        associated: boolean;
        previouslyOwned: true;
    };
}
type IvdtRequestShareableRequest = ShareableInfo;
interface IvdtRequestShareableResponse {
    qrImgUrl: string;
    token: string;
}
interface IvdtShareableRequest {
    token: string;
}
interface IvdtShareableResponse {
    who: {
        age: number;
        dateOfBirth: string;
        fullName: string;
        firstName: string;
        middleName: string;
        lastName: string;
        beingIdHistory: BeingIdHistory$1[];
    };
    what: any;
    where: {
        address: string;
        city: string;
        state: string;
        country: string;
        addressOnId: string;
    };
    tokens: {
        currentlyOwned: true;
        associated: true;
        previouslyOwned: true;
    };
}
interface SendVerificationCodeRequest {
    phone: string;
}
interface VerifyCodeRequest {
    phone: string;
    code: string;
}
interface VerifyCodeResponse {
    verified: boolean;
}

type UserServiceOptions = BaseServiceOptions & {
    userType: UserTypeEnum;
};
declare class UserService extends BaseService implements WithAddress {
    protected usersApiUrl: string;
    private userType;
    address: AddressService;
    constructor(opts: UserServiceOptions);
    getEndUser(id: string): Promise<EndUser>;
    searchUsers(req: SearchUsersRequest): Promise<PagedResponse<User>>;
    listUsers(req: ListUsersRequest): Promise<User[]>;
    getUser(id: string): Promise<User>;
    editUser(id: string, req: EditUserRequest): Promise<User>;
    removeUser(id: string): Promise<void>;
    getUserRoles(id: string): Promise<GetUserRolesResponse>;
    changeEmail(id: string, req: ChangeEmailRequest): Promise<void>;
    requestEmailVerification(id: string): Promise<void>;
    verifyEmail(id: string, req: VerifyEmailRequest): Promise<void>;
    changePhone(id: string, req: ChangePhoneRequest): Promise<void>;
    requestPhoneVerification(id: string): Promise<void>;
    verifyPhone(id: string, req: VerifyPhoneRequest): Promise<void>;
    assignRoles(id: string, req: ManageUserRolesRequest): Promise<void>;
    removeRoles(id: string, req: ManageUserRolesRequest): Promise<void>;
    requestResetPassword(id: string): Promise<void>;
    blockUser(id: string): Promise<void>;
    unblockUser(id: string): Promise<void>;
    verifyCredentials(req: VerifyCredentialsRequest): Promise<VerifyCredentialsResponse>;
    verifyCredentialsWitness(req: VerifyCredentialsWitnessRequest): Promise<VerifyCredentialsWitnessResponse>;
    getBeingId(id: string): Promise<BeingId>;
    setBeingId(id: string, req: SetBeingIdRequest): Promise<BeingId>;
    recalculateBeingId(id: string, req: RecalculateBeingIdRequest): Promise<BeingId>;
    completeFycOnboarding(id: string, req: CompleteFycOnboardingRequest): Promise<void>;
    getPreviousSessionSelfie(id: string): Promise<string>;
    searchOrganizations(id: string, req?: SearchOrgsRequest): Promise<SearchOrgsResponse>;
    getCurrentOrganization(id: string): Promise<UserOrganization>;
    createConsent(req: ConsentActionRequest): Promise<ConsentActionResponse>;
    setPrivacy(id: string, isPublic: boolean): Promise<void>;
    getInviteById(id: string): Promise<Invite>;
    listInvites(req: ListInvitesRequest): Promise<Invite[]>;
    exportList(req: ExportListUsersRequest): Promise<Blob>;
    listFycDocuments(req?: FycDocumentsRequest): Promise<FycDocument[]>;
    searchDocuments(req: SearchUserDocumentsRequest): Promise<PagedResponse<BitDocument>>;
    listDocuments(req: ListUserDocumentsRequest): Promise<BitDocument[]>;
    shareDeepLink(userId: string, req: ShareUserDeepLinkRequest): Promise<void>;
    ivdtRequestShareableInfo(req: IvdtRequestShareableRequest): Promise<IvdtRequestShareableResponse>;
    ivdtShareableInfo(req: IvdtShareableRequest): Promise<IvdtShareableResponse>;
    sendVerificationCode(req: SendVerificationCodeRequest): Promise<void>;
    verifyCode(req: VerifyCodeRequest): Promise<VerifyCodeResponse>;
}

interface UserRole {
    userId: string;
    roleId: number;
    appName: string;
    orgId: string;
    friendlyName: string;
}
interface User {
    firstName: string;
    lastName: string;
    id: string;
    dateOfBirth?: string;
    address: {
        addressLine1: string;
        addressLine2: string;
        city: string;
        country: string;
        state: string;
        zip: string;
    };
    organization?: string;
    email: string;
    phone: string;
    avatar?: string;
    avatarUrl?: string;
    emailVerified: boolean;
    createdAt: string;
    updatedAt: string;
    blocked: boolean;
    flagged?: boolean;
    roles?: UserRole[];
    beingId?: BeingId;
    organizations?: EndUserOrganizationResponse[];
    isPublic?: boolean;
}
type EndUserAddress = Omit<BaseAddress, 'id'>;
interface EndUser {
    id: string;
    orgId?: string | null;
    email?: string;
    emailVerified?: boolean;
    phone?: string;
    firstName?: string;
    lastName?: string;
    middleName?: string;
    username: string;
    avatarUrl?: string;
    jobTitle?: string;
    phoneVerified?: boolean;
    mainProfileCompleted?: boolean;
    address?: EndUserAddress | null;
    dateOfBirth?: string;
    blocked?: boolean;
    blockedUntil?: string | null;
    blockedReason?: string | null;
    createdAt?: string;
    updatedAt?: string | null;
    beingId?: {
        history?: {
            level?: number;
            timestamp?: string;
        }[];
        level?: number;
        userId?: string;
        updatedAt?: string;
    };
}

interface Profile {
    id: string;
    userId: string;
    appName: string;
    isDefault: boolean;
    createdAt: string;
    updateAt?: string;
}
interface SocialMediaSiteData {
    type: SocialMediaSiteTypeEnum;
    value: string;
}
interface CreatorProfile extends Profile {
    officialSiteUrl?: string;
    bio?: string;
    socialMediaSites: SocialMediaSiteData[];
}
interface BuyerProfile extends Profile {
}
interface SellerProfile extends Profile {
    type: SellerTypeEnum;
    taxId: string;
}
declare enum EAddressType {
    Billing = "Billing",
    Home = "Home",
    Office = "Office",
    Warehouse = "Warehouse",
    Company = "Company",
    Factory = "Factory",
    Others = "Others"
}
declare enum EBeingLevel {
    GovWitness = 1,
    GovRealId = 2,
    SecGovId = 3,
    WitnessConfirm = 4,
    MultiEvents = 5,
    Human = 6
}
interface SocialMedia {
    type: string;
    value: string;
}
interface DocumentAttachments {
    name: string;
    data: string;
}
interface BeingIdHistory {
    level: number;
    timestamp: string;
}
type ShippingDetails = {
    id?: string;
    type: EAddressType;
    name: string;
    address: string;
    phoneNumber: string;
    city: string;
    state: string;
    zip: string;
    country: string;
    shipInternationally: boolean;
    isDefault?: boolean;
};
interface GetProfilePayload {
    userId: string;
}
type GetEndUserAddressesPayload = {
    userId?: string;
    name?: string;
    address?: string;
    $ids?: string[];
    $order?: string;
};
interface SocialMediaSite {
    type: string;
    value: string;
}
interface GetCreatorProfileRes {
    id: string;
    userId: string;
    appName: string;
    isDefault: boolean;
    createdAt: string;
    updateAt?: string;
    officialSiteUrl?: string;
    bio?: string;
    socialMediaSites?: SocialMediaSite[];
}
type GetCreatorProfilesListRes = GetCreatorProfileRes[];
interface GetSellerProfileRes {
    document_ids: string[];
    shippingDetails: [
        {
            address: string;
            city: string;
            country: string;
            id: string;
            name: string;
            phone_number: string;
            state: string;
            type: string;
            zip: string;
        }
    ];
    id: string;
    type: string;
    userId: string;
}
type CreateProfileRes = ApiResponse<EndUser>;
interface UpdateAvatarInput {
    image: string;
}
interface UpdateFaceTemplateInput {
    template: string;
}
interface VerifyCredentialsPayload {
    email?: string;
    photoBase64?: string;
    userId?: string;
    transactionId?: string;
    token?: string;
}
interface VerifyCredentialsInput {
    type: string;
    faceCredentials?: {
        email: string;
        photo: string;
    };
    fycCredentials?: {
        userId?: string;
        transactionId?: string;
        token?: string;
    };
}
type VerifyCredentialsRes = ApiResponse<{
    token: string;
}>;
interface GetDeviceByIdPayload {
    deviceId: string;
}
interface GetDeviceByExternalIdPayload {
    externalId: string;
}
type RegisterDevicePayload = RegisterDeviceInput;
interface RegisterDeviceInput {
    appName: string;
    owner: {
        id: string;
        isPersonal: boolean;
    };
    externalId: string;
    name: string;
    typeId: number;
    deviceInfo?: {
        model?: string;
        os?: string;
        imei?: string;
        macAddress?: string;
    };
    locationId?: string;
    latitude: number;
    longitude: number;
    meanSeaLevel: number;
    platform: string;
    recipientAddress: string;
}
interface GetDeviceVdtResponse {
    platform: string;
    immutableTime: string;
    nftTokenId: string;
    nftMetadataUrl: string;
    nftSmartContractAddress: string;
    immutableTransactionHash: string;
    walletAddress: string;
    deviceId: string;
}
interface CreatorProfilePayload {
    id?: string;
    officialSiteUrl?: string;
    bio?: string;
    socialMediaSites?: SocialMedia[];
    isDefault: boolean;
}
interface CreateSellerProfilePayload {
    type: 'Company' | 'Individual';
    userId: string;
    appName: string;
    isDefault: boolean;
}
interface CreateSellerProfileRes {
    id: string;
    userId: string;
    type: 'Company' | 'Individual';
    shippingDetails: ShippingDetails[];
    document_ids: [];
    tin: string;
    paymentDetails: {
        bankName: string;
        accountNumber: string;
        bankIFSCCode: string;
    };
    createdAt: string;
    updatedAt: string;
}
interface GetDocumentsTypesRes {
    items: [
        {
            id: string;
            name: string;
            photoRequirements: [
                {
                    name: string;
                }
            ];
        }
    ];
    page: number;
    perPage: number;
    totalPages: number;
    totalCount: number;
}
interface GetDocumentsRes {
    attachments: [
        {
            name: string;
            path: string;
            url: string;
        }
    ];
    id: string;
    number: string;
    status: string;
    typeId: string;
    userId: string;
}
interface CreateDocumentPayload {
    userId: string;
    typeId: number;
    number: string;
    attachments: DocumentAttachments[];
}
interface CreateDocumentRes {
    id?: string;
    userId: string;
    typeId: string;
    number: string;
    attachments: [{
        name: string;
        data: string;
        url?: string;
    }];
    status?: string;
}
type CreateAddressesRes = BaseAddress;
type UpdateAddressPayload = AddAddressRequest & {
    id: string;
};
type CreateShippingAddressesRes = BaseAddress & {
    id?: string;
    userId: string;
    profileId: string;
    isDefault: boolean;
    phoneNumber: string;
    shipInternationally?: boolean;
};
type CreateSellerDocumentPayload = CreateDocumentPayload & {
    docId?: string;
    profileId: string;
};
type CreateSellerDocumentRes = CreateDocumentRes & {
    profileId: string;
};
type DeleteShippingAddressPayload = {
    id: string;
    profileId: string;
};
type PaymentDataProps = {
    bankName?: string;
    accountNumber?: string;
    routingNumber?: string;
    nameOnCard?: string;
    cardNumber?: string;
    expiryDate?: string;
    cvv?: string;
    username?: string;
    email?: string;
};
type CreatePaymentPayload = {
    userId?: string;
    type?: string;
    isDefault?: boolean;
    profileId?: string;
    paymentDetailId?: string;
    data?: PaymentDataProps;
};
type CreatePaymentRes = CreatePaymentPayload & {
    id?: string;
    createdAt?: string;
    updatedAt?: string;
};
type GetBuyerProfileRes = {
    id: string;
    userId: string;
    appName: string;
    isDefault: true;
    createdAt: string;
    updateAt: string;
};
type CreateBuyerProfilePayload = {
    userId: string;
    appName: string;
    isDefault: boolean;
};
interface ValidateDevicePayload {
    id: string;
    externalId: string;
    isPersonal: boolean;
}
interface GetOrganizationProfileRes {
    id: string;
    name: string;
    description?: string;
    contacts?: {
        id: string;
        name: string;
        job: string;
        email: string;
        phone: string;
    }[];
    logoUrl?: string;
    isSuper: string;
    createdAt?: string;
    updatedAt?: string;
}
interface GetOrganizationProfileByIdRes {
    userId: string;
    orgId: string;
    startedAt: string;
    jobTitle: string;
    endedAt: string;
}
interface GetUserRolesRes {
    global?: string[];
    apps?: any;
}
interface UserVdtResponse {
    platform: string;
    immutableTime: string;
    nftTokenId: string;
    nftMetadataUrl: string;
    nftSmartContractAddress: string;
    immutableTransactionHash: string;
    walletAddress: string;
    userId: string;
}
interface UserVdtByQrIdResponse {
    platform: string;
    immutableTime: string;
    nftTokenId: string;
    nftMetadataUrl: string;
    nftSmartContractAddress: string;
    immutableTransactionHash: string;
    walletAddress: string;
    userId: string;
    ipfsMetadata: IpfsMetadata;
}
interface GetUserBeingIdRes {
    userId: string;
    updatedAt: string;
    level: number;
    history: BeingIdHistory[];
}
interface SetUserBeingIdPayload {
    userId: string;
    level: number;
}
interface RecalculateUserBeingIdPayload {
    userId: string;
    sessionId?: number;
    forceLevel?: boolean;
}
interface CompleteOnboardingPayload {
    userId: string;
    sessionId: string;
}
interface EndUserOrganizationResponse {
    userId: string;
    orgId: string;
    startedAt: string;
    jobTitle: string;
    endedAt: string;
}
interface GetOrganizationsRes {
    items: [
        {
            userId: string;
            orgId: string;
            startedAt: string;
            jobTitle: string;
            endedAt: string;
        }
    ];
    page: number;
    perPage: number;
    totalPages: number;
    totalCount: number;
}
interface OrganizationInviteResponse {
    id: string;
    type?: {
        description?: string;
    };
    email: string;
    appName: string;
    orgId: string;
    jobTitle: string;
    roleIds: string[];
    createdAt: string;
}

interface AuthClaims {
    aud: string[];
    azp: string;
    exp: number;
    'https://blackinktech.io/schemas/claims/email'?: string;
    'https://blackinktech.io/schemas/claims/email_verified'?: boolean;
    'https://blackinktech.io/schemas/claims/roles'?: string[];
    iat: number;
    iss: string;
    permissions: string[];
    scope: string;
    sub: string;
}
interface IIdentityOrganizationPermission {
    blocked: boolean;
    roles: UserRoleEnum[];
    products: string[];
}
interface IIdentityOrganization {
    [orgId: string]: IIdentityOrganizationPermission;
}
interface BitAuthClaims {
    externalId: string;
    userId: string;
    userType: string;
    email: string;
    emailVerified: boolean;
    application: string;
    mainProfileCompleted: boolean;
    profileCompleted: boolean;
    biometricsVerified: boolean;
    roles: {
        global: UserRoleEnum[];
        orgs: IIdentityOrganization;
    };
    iat: number;
    exp: number;
    aud: number;
    iss: number;
}

declare enum RelationTypeEnum {
    Official = "CHECKIN_OFFICIAL",
    Witness = "CHECKIN_WITNESS",
    Inspector = "CHECKIN_INSPECTOR",
    Archive = "CHECKIN_ARCHIVE",
    Buyer = "CHECKIN_BUYER",
    Seller = "CHECKIN_SELLER",
    ChildVdt = "CHILD_VDT",
    ParentVdt = "PARENT_VDT"
}

interface GeolocationData {
    latitude: number;
    longitude: number;
    meanSeaLevel: number;
}

declare enum DeviceTypeIdEnum {
    STATIONARY_KIOSK = 1,
    MOBILE_KIOSK = 2,
    TABLET_KIOSK = 3,
    PHONE = 4,
    TABLET = 5
}
declare enum DeviceTypeEnum {
    STATIONARY_KIOSK = "STATIONARY_KIOSK",
    MOBILE_KIOSK = "MOBILE_KIOSK",
    TABLET_KIOSK = "TABLET_KIOSK",
    PHONE = "PHONE",
    TABLET = "TABLET"
}
type DeviceData = {
    deviceId: string;
    deviceName: string;
    deviceType: DeviceTypeEnum;
    geolocation: GeolocationData;
    ipAddress?: string;
    date: string;
    hardwareLevel?: number;
};

interface EventData {
    eventType: string;
    eventId: string;
}
declare enum StepEnum {
    DATA = "DATA",
    PHOTO = "PHOTO",
    CONFIRM = "CONFIRM",
    OFFICIAL = "OFFICIAL",
    QRCODE = "QRCODE",
    RFID = "RFID",
    PRIVACY = "PRIVACY",
    WITNESS = "WITNESS",
    DOCUMENT = "DOCUMENT",
    REFERENCE_VDTS = "REFERENCE_VDTS",
    VDT_MINTED = "VDT_MINTED"
}
type EventRelationType = 'CHECKIN_OFFICIAL' | 'CHECKIN_WITNESS';

interface BaseRefVdt {
    bitSysId: string;
    tokenId: string;
    ipfsUrl: string;
}
interface LevelDetail {
    activeAt: string;
    level: string | number;
}
interface UserRefVdt extends BaseRefVdt {
    beingIdLevel: LevelDetail;
}
interface DeviceRefVdt extends BaseRefVdt {
    hardwareLevel: LevelDetail;
}

declare enum TraitTypeEnum {
    Type = "Type",
    TypeWitness = "Type-Witness",
    Who = "Who",
    WhoBiometrics = "Who-Biometrics",
    What = "What",
    When = "When",
    Where = "Where",
    WhereDevice = "Where-Device"
}
interface VdtAttribute {
    trait_type: TraitTypeEnum;
    value: string;
}
interface IpfsMetadata {
    ipfs: string;
    name: string;
    image: string;
    qrCode: {
        image: string;
        url: string;
    };
    eventId: string;
    refVdts: {
        userVdt: UserRefVdt;
        deviceVdt: DeviceRefVdt;
    };
    vdtType: string;
    bitSysId: string;
    attributes: VdtAttribute[];
    description: string;
    beingIdLevel: {
        current: {
            activeAt: Date;
            endedAt?: Date;
            level: string;
        };
        history: {
            activeAt: Date;
            endedAt?: Date;
            level: string;
        }[];
    };
}

type LogLevels = 'debug' | 'info' | 'warn' | 'error';
type LoggerType = {
    [key in LogLevels]: (...args: unknown[]) => void;
};

type PaginationPayload = {
    page: string;
    limit: string;
};
interface FilterParams {
    $ids?: string[];
    $orderBy?: string;
    $order?: 'asc' | 'desc';
    $resolveImages?: boolean;
}
interface PaginationParams {
    $page?: number;
    $perPage?: number;
}
type SerializableValue = object | number | number[] | number[][] | string | string[] | boolean | number | undefined;
type FilteredRequest<TRequest> = TRequest & FilterParams;
type PagedRequest<TRequest> = TRequest & FilterParams & PaginationParams;
type PagedResponse<TResponse> = {
    items: TResponse[];
    page: number;
    perPage: number;
    totalPages: number;
    totalCount: number;
};

declare enum QrPackageTypeEnum {
    OBJECTS = "OBJECTS",
    SERVICES = "SERVICES",
    USERS = "USERS",
    USER_DEVICES = "USER_DEVICES",
    USER_OBJECTS = "USER_OBJECTS",
    USER_SERVICES = "USER_SERVICES",
    ORGANIZATIONS = "ORGANIZATIONS",
    DEVICES = "DEVICES",
    ORG_USERS = "ORG_USERS",
    ORG_DEVICES = "ORG_DEVICES",
    ORG_OBJECTS = "ORG_OBJECTS",
    ORG_SERVICES = "ORG_SERVICES",
    WITNESS = "WITNESS",
    OBJECT_WITNESSES = "OBJECT_WITNESSES",
    SERVICE_WITNESSES = "SERVICE_WITNESSES"
}

interface RootEventData {
    id: string;
    associationType: string;
}

declare enum ReferenceType {
    PHONE = "PHONE",
    DRIVERS_LICENSE = "DRIVERS_LICENSE",
    EMPLOYEE_ID = "EMPLOYEE_ID",
    AUTH0_IDENTITY = "AUTH0_IDENTITY",
    END_USER_ID = "END_USER_ID",
    ADMIN_USER_ID = "ADMIN_USER_ID"
}
interface SubjectDataReferenceItem {
    type: ReferenceType;
    value: string;
}
interface SubjectData {
    subjectType: string;
    references: SubjectDataReferenceItem[];
    orgId?: string;
}
declare enum SubjectTypeEnum {
    EMPLOYEE = "EMPLOYEE",
    DRIVER = "DRIVER",
    USER = "USER",
    ASSET_OWNER = "ASSET_OWNER"
}

interface TemplateRes {
    name: string;
    type: number;
    text: string;
    createdAt: string;
    updatedAt: string;
}

declare enum WalletPlatformEnum {
    Ethereum = "ethereum",
    Polygon = "polygon"
}

interface WeatherData {
    AbsHumidity: number;
    AirDensity: number;
    AvgCorrectedWindDir: number;
    AvgCorrectedWindSpeed: number;
    AvgRelativeWindDir: number;
    AvgRelativeWindSpeed: number;
    CompassHeading: number;
    CorrectedGustDirection: number;
    CorrectedGustSpeed: number;
    CorrectedWindDir: number;
    CorrectedWindSpeed: number;
    Dewpoint: number;
    GPSHeading: string;
    GPSLocation: string;
    GPSSpeedOverGround: string;
    GPSStatusError: boolean;
    HeatIndex: number;
    PositionOfTheSun: number;
    PrecipIntensity: string;
    RainPresent: boolean;
    Pressure: number;
    PressureAtSeaLevel: number;
    PressureAtStation: number;
    RelGustDir: number;
    RelGustSpeed: number;
    RelHumidity: number;
    RelWindDir: number;
    RelWindSpeed: number;
    SensorStatusError: boolean;
    SolarNoonTime: string;
    SolarRadiation: string;
    SunriseTime: string;
    SunsetTime: string;
    SunshineHours: number;
    Temperature: number;
    TotalPrecip: string;
    TwilightAstronomical: string;
    TwilightCivil: string;
    TwilightNautical: string;
    WetBulbTemperature: number;
    WindChill: number;
    WindSensorError: boolean;
    XTilt: number;
    YTilt: number;
    ZOrientation: string;
}

interface ViewAttachmentResponse {
    url: string;
}
interface UpdateAttachmentResponse {
    docId: string;
    status: EAttachmentUploadStatus;
    message: string;
}

declare enum FileFormatEnum {
    CSV = "CSV",
    PDF = "PDF"
}

declare enum InfoTypeEnum {
    Who = "Who",
    What = "What",
    When = "When",
    Where = "Where"
}

declare enum WitnessTypeEnum {
    Witness = "witness",
    Buyer = "buyer",
    Seller = "seller"
}

declare function getAuth0Id(claims: AuthClaims, opts?: {
    keepPrefix: boolean;
}): Promise<string>;
declare function getAuthEmail(claims: AuthClaims): Promise<string | undefined>;
declare function isTokenExpired(token: string): boolean;

declare const createQueryParams: (params?: Record<any, SerializableValue>) => string;

declare const debounce: <TFunction extends (...args: any[]) => any>(fn: TFunction, ms?: number) => (this: any, ...args: any[]) => void;

declare function formatDate(date: string): string;

declare function formatNumber(n: string): string;

/**
 * This is a no-man's land function that tries
 * to handle every possible error scenario from ChainIT frontend & backend.
 * Handles simple error messages, axios errors, and now FATAL server error objects
 */
declare function getErrorMessage(err: unknown): string;

declare function makeSampleGeolocation(): {
    latitude: number;
    longitude: number;
    meanSeaLevel: number;
};

declare function makeSampleWeatherData(): {
    AbsHumidity: number;
    AirDensity: number;
    AvgCorrectedWindDir: number;
    AvgCorrectedWindSpeed: number;
    AvgRelativeWindDir: number;
    AvgRelativeWindSpeed: number;
    CompassHeading: number;
    CorrectedGustDirection: number;
    CorrectedGustSpeed: number;
    CorrectedWindDir: number;
    CorrectedWindSpeed: number;
    Dewpoint: number;
    GPSHeading: string;
    GPSLocation: string;
    GPSSpeedOverGround: string;
    GPSStatusError: boolean;
    HeatIndex: number;
    PositionOfTheSun: number;
    PrecipIntensity: string;
    RainPresent: boolean;
    Pressure: number;
    PressureAtSeaLevel: number;
    PressureAtStation: number;
    RelGustDir: number;
    RelGustSpeed: number;
    RelHumidity: number;
    RelWindDir: number;
    RelWindSpeed: number;
    SensorStatusError: boolean;
    SolarNoonTime: string;
    SolarRadiation: string;
    SunriseTime: string;
    SunsetTime: string;
    SunshineHours: number;
    Temperature: number;
    TotalPrecip: string;
    TwilightAstronomical: string;
    TwilightCivil: string;
    TwilightNautical: string;
    WetBulbTemperature: number;
    WindChill: number;
    WindSensorError: boolean;
    XTilt: number;
    YTilt: number;
    ZOrientation: string;
};

declare const ASSET_STEPS: readonly [StepEnum.DATA, StepEnum.PHOTO, StepEnum.OFFICIAL, StepEnum.QRCODE, StepEnum.RFID, StepEnum.PRIVACY, StepEnum.WITNESS];
declare const assetStatuses: readonly ["INFO", "PHOTO", "OFFICIALS", "QRCODE", "RFID", "WITNESS", "MINTED"];
declare const SKIPPABLE_ASSET_STEPS: StepEnum[];
declare const ASSET_STATUSES: readonly ["CREATED", "PHOTO_ADDED_STARTED", "PHOTO_ADDED_FAILED", "PHOTO_ADDED", "OFFICIAL_VERIFYING_STARTED", "OFFICIAL_VERIFYING_FAILED", "OFFICIAL_VERIFIED", "QR_BINDING_STARTED", "QR_BINDING_FAILED", "QR_BOUND", "RFID_BINDING_STARTED", "RFID_BINDING_FAILED", "RFID_BOUND", "PRIVACY_STARTED", "PRIVACY_FAILED", "PRIVACY_DONE", "REGISTERING_STARTED", "REGISTERING_FAILED", "REGISTERED", "MINTING_STARTED", "MINTING_FAILED", "MINTED", "INCOMPLETE", "COMPLETED"];
declare enum CategoryStatusEnum {
    Normal = "NORMAL",
    Fixed = "FIXED"
}

declare enum ChainTypeEnum {
    Objects = "OBJECTS",
    Services = "SERVICES",
    Files = "FILES",
    OrgObjects = "ORG-OBJECTS",
    OrgServices = "ORG-SERVICES",
    OrgFiles = "ORG-FILES"
}
declare enum ReportTypeEnum {
    Seller = "Seller",
    Buyer = "Buyer"
}
declare enum FileTypeEnum {
    PDF = "PDF",
    CSV = "CSV"
}
declare enum AssetStatusEnum {
    CREATED = "CREATED",
    PHOTO_ADDED_STARTED = "PHOTO_ADDED_STARTED",
    PHOTO_ADDED_FAILED = "PHOTO_ADDED_FAILED",
    PHOTO_ADDED = "PHOTO_ADDED",
    DOCUMENT_ADDED_STARTED = "DOCUMENT_ADDED_STARTED",
    DOCUMENT_ADDED_FAILED = "DOCUMENT_ADDED_FAILED",
    DOCUMENT_ADDED = "DOCUMENT_ADDED",
    OFFICIAL_VERIFYING_STARTED = "OFFICIAL_VERIFYING_STARTED",
    OFFICIAL_VERIFYING_FAILED = "OFFICIAL_VERIFYING_FAILED",
    OFFICIAL_VERIFIED = "OFFICIAL_VERIFIED",
    QR_BINDING_STARTED = "QR_BINDING_STARTED",
    QR_BINDING_FAILED = "QR_BINDING_FAILED",
    QR_BOUND = "QR_BOUND",
    RFID_BINDING_STARTED = "RFID_BINDING_STARTED",
    RFID_BINDING_FAILED = "RFID_BINDING_FAILED",
    RFID_BOUND = "RFID_BOUND",
    PRIVACY_STARTED = "PRIVACY_STARTED",
    PRIVACY_FAILED = "PRIVACY_FAILED",
    PRIVACY_DONE = "PRIVACY_DONE",
    WITNESS_VERIFYING_STARTED = "WITNESS_VERIFYING_STARTED",
    WITNESS_VERIFYING_FAILED = "WITNESS_VERIFYING_FAILED",
    WITNESS_VERIFIED = "WITNESS_VERIFIED",
    REGISTERING_STARTED = "REGISTERING_STARTED",
    REGISTERING_FAILED = "REGISTERING_FAILED",
    REGISTERED = "REGISTERED",
    MINTING_STARTED = "MINTING_STARTED",
    MINTING_FAILED = "MINTING_FAILED",
    MINTED = "MINTED",
    REFERENCE_VDTS_STARTED = "REFERENCE_VDTS_STARTED",
    REFERENCE_VDTS_FAILED = "REFERENCE_VDTS_FAILED",
    REFERENCE_VDTS_COMPLETED = "REFERENCE_VDTS_COMPLETED",
    CONFIRMED = "CONFIRMED"
}

interface AssetTemplate {
    id: string;
    typeId: string | null;
    typeName?: string | null;
    step: string | null;
    name: string;
    title: string;
    fields: AssetTypePropDataModel[];
    description: string | null;
    status: string;
    createdAt: string | null;
    updatedAt: string | null;
    activatedAt: string | null;
    archivedAt: string | null;
    hint: string;
}
interface AssetTypePropDataModel {
    propName: string;
    propTypeId: number;
    propType: {
        id: number;
        name: string;
        friendlyName: string;
        type: string;
        hasOption: boolean;
        multiValue: boolean;
    };
    label: string;
    required: boolean;
    order: number;
    visible: boolean;
    hint: string | null;
    defaultValue: string | null;
    options: {
        optionId: string;
        name: string;
        visible: boolean;
        order: number;
    }[] | null;
}
interface AssetType {
    id: string;
    name: string;
    description: string;
    categoryId: string;
    readyForUse: boolean;
    imageUrl: string;
    isActive: boolean;
    steps: AssetTypeStep[];
    vdtType: ChainTypeEnum;
}
interface AssetTypeStep {
    typeId: string | null;
    step: string | null;
    enabled: boolean;
    order: number;
}

interface AssetCategory {
    id: string;
    name: string;
    description: string;
    parentId: string | null;
    appName: string;
    isFinal: boolean;
    imageUrl: string | null;
    types?: AssetType[];
    createdAt?: string;
    updatedAt?: string;
    deletedAt: string | null;
    state: CategoryStatusEnum;
}

declare enum SellingMethodEnum {
    /**
     * I don't know why this is called "Mint",
     * in product terms we just call it "Fixed Price"
     */
    Fixed = "fixed",
    Auction = "auction",
    Dutch = "dutch_auction",
    Inverse = "inverse_auction"
}
declare enum MeasurementUnitEnum {
    IN = "IN",
    CM = "CM"
}

interface BaseTypePropertyData {
    id: string | number;
    name: string;
    value: string;
}
interface BaseType {
    id: string;
    name: string;
    categoryId: number;
    image: string | null;
}
interface CustomerAssetWitness {
    assetId: string;
    witnessId: string;
    relationType: RelationsTypeEnum;
    witness: AssetWitness;
}
interface CustomerAsset {
    id: string;
    appName: string;
    typeId: string;
    typeName: string;
    status: AssetStatus;
    level: AssetLevelEnum;
    name: string;
    ownerId: string;
    orgId: string;
    serializedSteps: SerializedStep[];
    serializedProps: SerializedProp[];
    serializedImages: SerializedImage[];
    serializedDocuments: SerializedImage[];
    serializedCategories: string[];
    qrCodeRef?: string | null;
    rfIdRef?: string | null;
    eventIdRef: string;
    city?: string | null;
    state?: string | null;
    country?: string | null;
    isMinted: boolean;
    isVerifiedByWitness: boolean;
    createdAt: string;
    updatedAt: string;
    mintedAt: string;
    isFavorite: boolean;
    isVerifiedByOfficial: boolean;
    sellingMethod: SellingMethodEnum | null;
    referenceVDT: AssetReferenceVDTResponse[];
    witness: WitnessCustomerAssetResponse[];
    createdBy: string;
    categoryId?: string;
    assetWitness?: CustomerAssetWitness[];
}
interface S2CCustomerAsset extends CustomerAsset {
    typeDetail: {
        id: string;
        name: string;
        description: string;
        categoryId: string;
        readyForUse: true;
        imageUrl: string;
        isActive: true;
        steps: AssetTypeStep[];
        vdtType: ChainTypeEnum;
        orgId: string;
    };
    isOpen?: boolean;
}
interface AssetReferenceVDTResponse {
    assetId?: string;
    serviceId?: string;
    qrCodeRefId: string;
    vdtType: ChainTypeEnum;
    bitSysId: string;
    relationType: RelationTypeEnum;
    createdAt: string;
    data: {
        title: string;
    };
}
interface WitnessCustomerAssetResponse {
    id: string;
    relationType: RelationTypeEnum;
    userId: string;
    name: string;
    email: string;
    firstName: string;
    lastName: string;
    avatarUrl: string;
    serializedImages: SerializedImage[];
    serializedProps: SerializedProp[];
    eventIdRef: string;
    isMinted: boolean;
    city: string;
    state: string;
    country: string;
    locationAccuracy: 'exact' | 'city';
    geolocation: {
        longitude: number;
        latitude: number;
        meanSeaLevel: number;
    };
    createdAt: string;
    mintedAt: string;
    approved: boolean;
    updatedAt: string;
    orgId: string;
}
declare enum RelationsTypeEnum {
    CHECKIN_OFFICIAL = "CHECKIN_OFFICIAL",
    CHECKIN_WITNESS = "CHECKIN_WITNESS",
    CHECKIN_INSPECTOR = "CHECKIN_INSPECTOR",
    CHECKIN_BUYER = "CHECKIN_BUYER",
    CHECKIN_SELLER = "CHECKIN_SELLER",
    PARENT_VDT = "PARENT_VDT",
    CHILD_VDT = "CHILD_VDT"
}
type AssetStatus = (typeof ASSET_STATUSES)[number];
declare enum AssetLevelEnum {
    A_PLUS = "A+",
    A = "A",
    A_MINUS = "A-",
    B_PLUS = "B+",
    B = "B",
    B_MINUS = "B-",
    C_PLUS = "C+",
    C = "C",
    C_MINUS = "C-"
}
interface SerializedStep {
    step?: StepEnum;
    order: number;
    typeId: string;
    enabled: boolean;
    finished: boolean;
    isRequired: boolean;
}
interface SerializedProp {
    id: string;
    name: string;
    value: string;
}
interface SerializedImage {
    name: string;
    docId: string;
    docType: string;
    mimeType: string;
    description: string;
    classification: AttachmentClassification;
    isMain: boolean;
}
declare enum VerifyType {
    NOT_VERIFIED = "notVerified",
    OFFICIAL_VERIFIED = "verifiedByOfficial",
    SELF_VERIFIED = "selfVerified"
}
type MintStatus = 'MINTING_STARTED' | 'MINTING_FAILED' | 'MINTED';
interface FavoriteAsset extends CustomerAsset {
    isDeleted: boolean;
}

interface AssetWitness {
    approved: boolean;
    avatarUrl: string;
    city: string;
    country: string;
    createdAt: string;
    email: string;
    eventIdRef: string;
    firstName: string;
    geolocation: GeolocationData;
    id: string;
    isMinted: boolean;
    lastName: string;
    mintedAt: string | null;
    name: string;
    relationType: RelationTypeEnum;
    serializedImages: SerializedImage[] | null;
    serializedProps: SerializedProp[] | null;
    state: string;
    userId: string;
}

interface CreateChainBaseRequest {
    application: ApplicationData;
    subject: SubjectData;
    device: DeviceData;
    weather?: WeatherData;
    data: {
        date: string;
    };
}
interface ChainBaseEvent {
    id: string;
    application: string;
    device: DeviceData;
    weather: WeatherData;
    status: AssetStatus;
    subjectType: string;
    /**
     * For some reason there are rare situations where this is `undefined`
     */
    attachments?: AttachmentData[] | null;
    eventDate?: string | null;
    data?: ChainBaseEventData;
    subjectReferences: SubjectDataReferenceItem[];
}
interface ChainBaseEventData {
    assetCategory?: string[];
    metadata?: Partial<ChainBaseEventMetadata>;
    locationAccuracy?: LocationAccuracy;
}
interface ChainBaseEventMetadata {
    qrId?: string;
    timezone?: string;
    nftTokenId?: string;
    description?: string;
    immutableTime?: string;
    nftMetadataUrl?: string;
    nftSmartContractAddress?: string;
    immutableTransactionHash?: string;
    city?: string;
    state?: string;
    country?: string;
    platform?: string;
    categoryState?: CategoryStatusEnum;
}
interface FindMainPhotoByTypeClassOpts<TPhotos> {
    photos: TPhotos[];
    chainType: ChainTypeEnum;
    attachmentType: AttachmentType;
}

interface ChainAssetEventData extends ChainBaseEventData {
    assetType?: string;
    assetCategory?: string[];
    assetName?: string;
    isFavorite?: boolean;
    assetProperties?: AssetTypePropertyData[];
    metadata?: ChainAssetEventMetadata;
    locationAccuracy?: LocationAccuracy;
}
interface ChainAssetEventMetadata extends ChainBaseEventMetadata {
    assetTypeId?: string;
    custFileReqId?: string;
    custFileId?: string;
}
interface AssetTypePropertyData extends BaseTypePropertyData {
    isAssetName?: boolean;
}
interface WhenDetails {
    blockNumber?: string;
    ownerWalletId?: string;
    value?: string;
    valueUsd?: string;
    transactionFee?: string;
    transactionFeeUsd?: string;
    gasPrice?: string;
    gasPriceUsd?: string;
    etherPrice?: string;
    timestamp?: string;
    coinName?: string;
    coinPrice?: number;
}
interface PublicToken {
    id: string;
    typeName: string;
    orgId?: string;
    appName: string;
    name: string;
    status: string;
    level: string;
    eventIdRef?: string;
    qrCodeId?: string;
    serializedProps?: AssetTypePropertyData[];
    serializedImages?: AttachmentData[];
    serializedCategories?: string[];
    assetType?: string;
    city: string;
    state: string;
    country: string;
}

declare enum CoreEventTypeEnum {
    CHAIN_SERVICES = "CHAIN_SERVICES",
    CHAIN_OBJECTS = "CHAIN_OBJECT"
}

declare enum EEventStatus {
    Initialized = "INITIALIZED",
    Uploading = "UPLOADING",
    Completed = "COMPLETED",
    ForVerification = "FOR_VERIFICATION",
    Verified = "VERIFIED"
}
interface Event {
    id: string;
    deviceId: string;
    appName: string;
    deviceDate: string;
    subjectType: SubjectTypeEnum;
    eventTypeId: string;
    createdBy: string;
    latitude: number;
    longitude: number;
    meanSeaLevel: number;
    ipAddress: string;
    status: EEventStatus;
    eventDate: string;
    createdAt: string;
    weather: WeatherData;
}
declare class EventService extends BaseService {
    constructor(opts: BaseServiceOptions);
    getEventById(eventId?: string): Promise<Event>;
    searchEvents(req?: FilterParams): Promise<PagedResponse<Event>>;
}

type GetAssetsRequest = PagedRequest<{
    ownerId?: string;
    typeId?: string;
    orgId?: string;
    appName?: string[] | string;
    name?: string;
    status?: AssetStatus;
    eventIdRef?: string;
    isMinted?: boolean;
    isListed?: boolean;
    isVerifiedByWitness?: boolean;
    isVerifiedByOfficial?: boolean;
    sellingMethod?: SellingMethodEnum;
    isFavorite?: boolean;
}>;
type GetPublicAssetsRequest = PagedRequest<{
    ownerId?: string;
    typeId?: string;
    orgId?: string;
    appName?: string;
    name?: string;
    status?: AssetStatus;
    eventIdRef?: string;
    isMinted?: boolean;
    isVerifiedByWitness?: boolean;
    isVerifiedByOfficial?: boolean;
    sellingMethod?: SellingMethodEnum;
}>;
interface GetAssetsRes {
    assets: CustomerAsset[];
    page: number;
    totalPages: number;
}
type GetAssetGroupsRes = {
    [assetGroupName: string]: CustomerAsset[];
}[];
interface ShareAssetReq {
    to: {
        email: string;
        name: string;
    }[];
}
declare const chainServiceStatuses: readonly ["INFO", "PHOTO", "OFFICIALS", "QRCODE", "RFID", "WITNESS", "MINTED"];
type GetAssetGroupsResponse = {
    [assetGroupName: string]: CustomerAsset[];
}[];
interface ShareAssetRequest {
    to: {
        email: string;
        name: string;
    }[];
}
interface CategoriesRequest {
    parentId?: string;
    parentIds?: string[];
    appName?: string;
    name?: string;
    isActive?: boolean;
    state?: CategoryStatusEnum;
    vdtType?: ChainTypeEnum;
}
interface SearchAssetTypesRequest {
    categoryId?: string;
    name?: string;
    isActive?: boolean;
    state?: CategoryStatusEnum;
    vdtType?: ChainTypeEnum;
}
type GetActiveAssetTemplateRequest = {
    typeId: string;
    step: StepEnum;
};
type GetAssetWitnessesRequest = PagedRequest<{
    userId?: string;
    assetId?: string;
}>;
type GetPublicWitnessesRequest = PagedRequest<{
    eventId?: string;
    relationType?: RelationTypeEnum;
}>;
interface AddReferenceVdtRequest {
    serviceId?: string;
    assetId: string;
    qrCodeRefId: string;
    vdtType: ChainTypeEnum;
    bitSysId: string;
    relationType: RelationTypeEnum;
    data?: {
        title: string;
    };
}
interface AddReferenceVdtResponse {
    assetId: string;
    qrCodeRefId: string;
    vdtType: ChainTypeEnum;
    bitSysId: string;
    relationType: RelationTypeEnum;
    createdAt: string;
    data: {
        title: string;
    };
}
interface CreateListingRequest {
    id: string;
    sellingMethod: SellingMethodEnum;
    price: number;
    startAt?: string;
    endAt?: string;
    description: string;
    isFreeShipping: boolean;
    shippingDetail?: {
        shipFrom: BaseAddress & {
            phone: string;
        };
        weight: number;
        length: number;
        width: number;
        height: number;
        handlingFee: number;
        unitOfMeasurement: string;
        packagingType: string;
    };
    revenue: number;
}
interface CreateListingResponse {
    id: string;
    assetId: string;
    sellerId: string;
    sellerWallet: string;
    listingType: string;
    plstform: string;
    chainName: string;
    tokenId: string;
    tokenContract: string;
    startDate: string;
    endDate: string;
}
interface ListFinalWithTypes {
    appName: string;
    $resolveImages?: boolean;
}
interface CollectionReport {
    fileFormat: FileFormatEnum;
    url: string;
    fileName: string;
}

interface EventGroupItem {
    relationType: EventRelationType;
    event: ChainAssetEvent & {
        id: string;
        eventType: string;
    };
    approved?: boolean;
}

interface IChainService {
    chainApiUrl: string;
    create: (req: CreateChainBaseRequest) => Promise<ChainBaseEvent>;
    createAttachments: (req: CreateAttachmentsPayload) => Promise<UploadedAttachmentData[]>;
    createQrAttachment: (eventId: string, req: CreateQrAttachmentRequest) => Promise<void>;
    getEvent: (eventId: string) => Promise<ChainBaseEvent>;
    getChildEvents: (eventId: string) => Promise<EventGroupItem[]>;
    getDetailsByEvent: (eventId: string) => Promise<CustomerAsset>;
    getDetails: (assetId: string) => Promise<CustomerAsset>;
    assetByQr: (qrId: string) => Promise<ChainBaseEvent>;
    getAttachmentImageUrl: (attId: string, thumb?: boolean) => string;
    getWitnesses: (req: GetWitnessAssetsRequest) => Promise<PagedResponse<WitnessAsset>>;
    update: (eventId: string, req: UpdateChainBaseDetailsRequest) => Promise<ChainBaseEvent>;
    updateMetadata: (eventId: string, req: UpdateMetadataRequest) => Promise<ChainBaseEventData>;
    updateLocationPrivacy: (eventId: string, req: UpdateLocationPrivacyRequest) => Promise<void>;
    linkQr: (qrId: string, req: LinkQrRequest) => Promise<QrPackageCodeResponse>;
    generateQr: (req: GenerateQrRequest) => Promise<QrPackageCodeResponse>;
    deleteAttachments: (attId: string) => Promise<any>;
    addReferenceVdt: (req: AddReferenceVdtRequest) => Promise<AddReferenceVdtRequest>;
    updateAttachments: (eventId: string, req: UpdateAttachmentRequest) => Promise<UpdateAttachmentResponse>;
    updateConfirmStatus: (eventId: string) => Promise<void>;
    deleteReferenceVdt: (id: string, qrCodeRefId: string) => Promise<void>;
    eventByQr: (qrId: string) => Promise<Event>;
    updateFavorite: (req: UpdateFavoriteRequest) => Promise<void>;
    share: (eventId: string, data: ShareAssetRequest) => Promise<void>;
}
interface CreateAttachmentsPayload {
    eventId: string;
    req: CreateAttachmentRequest;
    chainType?: string;
    onUpload?: (index: number, total: number) => void;
}
interface CreateAttachmentRequest {
    application: ApplicationData;
    device: DeviceData;
    eventId: string;
    docs: CreateAttachmentInputData[];
}
interface UpdateAttachmentRequest {
    application: ApplicationData;
    docs: UpdateAttachmentInputData[];
}
interface CreateQrAttachmentRequest {
    application: ApplicationData;
    device: DeviceData;
    docs: CreateQrAttachmentInputData[];
}
interface UpdateChainBaseDetailsRequest {
    date: string;
}
interface UpdateMetadataRequest {
    metadata: ChainBaseEventMetadata;
}
declare enum LocationAccuracy {
    Exact = "exact",
    City = "city",
    State = "state",
    Country = "country"
}
interface UpdateLocationPrivacyRequest {
    locationAccuracy: LocationAccuracy;
    city?: string;
    state?: string;
    country?: string;
}
interface LinkQrRequest {
    eventId: string;
    device: DeviceData;
    isAdminAsset?: boolean;
}
interface QrPackageCodeResponse {
    id: string;
    eventId?: string;
    package?: {
        id: string;
        isSystem: boolean;
        isCategoryDefault: boolean;
        type: QrPackageTypeEnum;
        name: string;
        url: string;
        qrCodeTotalCount: number;
        createdBy: string;
        createdAt: string;
    };
}
interface GenerateQrRequest {
    application: ApplicationData;
    type: QrPackageTypeEnum;
    categoryId?: string;
    orgId?: string;
}
type GetWitnessAssetsRequest = PagedRequest<{
    name?: string;
    id?: string;
    userId: string;
    relationType?: RelationsTypeEnum;
    isMinted?: boolean;
    categoryId?: string;
}>;
interface UpdateFavoriteRequest {
    ids: string[];
    isFavorite: boolean;
}

interface CreateChainAssetRequest extends CreateChainBaseRequest {
    data: CreateChainBaseRequest['data'] & {
        asset?: ChainAssetEventData;
    };
}
interface UpdateChainAssetDetailsRequest extends UpdateChainBaseDetailsRequest {
    asset?: ChainAssetEventData;
}
interface ChainAssetEvent extends ChainBaseEvent {
    assetType?: string;
    data?: ChainAssetEventData;
}

interface ChainServiceEventData extends ChainBaseEventData {
    serviceType?: string;
    serviceCategory?: string[];
    serviceName?: string;
    isFavorite?: boolean;
    serviceProperties?: ServiceTypePropertyData[];
    metadata?: ChainServiceEventMetadata;
}
interface ChainServiceEventMetadata extends ChainBaseEventMetadata {
    serviceTypeId?: string;
}
interface ServiceTypePropertyData extends BaseTypePropertyData {
    isServiceName?: boolean;
}

interface CreateChainServiceRequest extends CreateChainBaseRequest {
    data: CreateChainBaseRequest['data'] & {
        service?: ChainServiceEventData;
    };
}
interface UpdateChainServiceDetailsRequest {
    date: string;
    service?: ChainServiceEventData;
}
interface ChainServiceEvent extends ChainBaseEvent {
    serviceType?: string;
    data: ChainServiceEventData;
}

declare enum VerifyTypeEnum {
    NOT_VERIFIED = "notVerified",
    OFFICIAL_VERIFIED = "verifiedByOfficial",
    OFFICIAL_REJECTED = "rejectedByOfficial",
    SELF_VERIFIED = "selfVerified"
}

declare enum EOrderStatus {
    Created = "CREATED",
    ShippingInfo = "SHIPPING_INFO",
    PaymentCompleted = "PAYMENT_COMPLETED",
    PaymentFailed = "PAYMENT_FAILED",
    Confirmed = "CONFIRMED",
    Canceled = "CANCELED",
    OrderShipped = "ORDER_SHIPPED",
    OrderDelivered = "ORDER_DELIVERED",
    OwnershipTransferStarted = "OWNERSHIP_TRANSFER_STARTED",
    OwnershipTransferCompleted = "OWNERSHIP_TRANSFER_COMPLETED",
    OwnershipTransferFailed = "OWNERSHIP_TRANSFER_FAILED",
    OrderUndelivered = "ORDER_UNDELIVERED",
    OrderSuccess = "ORDER_SUCCESS",
    Return = "RETURN",
    ReturnShipped = "RETURN_SHIPPED",
    ReturnDelivered = "RETURN_DELIVERED",
    ReturnUndelivered = "RETURN_UNDELIVERED",
    Refund = "REFUND",
    RefundCompleted = "REFUND_COMPLETED",
    RefundFailed = "REFUND_FAILED"
}
interface OrderDataDataResponse {
    id: string;
    listingId: string;
    assetId: string;
    sellerId: string;
    buyerId: string;
    price: number;
    status: EOrderStatus;
    createdAt: Date;
    updatedAt: Date;
    ownershipChangedAt: Date;
}
interface OwnershipHistoryResponse {
    id: string;
    assetId: string;
    ownerId: string;
    orderData: OrderDataDataResponse;
    orgId: string;
    asset: CustomerAsset;
    createdAt: string;
}

declare enum EWitnessStatus {
    Created = "CREATED",
    MintingStarted = "MINTING_STARTED",
    MintingFailed = "MINTING_FAILED",
    Minted = "MINTED"
}
declare enum ERelationType {
    CheckinOfficial = "CHECKIN_OFFICIAL",
    CheckinWitness = "CHECKIN_WITNESS",
    CheckinInspector = "CHECKIN_INSPECTOR",
    CheckinBuyer = "CHECKIN_BUYER",
    CheckinSeller = "CHECKIN_SELLER",
    ParentVDT = "PARENT_VDT",
    ChildVDT = "CHILD_VDT",
    CheckinArchive = "CHECKIN_ARCHIVE"
}
interface WitnessAsset {
    id: string;
    status: EWitnessStatus;
    relationType: ERelationType;
    userId?: string;
    name?: string;
    email?: string;
    firstName?: string;
    lastName?: string;
    avatarUrl?: string;
    serializedImages?: SerializedImage[];
    serializedProps: SerializedProp[];
    eventIdRef: string;
    isMinted: boolean;
    city: string;
    state: string;
    country: string;
    locationAccuracy: 'exact' | 'city';
    geolocation: GeolocationData;
    createdAt: Date;
    mintedAt?: Date;
    approved: boolean;
    level: number;
    categoryId?: string;
    asset?: CustomerAsset;
}

interface GetAttachmentLinkOpts {
    apiUrl: string;
    id: string;
    bitToken: string;
    accessToken: string;
    thumb?: boolean;
}
declare function getAttachmentLink(opts: GetAttachmentLinkOpts): string;
interface CreateAndUploadAttachmentsOpts {
    service: BaseService;
    chainApiUrl: string;
    req: CreateAttachmentsPayload;
}
declare function createAndUploadAttachments(opts: CreateAndUploadAttachmentsOpts): Promise<UploadedAttachmentData[]>;

interface AssetServiceOptions {
    route: 'asset' | 'service';
}
declare class AssetService extends BaseService {
    assetApiUrl: string;
    constructor(opts: BaseServiceOptions & AssetServiceOptions);
    list(req?: GetAssetsRequest): Promise<PagedResponse<CustomerAsset>>;
    listPublic(req?: GetAssetsRequest): Promise<PagedResponse<CustomerAsset>>;
    favorites(req?: GetAssetsRequest): Promise<PagedResponse<FavoriteAsset>>;
    listGroup(): Promise<GetAssetGroupsResponse>;
    listCategories(req?: FilteredRequest<CategoriesRequest>): Promise<AssetCategory[]>;
    searchCategories(req?: PagedRequest<CategoriesRequest>): Promise<PagedResponse<AssetCategory>>;
    getCategoryByName(name?: string): Promise<AssetCategory>;
    getCategoryById(categoryId?: string, headers?: AxiosRequestHeaders): Promise<AssetCategory>;
    searchAssetTypes(req?: PagedRequest<SearchAssetTypesRequest>): Promise<PagedResponse<AssetType>>;
    listAssetTypes(req?: PagedRequest<SearchAssetTypesRequest>): Promise<AssetType[]>;
    getActiveAssetTemplate(req?: GetActiveAssetTemplateRequest, headers?: AxiosRequestHeaders): Promise<AssetTemplate>;
    getAssetType(assetTypeId: string, headers?: AxiosRequestHeaders): Promise<AssetType>;
    getAssetTypeSteps(assetTypeId: string): Promise<AssetTypeStep>;
    share(eventId: string, data: ShareAssetRequest): Promise<any>;
    witnesses(req?: GetAssetWitnessesRequest): Promise<PagedResponse<AssetWitness>>;
    witnessesPublic(req?: GetPublicWitnessesRequest): Promise<PagedResponse<AssetWitness>>;
    addReferenceVdt(req: AddReferenceVdtRequest): Promise<AddReferenceVdtResponse>;
    createListing(props: CreateListingRequest): Promise<CreateListingResponse>;
    getAssetChainDetails(eventId: string): Promise<ChainBaseEvent>;
    getOwnershipHistory(req?: GetAssetsRequest): Promise<PagedResponse<OwnershipHistoryResponse>>;
    getAssociatedAssets(req?: GetAssetsRequest): Promise<PagedResponse<CustomerAsset>>;
    vdtReport(fileFormat: FileFormatEnum): Promise<CollectionReport>;
}

declare function makeGetAssetsParams(req?: Partial<GetAssetsRequest>): GetAssetsRequest;

declare function getAssetStatusIndex(status: AssetStatus): number;
declare function isAssetStatusBefore(currentStatus: AssetStatus, targetStatus: AssetStatus): boolean;
declare function isAssetStatusAfter(currentStatus: AssetStatus, targetStatus: AssetStatus): boolean;
declare function isAssetStatusFinished(currentStatus: AssetStatus, targetStatus: AssetStatus): boolean;
/**
 * There is a backend logical bug that causes BITDEV-1389:
 * - Token's status updates to "PHOTO_ADDED" after witness verification
 *
 * The workaround for the above bug is to
 * manually check "serializedSteps" instead of "status" property.
 *
 * See function directly below for the workaround version
 * (exact same function but without the status checks).
 */
declare function getAssetVerifyStatus(a: CustomerAsset): VerifyTypeEnum.NOT_VERIFIED | VerifyTypeEnum.OFFICIAL_VERIFIED | VerifyTypeEnum.SELF_VERIFIED;
declare function getAssetVerifyStatusBySteps(a: CustomerAsset): VerifyTypeEnum;
declare function getAssetVerifyRejected(data: WitnessCustomerAssetResponse[]): boolean;

declare class ChainAssetService extends BaseService implements IChainService {
    chainApiUrl: string;
    constructor(opts: BaseServiceOptions);
    create(req: CreateChainAssetRequest): Promise<ChainAssetEvent>;
    createAttachments(req: CreateAttachmentsPayload): Promise<UploadedAttachmentData[]>;
    createQrAttachment(eventId: string, req: CreateQrAttachmentRequest): Promise<void>;
    getEvent(eventId: string): Promise<ChainAssetEvent>;
    getChildEvents(eventId: string): Promise<EventGroupItem[]>;
    getDetailsByEvent(eventId: string): Promise<CustomerAsset>;
    getDetails(assetId: string): Promise<CustomerAsset>;
    assetByQr(qrId: string): Promise<ChainAssetEvent>;
    eventPublicByQr(qrId: string): Promise<ChainAssetEvent>;
    getAttachmentImageUrl(attachmentId: string, thumb?: boolean): string;
    getWitnesses(req: GetWitnessAssetsRequest): Promise<PagedResponse<WitnessAsset>>;
    update(eventId: string, req: UpdateChainAssetDetailsRequest): Promise<ChainAssetEvent>;
    updateMetadata(eventId: string, req: UpdateMetadataRequest): Promise<ChainAssetEventData>;
    updateLocationPrivacy(eventId: string, req: UpdateLocationPrivacyRequest): Promise<void>;
    linkQr(qrId: string, req: LinkQrRequest): Promise<QrPackageCodeResponse>;
    generateQr(req: GenerateQrRequest): Promise<QrPackageCodeResponse>;
    deleteAttachments(attId: string): Promise<any>;
    addReferenceVdt(req: AddReferenceVdtRequest): Promise<AddReferenceVdtRequest>;
    updateAttachments(eventId: string, req: UpdateAttachmentRequest): Promise<UpdateAttachmentResponse>;
    updateConfirmStatus(eventId: string): Promise<void>;
    deleteReferenceVdt(id: string, qrCodeRefId: string): Promise<void>;
    eventByQr(qrId: string): Promise<Event>;
    updateFavorite(req: UpdateFavoriteRequest): Promise<void>;
    share(eventId: string, data: ShareAssetRequest): Promise<any>;
}

interface MakeCreateAttachmentRequestOpts {
    appId?: string;
    eventId: string;
    deviceId?: string;
    deviceName?: string;
    deviceType?: DeviceTypeEnum;
    geolocation?: GeolocationData;
    ipAddress?: string;
    docs?: CreateAttachmentInputData[];
    chainType?: string;
}
declare function makeCreateAttachmentsRequest(opts: MakeCreateAttachmentRequestOpts): CreateAttachmentsPayload;
interface MakeCreateQrAttachmentRequestOpts {
    qrImageBase64: string;
    appId?: string;
    eventId: string;
    deviceId?: string;
    deviceName?: string;
    deviceType?: DeviceTypeEnum;
    geolocation?: GeolocationData;
    ipAddress?: string;
    docs?: CreateQrAttachmentInputData[];
}
declare function makeCreateQrAttachmentRequest(opts: MakeCreateQrAttachmentRequestOpts): CreateQrAttachmentRequest;

declare class ChainServiceService extends BaseService implements IChainService {
    chainApiUrl: string;
    constructor(opts: BaseServiceOptions);
    create(req: CreateChainServiceRequest): Promise<ChainServiceEvent>;
    createAttachments(req: CreateAttachmentsPayload): Promise<UploadedAttachmentData[]>;
    createQrAttachment(eventId: string, req: CreateQrAttachmentRequest): Promise<void>;
    getEvent(eventId: string): Promise<ChainServiceEvent>;
    getChildEvents(eventId: string): Promise<EventGroupItem[]>;
    getDetailsByEvent(eventId: string): Promise<CustomerAsset>;
    getDetails(serviceId: string): Promise<CustomerAsset>;
    assetByQr(qrId: string): Promise<ChainServiceEvent>;
    getAttachmentImageUrl(attachmentId: string, thumb?: boolean): string;
    getWitnesses(req: GetWitnessAssetsRequest): Promise<PagedResponse<WitnessAsset>>;
    update(eventId: string, req: UpdateChainServiceDetailsRequest): Promise<ChainServiceEvent>;
    updateMetadata(eventId: string, req: UpdateMetadataRequest): Promise<ChainServiceEventData>;
    updateLocationPrivacy(eventId: string, req: UpdateLocationPrivacyRequest): Promise<void>;
    linkQr(qrId: string, req: LinkQrRequest): Promise<QrPackageCodeResponse>;
    generateQr(req: GenerateQrRequest): Promise<QrPackageCodeResponse>;
    deleteAttachments(attachmentId: string): Promise<unknown>;
    addReferenceVdt(req: AddReferenceVdtRequest): Promise<AddReferenceVdtRequest>;
    updateAttachments(eventId: string, req: UpdateAttachmentRequest): Promise<UpdateAttachmentResponse>;
    updateConfirmStatus(eventId: string): Promise<void>;
    deleteReferenceVdt(id: string, qrCodeRefId: string): Promise<void>;
    getS2CEventByQrId(qrId: string, vdtType: ChainTypeEnum, orgId?: string): Promise<S2CCustomerAsset[]>;
    eventByQr(qrId: string): Promise<Event>;
    updateFavorite(req: UpdateFavoriteRequest): Promise<void>;
    share(eventId: string, data: ShareAssetRequest): Promise<any>;
}

declare class ChainUtils {
    static getName(data: ChainBaseEventData): string;
    static getNameFromProperties(props: BaseTypePropertyData[]): string;
    static getCategories(data: ChainBaseEventData): string[];
    static getProperties(data: ChainBaseEventData): BaseTypePropertyData[];
    static getMimeType(mimeType: string): AttachmentType.TokenDocument | AttachmentType.TokenPhoto;
    static findMainPhotoByTypeClass<TPhotos extends Pick<AttachmentData, 'classification' | 'isMain'>>(opts: FindMainPhotoByTypeClassOpts<TPhotos>): TPhotos | undefined;
    static getAttachmentClassification(chainType: ChainTypeEnum, attachmentType: AttachmentType): any;
    static getType(data: ChainBaseEventData): {
        id: string;
        name: string;
    };
    static makeCreateChainRequest(opts: MakeCreateChainRequestOpts): CreateChainBaseRequest;
    static makeUpdateChainRequest(opts: MakeUpdateChainRequestOpts): UpdateChainBaseDetailsRequest;
    static isOfficialVerified(chainType: ChainTypeEnum, childEvents: EventGroupItem[]): Promise<boolean>;
}
interface MakeCreateChainRequestOpts {
    chainType: ChainTypeEnum;
    appId?: string;
    deviceId?: string;
    deviceName?: string;
    deviceType?: DeviceTypeEnum;
    geolocation?: GeolocationData;
    ipAddress?: string;
    weather?: WeatherData;
    eventDate?: string;
    type?: string;
    category?: string[];
    name?: string;
    properties?: BaseTypePropertyData[];
    typeId?: string;
    metadata?: Partial<ChainBaseEventMetadata>;
    subjectType?: SubjectTypeEnum;
    auth0Id: string;
    endUserId: string;
    orgId?: string;
    isFavorite?: boolean;
}
interface MakeUpdateChainRequestOpts {
    chainType: ChainTypeEnum;
    type?: string;
    category?: string[];
    name?: string;
    isFavorite?: boolean;
    properties?: BaseTypePropertyData[];
    metadata?: Partial<ChainBaseEventMetadata>;
}

declare class S2CAssetService extends BaseService {
    listS2CCategories(req?: FilteredRequest<CategoriesRequest>): Promise<AssetCategory[]>;
    listS2CFinalType(req: ListFinalWithTypes): Promise<AssetCategory[]>;
}

interface IncodeExtendedOcrDataCommon {
    ocrData: {
        name: {
            fullName: string;
            machineReadableFullName: string;
            firstName: string;
            middleName: string;
            givenName: string;
            paternalLastName: string;
        };
        address: string;
        addressFields: {
            street: string;
            postalCode: string;
            city: string;
            state: string;
        };
        checkedAddress: string;
        checkedAddressBean: {
            street: string;
            postalCode: string;
            city: string;
            state: string;
            label: string;
            zipColonyOptions: any[];
        };
        birthDate: string;
        gender: string;
        documentNumber: string;
        issuedAt: string;
        expireAt: string;
        expirationDate: number;
        issueDate: number;
        additionalTimestamps: any[];
        issuingCountry: string;
        fullNameMrz: string;
        ocrDataConfidence: {
            birthDateConfidence: number;
            nameConfidence: number;
            givenNameConfidence: number;
            firstNameConfidence: number;
            middleNameConfidence: number;
            fathersSurnameConfidence: number;
            fullNameMrzConfidence: number;
            addressConfidence: number;
            streetConfidence: number;
            postalCodeConfidence: number;
            cityConfidence: number;
            stateConfidence: number;
            countryCodeConfidence: number;
            genderConfidence: number;
            issueDateConfidence: number;
            expirationDateConfidence: number;
            issuedAtConfidence: number;
            expireAtConfidence: number;
            documentNumberConfidence: number;
        };
    };
}
interface IncodeExtendedOcrDataPassport {
    ocrData: {
        typeOfId: 'Passport';
        nationalityMrz: string;
        gender: string;
        documentNumber: string;
        documentNumberCheckDigit: string;
        ocrDataConfidence: {
            birthDateConfidence: number;
            genderConfidence: number;
            numeroEmisionCredencialConfidence: number;
            fathersSurnameConfidence: number;
            givenNameConfidence: number;
            fullNameMrzConfidence: number;
            documentNumberConfidence: number;
            birthPlaceConfidence: number;
            nationalityMrzConfidence: number;
            expireAtConfidence: number;
            mrz1Confidence: number;
            nationalityConfidence: number;
            issuedAtConfidence: number;
            expirationDateConfidence: number;
            middleNameConfidence: number;
            mrz2Confidence: number;
            issuingAuthorityConfidence: number;
        };
        expireAt: string;
        dateOfBirthCheckDigit: string;
        birthDate: number;
        mrz2: string;
        mrz1: string;
        birthPlace: string;
        issuingAuthority: string;
        fullNameMrz: string;
        additionalTimestamps: any[];
        nationality: string;
        issuingCountry: string;
        name: {
            givenNameMrz: string;
            firstName: string;
            lastNameMrz: string;
            givenName: string;
            fullName: string;
            paternalLastName: string;
            middleName: string;
            machineReadableFullName: string;
        };
        checkedAddressBean: {
            zipColonyOptions: any[];
        };
        documentFrontSubtype: string;
        issuedAt: string;
        issueDate: number;
        expirationDate: number;
        expirationDateCheckDigit: string;
    };
}
interface IncodeExtendedOcrDataDriversLicense {
    ocrData: {
        name: {
            fullName: string;
            machineReadableFullName: string;
            firstName: string;
            middleName: string;
            givenName: string;
            paternalLastName: string;
        };
        address: string;
        addressFields: {
            street: string;
            postalCode: string;
            city: string;
            state: string;
        };
        checkedAddress: string;
        checkedAddressBean: {
            street: string;
            postalCode: string;
            city: string;
            state: string;
            label: string;
            zipColonyOptions: any[];
        };
        typeOfId: 'DriversLicense';
        documentFrontSubtype: string;
        documentBackSubtype: string;
        birthDate: number;
        gender: string;
        documentNumber: string;
        refNumber: string;
        issuedAt: string;
        expireAt: string;
        expirationDate: number;
        issueDate: number;
        additionalTimestamps: any[];
        issuingCountry: string;
        issuingState: string;
        height: string;
        weight: string;
        eyeColor: string;
        classes: string;
        mentions: string;
        restrictions: string;
        fullNameMrz: string;
        barcodeRawData: string;
        ocrDataConfidence: {
            birthDateConfidence: number;
            nameConfidence: number;
            givenNameConfidence: number;
            firstNameConfidence: number;
            middleNameConfidence: number;
            fathersSurnameConfidence: number;
            fullNameMrzConfidence: number;
            addressConfidence: number;
            streetConfidence: number;
            postalCodeConfidence: number;
            cityConfidence: number;
            stateConfidence: number;
            countryCodeConfidence: number;
            genderConfidence: number;
            issueDateConfidence: number;
            expirationDateConfidence: number;
            issuedAtConfidence: number;
            expireAtConfidence: number;
            documentNumberConfidence: number;
            heightConfidence: number;
            eyeColorConfidence: number;
            classesConfidence: number;
            mentionsConfidence: number;
            refNumberConfidence: number;
            weightConfidence: number;
            restrictionsConfidence: number;
        };
    };
}

interface IncodeInitializeOptions {
    /** Incode SDK API key */
    apiKey: string;
    /** Incode SDK API URL */
    apiUrl: string;
    /**
     * **Note:** Only relevant for Mobile.
     *
     * If this is true then "emulator" mode is assumed,
     * and Face Recognition step is skipped.
     *
     * We will also return useless values (i.e. `'testmode'`)
     * as the result of face recognition methods.
     *
     */
    isMobileEmulator?: boolean;
    /**
     * **Note:** Only relevant for Mobile.
     *
     * Default value is `false`.
     * This makes the user see Incode tutorials (which is skippable).
     */
    waitForTutorials?: boolean;
}
interface IIncodeService {
    initialize(config: IncodeInitializeOptions): Promise<void>;
}

interface IStorage {
    setItem(key: string, value: string): Promise<void>;
    getItem(key: string): Promise<string | null>;
    removeItem(key: string): Promise<void>;
    clear(): Promise<void>;
}

interface IncodeOcrResult {
    extendedOcrData: string;
    data: {
        numeroEmisionCredencial: string;
        name: string;
        address: {
            street: string;
            state: string;
            postalCode: string;
            colony: string;
            city: string;
        };
        gender: string;
        birthDate: string;
        issueDate: number;
        expirationDate: number;
        fullAddress: string;
    };
}

type BiometricsServiceOptions = IncodeInitializeOptions & {
    /**
     * Web and Mobile have different implementations of IncodeSdk.
     *
     * Based on the platform being used,
     * the appropriate service class needs to be passed here.
     */
    incodeService: IIncodeService;
    /**
     * Web and Mobile have different libraries / services
     * for storing persistent data in a key/value store.
     *
     * Based on the platform being used,
     * the asessionTokenppropriate storage instance needs to be passed here.
     */
    storage: IStorage;
    /** Optional `LoggerType` object to be able to see our debug / info logs */
    logger?: LoggerType;
};
interface SignInOptions {
    /**
     * Session Token from BIT Authentication flow.
     *
     * If this is passed, we try the following:
     * - If user's `email` matches email persisted from the previous session,
     * -
     */
    sessionToken?: string;
}
declare class BiometricsService {
    private options;
    /** Platform-specific Incode service class */
    incode: IIncodeService;
    /** Platform-specific storage (e.g. `localStorage`, `EncryptedStorage`) */
    private storage?;
    private mode;
    private sessionToken?;
    private logger?;
    constructor(options: BiometricsServiceOptions);
    /**
     * Two reasons why this method needs to be called separately and is `async`
     *
     * Web - needs to call `warmup()` which is `async`
     *
     * Mobile - `IncodeSdk.initialize(...)` is `async`
     */
    initialize(): Promise<void>;
    signIn(): Promise<void>;
    signUp(options?: SignInOptions): Promise<void>;
}

declare enum BiometricsModeEnum {
    SignIn = "sign-in",
    SignUp = "sign-up"
}
/**
 * Key values used to store persistent data for future Biometrics sessions
 */
declare enum BiometricsStorageKeyEnum {
    /**
     * I don't remember why we have to store the email
     * that the user used for authenticating.
     */
    AuthEmails = "authEmails"
}

interface CheckInEventInput {
    application: ApplicationData;
    rootEvent: RootEventData;
    subject: SubjectData;
    device: DeviceData;
    data: {
        date: string;
        geolocation: GeolocationData;
        attachments: CreateAttachmentInputData[];
    };
    event: EventData;
}
interface CheckInEvent {
    id: string;
    eventType: string;
    application: string;
    device: DeviceData;
    status: string;
    subjectType: string;
    attachments: AttachmentData[];
    eventDate?: string;
    subjectReferences: SubjectDataReferenceItem[];
    properties?: CheckInProperty[];
    metadata?: Partial<ChainBaseEventMetadata>;
}
interface CheckInProperty {
    id: string;
    name: string;
    value: string;
}
declare enum VerificationTypeEnum {
    Reject = "Reject",
    Official = "Official",
    Witness = "Witness",
    Buyer = "Buyer",
    Seller = "Seller",
    Review = "Review",
    Inspection = "Inspection",
    Archive = "Archive"
}

interface CreateCheckInEventRequest {
    application: ApplicationData;
    subject: SubjectData;
    device: DeviceData;
    event?: {
        eventType: string;
        eventToken: string;
        eventDate: string;
        eventRelation: {
            relationType: RelationTypeEnum;
            rootEventId: string;
        };
    };
    data: {
        date: string;
        properties?: CheckInProperty[];
        attachments?: CreateAttachmentInputData[];
        approved?: boolean;
        categoryId?: string;
    };
}
type GetCheckInEventsRequest = Record<string, string> & {
    endUserId?: string;
};
interface UpdateCheckInAttachmentRequest {
    application: ApplicationData;
    eventId: string;
    geolocation: GeolocationData;
    docs: UpdateAttachmentInputData[];
    eventToken?: string;
    relationType?: RelationTypeEnum;
}

declare class CheckInService extends BaseService {
    checkinApiUrl: string;
    constructor(opts: BaseServiceOptions);
    createCheckIn(req: CreateCheckInEventRequest): Promise<CheckInEvent>;
    getEvent(eventId: string): Promise<CheckInEvent>;
    getCheckInEvents(req?: PagedRequest<GetCheckInEventsRequest>): Promise<PagedResponse<CheckInEvent>>;
    updateAttachment(req: UpdateCheckInAttachmentRequest): Promise<UpdateAttachmentResponse>;
    getAttachmentImage(attId: string, thumb?: boolean): Promise<ViewAttachmentResponse>;
    updateLocationPrivacy(eventId: string, req: UpdateLocationPrivacyRequest): Promise<void>;
}

interface MakeCreateCheckInEventRequestOpts {
    appId?: string;
    reference?: SubjectDataReferenceItem;
    deviceId?: string;
    deviceName?: string;
    deviceType?: DeviceTypeEnum;
    geolocation?: GeolocationData;
    ipAddress?: string;
    attachments?: CreateAttachmentInputData[];
    properties?: CheckInProperty[];
    auth0Id?: string;
    orgId?: string;
    subjectType?: SubjectTypeEnum;
    parentEvent?: CreateCheckInEventRequest['event'];
    approved?: boolean;
    categoryId?: string;
}
declare function makeCreateCheckInEventRequest(opts?: MakeCreateCheckInEventRequestOpts): CreateCheckInEventRequest;
interface MakeUpdateCheckInAttachmentRequestOpts {
    appId?: string;
    eventId: string;
    geolocation: GeolocationData;
    attachmentId: string;
    name?: string;
    imageBase64: string;
    classification: AttachmentClassification;
    isMain?: boolean;
    eventToken?: string;
    relationType?: RelationTypeEnum;
}
declare function makeUpdateCheckInAttachmentRequest(opts: MakeUpdateCheckInAttachmentRequestOpts): UpdateCheckInAttachmentRequest;

interface ReasonsRequest {
    actions?: ActionType[];
    name?: string;
    isActive?: boolean;
    createdBy?: string;
    $ids?: string[];
    $orderBy?: string;
    $order?: 'asc' | 'desc';
}
interface ActionReason {
    id: string;
    createdBy: string;
    action: string;
    name: string;
    description: string;
    isActive: boolean;
    createdAt: string;
}
declare enum ActionType {
    OfficialRejectVerification = "OFFICIAL_REJECT_VERIFICATION",
    SellerRejectOrder = "SELLER_REJECT_ORDER",
    SellerRejectBid = "SELLER_REJECT_BID",
    BuyerRejectDelivery = "BUYER_REJECT_DELIVERY",
    UserArchiveS2CToken = "USER_ARCHIVE_S2S_TOKEN"
}
type ListApplicationsRequest = FilteredRequest<{
    name?: string;
    friendlyName?: string;
    names?: string[];
    $resolveImages?: boolean;
}>;
interface Application {
    name: string;
    friendlyName: string;
    description: string;
    logoUrl: string | null;
    isEncrypted: boolean;
    createdAt: string;
    updatedAt: string;
}

declare class CommonAdminService extends BaseService {
    listReasons(req: FilteredRequest<ReasonsRequest>): Promise<ActionReason[]>;
    listApplications(req: FilteredRequest<ListApplicationsRequest>): Promise<Application[]>;
}

interface DeviceOwner {
    id: string;
    isPersonal: boolean;
}
interface DeviceInformation {
    model: string;
    os: string;
    imei: string;
    macAddress: string;
}
interface Device {
    id: string;
    typeId: DeviceTypeIdEnum;
    typeName: DeviceTypeEnum;
    hardwareLevel: number;
    orgId?: string;
    userId?: string;
    image?: string;
    appName: string;
    owner: DeviceOwner;
    externalId: string;
    name: string;
    deviceInfo: DeviceInformation;
    locationId?: string;
    latitude: number;
    longitude: number;
    meanSeaLevel: number;
    platform: 'ethereum' | 'polygon';
    recipientAddress: string;
    createdAt?: string | null;
    deletedAt?: string | null;
}

type SearchDevicesRequest = PagedRequest<{
    name?: string;
    isPersonal: boolean;
    externalId?: string;
    orgId?: string;
    locationId?: string;
    userId?: string;
    typeId?: string;
    isActive?: boolean;
    showSoftDeleted?: boolean;
}>;
interface RegisterDeviceRequest {
    appName: string;
    owner: DeviceOwner;
    externalId: string;
    name: string;
    typeId: number;
    deviceInfo?: DeviceInformation;
    locationId?: string;
    latitude: number;
    longitude: number;
    meanSeaLevel: number;
    platform: WalletPlatformEnum;
    recipientAddress: string;
}
interface RegisterAdminDeviceRequest {
    appName: string;
    owner: DeviceOwner;
    externalId: string;
    name: string;
    typeId: number;
    deviceInfo?: DeviceInformation;
    locationId?: string;
    latitude: number;
    longitude: number;
    meanSeaLevel: number;
}
interface ValidateDeviceRequest {
    id?: string;
    externalId: string;
    isPersonal: boolean;
}
interface ValidateDeviceResponse {
    isRegistered: boolean;
}
interface InitDeviceVdtRequest {
    appName: string;
    deviceId: string;
    latitude: number;
    longitude: number;
    meanSeaLevel: number;
    platform: string;
    recipientAddress: string;
}

declare class DeviceService extends BaseService {
    protected deviceApiUrl: string;
    constructor(opts: BaseServiceOptions);
    searchDevices(req: SearchDevicesRequest): Promise<PagedResponse<Device>>;
    registerDevice(req: RegisterDeviceRequest): Promise<Device>;
    registerAdminDevice(req: RegisterAdminDeviceRequest): Promise<Device>;
    getAdminDeviceByExternalId(externalId: string): Promise<Device>;
    validateDevice(req: ValidateDeviceRequest): Promise<ValidateDeviceResponse>;
    getDeviceByExternalId(externalId: string): Promise<Device>;
    unregisterDevice(externalId: string): Promise<void>;
    initDeviceVdt(req: InitDeviceVdtRequest): Promise<void>;
    getDeviceInfoById(deviceId: string): Promise<Device>;
}

interface Inventory {
    id: string;
    userId: string;
    orgId: string;
    name: string;
    isArchived: boolean;
    createdAt: string;
    archivedBy: string;
    archivedAt: string;
    archivedOrgId: string;
}
interface AddInventoryItemRequest {
    inventoryId: string;
    serviceId: string;
    qrCodeId?: string;
    vdtType: ChainTypeEnum;
    typeId: string;
    bitSysId: string;
}
interface InventoryItem {
    isArchived: boolean;
    createdAt: string;
    archivedBy: string;
    archivedAt: string;
    archivedOrgId: string;
    name: string;
    inventoryId: string;
    serviceId: string;
    qrCodeId: string;
    vdtType: ChainTypeEnum;
    typeId: string;
    bitSysId: string;
    isSelect?: boolean;
}
interface InventoryItemRequest {
    inventoryId: string;
    name?: string;
}
interface DeleteInventoryItemRequest {
    inventoryId: string;
    qrCodeId: string;
    orgId?: string;
}

declare class InventoryService extends BaseService {
    protected inventoryApiUrl: string;
    protected inventoryItemApiUrl: string;
    constructor(opts: BaseServiceOptions);
    getInventoryByOrgId(orgId: string): Promise<Inventory>;
    addInventoryItem(req: AddInventoryItemRequest): Promise<InventoryItem>;
    getInventoryItem(req: PagedRequest<InventoryItemRequest>): Promise<PagedResponse<InventoryItem>>;
    deleteInventoryItem(req: DeleteInventoryItemRequest): Promise<void>;
}

declare enum ListedStatusEnum {
    MINTED = "MINTED",
    LISTING_STARTED = "LISTING_STARTED",
    LISTING_FAILED = "LISTING_FAILED",
    LISTED = "LISTED",
    DELIST_STARTED = "DELIST_STARTED",
    DELIST_FAILED = "DELIST_FAILED",
    DELISTED = "DELISTED",
    ORDER_STARTED = "ORDER_STARTED",
    ORDER_COMPLETED = "ORDER_COMPLETED",
    ORDER_FAILED = "ORDER_FAILED"
}
declare enum BidStatusEnum {
    PENDING = "PENDING",
    REJECTED = "REJECTED",
    ACCEPTED = "ACCEPTED",
    RETRACTED = "RETRACTED"
}
declare enum OrderStatusEnum {
    CREATED = "CREATED",
    PAYMENT_COMPLETED = "PAYMENT_COMPLETED",
    PAYMENT_FAILED = "PAYMENT_FAILED",
    CANCELLED = "CANCELLED",
    ORDER_SHIPPED = "ORDER_SHIPPED",
    ORDER_DELIVERED = "ORDER_DELIVERED",
    OWNERSHIP_TRANSFER_STARTED = "OWNERSHIP_TRANSFER_STARTED",
    OWNERSHIP_TRANSFER_COMPLETED = "OWNERSHIP_TRANSFER_COMPLETED",
    OWNERSHIP_TRANSFER_FAILED = "OWNERSHIP_TRANSFER_FAILED",
    ORDER_UNDELIVERED = "ORDER_UNDELIVERED",
    ORDER_SUCCESS = "ORDER_SUCCESS",
    RETURN = "RETURN",
    RETURN_SHIPPED = "RETURN_SHIPPED",
    RETURN_DELIVERED = "RETURN_DELIVERED",
    RETURN_UNDELIVERED = "RETURN_UNDELIVERED",
    REFUND = "REFUND",
    REFUND_COMPLETED = "REFUND_COMPLETED",
    REFUND_FAILED = "REFUND_FAILED",
    ONGOING = "ON_GOING",
    COMPLETED = "COMPLETED"
}

interface Listing {
    id: string;
    assetId: string;
    createdBy: string;
    price: number;
    sellingMethod: SellingMethodEnum;
    status: ListedStatusEnum;
    startAt: string;
    endAt: string;
    concurrencyStamp: string;
    isFreeShipping: boolean;
    shippingDetail: {
        shipFrom: BaseAddress;
        weight: number;
        length: number;
        width: number;
        height: number;
        handlingFee: number;
        unitOfMeasurement: MeasurementUnitEnum;
        packagingType: string;
    };
    description: string;
}
type ListingExtended = Omit<Listing, 'concurrencyStamp'> & ListingWithAsset['asset'];
interface ListingWithAsset extends Listing {
    asset: Pick<CustomerAsset, 'id' | 'appName' | 'qrCodeRef' | 'eventIdRef' | 'name' | 'level' | 'ownerId' | 'isVerifiedByWitness' | 'isVerifiedByOfficial' | 'orgId' | 'typeId' | 'createdAt'> & {
        platform: WalletPlatformEnum;
        isListed: boolean;
    };
}

interface Bid {
    id: string;
    listingId: string;
    status: BidStatusEnum;
    price: number;
    paymentExpireTime: string;
    rejectReason: string;
    reasonDescription: string;
    createdAt: string;
    createdBy: string;
    listing?: Listing;
    asset?: CustomerAsset;
}
declare enum BidReasonsEnum {
    OTHER = "Other",
    REJECT_REASON = "rejectReason",
    REJECT_DESCRIPTION = "rejectDescription"
}

interface Category {
    id: string;
    appName: string;
    name: string;
    parentId: string;
}

type SearchBidsRequest = PagedRequest<{
    listingId?: string;
    createdBy?: string;
    status?: string;
}>;
interface AddBidRequest {
    listingId: string;
    price: number;
}
interface RejectBidRequest {
    id: string;
    rejectReason: string;
    reasonDescription?: string;
}

declare class BidService extends BaseService {
    bidsApiUrl: string;
    constructor(opts: BaseServiceOptions);
    search(req: SearchBidsRequest): Promise<PagedResponse<Bid>>;
    create(req: AddBidRequest): Promise<Bid>;
    reject(req: RejectBidRequest): Promise<Bid>;
    getById(id: string): Promise<Bid>;
    accept(id: string): Promise<Bid>;
}

type ListCategoriesRequest = FilteredRequest<{
    parentId?: string;
    name?: string;
}>;
type SearchCategoriesRequest = PagedRequest<{
    parentId?: string;
    name?: string;
}>;

declare class CategoriesService extends BaseService {
    catsApiUrl: string;
    constructor(opts: BaseServiceOptions);
    list(req?: ListCategoriesRequest): Promise<Category[]>;
    search(req?: SearchCategoriesRequest): Promise<PagedResponse<Category>>;
    getById(id: string): Promise<Category>;
    listFromAssets(): Promise<Category[]>;
}

type SearchListingsRequest = PagedRequest<{
    name?: string;
    createdBy?: string;
    sellingMethod?: SellingMethodEnum;
    categories?: string[];
    assetId?: string;
    types?: string[];
    zip?: string;
    miles?: number;
    minPrice?: number;
    maxPrice?: number;
    ranges?: number[][];
    shippingDetail?: {
        shipFrom: BaseAddress;
        weight: number;
        length: number;
        width: number;
        height: number;
    };
}>;
type SearchListingsResponse = PagedResponse<ListingExtended>;
interface EditPriceRequest {
    id: string;
    price: number;
    concurrencyStamp: string;
}
type GetListingsReportRequest = FilteredRequest<{
    createdBy?: string;
    from?: string;
    to?: string;
    appNames?: string[];
    fileFormat?: FileFormatEnum;
}>;

declare class ListingService extends BaseService {
    listingApiUrl: string;
    constructor(opts: BaseServiceOptions);
    search(req?: SearchListingsRequest): Promise<SearchListingsResponse>;
    editPrice(req: EditPriceRequest): Promise<Listing>;
    reportDownloadUrl(req: GetListingsReportRequest): Promise<SearchListingsResponse>;
    getById(id: string): Promise<Listing>;
    removeById(id: string): Promise<Listing>;
    getPublic(id: string): Promise<Listing>;
    getByAssetId(assetId: string): Promise<ListingWithAsset>;
    getPublicByAssetId(assetId: string): Promise<ListingWithAsset>;
    removeByAssetId(assetId: string): Promise<void>;
    listingView(listingId: string): Promise<boolean>;
}

declare enum OrderTypeEnum {
    SELL = "SELL",
    BUY = "BUY"
}
type GetOrdersReportRequest = FilteredRequest<{
    buyerId?: string;
    sellerId?: string;
    from?: string;
    to?: string;
    status?: OrderStatusEnum;
    fileFormat?: FileFormatEnum;
}>;
type GetOrdersRequest = PagedRequest<{
    orderType?: OrderTypeEnum;
    userId?: string;
    assetId?: string;
    status?: OrderStatusEnum;
    orderState?: OrderStatusEnum;
}>;
interface CreateOrderRequest {
    listingId: string;
    concurrencyStamp: string;
}
interface CreateOrdersResponse {
    id: string;
    listingId: string;
    assetId: string;
    sellerId: string;
    buyerId: string;
    price: number;
    status: string;
    createdAt: string;
    concurrencyStamp: string;
}
type SearchOrderStoreRequest = PagedRequest<{
    orderId?: string;
    operation?: string;
    createdBy?: string;
}>;
type SearchQuestionRequest = PagedRequest<{
    parentId?: string;
    hint?: string;
}>;
type OrderShippingInfoRequest = Omit<ExtraCharges, 'id'> & {
    id: string;
    concurrencyStamp: string;
    shippingAddress: BuyerShippingAddress;
    billingAddress: BuyerBillingAddress;
    service: string;
    price: number;
    assetPrice: number;
};
interface OrderPaymentRequest {
    listingId: string;
    concurrencyStamp: string;
    shippingAddress: BuyerShippingAddress;
    billingAddress: BuyerBillingAddress;
    serviceCode: number;
    paymentType: PaymentTypeEnum;
    nameOnCard: string;
    cardNumber: string;
    cvv: string;
    expiryDate: string;
    paypalId: string;
}
interface ShippingOrderRequest {
    id: string;
    concurrencyStamp: string;
    status: OrderStatusEnum;
    courier?: string;
    trackingId?: string;
    image?: string;
    rejectReason?: string;
    reasonDescription?: string;
}
interface DeliveredRequest {
    id: string;
    concurrencyStamp: string;
    status: OrderStatusEnum;
    feedback: FeedbackRequest[];
    image: string;
    courier?: string;
    trackingId?: string;
}
interface FeedbackRequest {
    id: string;
    answer: string;
    parentId?: string;
}
interface GetTotalSalesRequest {
    sellerId?: string;
    orgId?: string;
}
interface GetSalesStatsRequest {
    sellerId?: string;
    orgId?: string;
    year: string;
}
interface CancelOrderRequest {
    id: string;
    concurrencyStamp: string;
    reasonId: string;
    comment: string;
}
interface OrderPaymentDetailsRequest {
    listingId: string;
    serviceCode?: string;
    country?: string;
    city?: string;
    state?: string;
    zip?: string;
}
interface OrderPaymentDetailsResponse {
    publicKey: string;
    merchantRefNum: string;
    sellingPrice: number;
    amount: number;
    amountPaysafe: number;
    accountId: string;
    gasFee: number;
    costTax: number;
    shippingCost: number;
    handlingFee: number;
}

declare class OrdersService extends BaseService {
    orderApiUrl: string;
    constructor(opts: BaseServiceOptions);
    reportDownloadUrl(req: GetOrdersReportRequest): Promise<SearchListingsResponse>;
    search(req?: GetOrdersRequest): Promise<PagedResponse<Order>>;
    searchStore(req?: SearchOrderStoreRequest): Promise<PagedResponse<OrderStore>>;
    searchQuestion(req?: SearchQuestionRequest): Promise<PagedResponse<Question>>;
    orderPayment(req: OrderPaymentRequest): Promise<Order>;
    shipping(req: ShippingOrderRequest): Promise<Order>;
    delivered(req: DeliveredRequest): Promise<Order>;
    cancel(req: CancelOrderRequest): Promise<Order>;
    getById(id: string): Promise<Order>;
    totalSales(req: GetTotalSalesRequest): Promise<TotalSales>;
    salesTax(req: SalesTaxRequest): Promise<SalesTax>;
    shippingCost(req: ShippingCostReq): Promise<ShippingCost[]>;
    stats(req: GetSalesStatsRequest): Promise<OrderStatistics[]>;
    getPaymentDetails(req: OrderPaymentDetailsRequest): Promise<OrderPaymentDetailsResponse>;
}

type ListTypesRequest = FilteredRequest<{
    categoryId?: string;
    name?: string;
}>;
type SearchTypesRequest = PagedRequest<{
    categoryId?: string;
    name?: string;
}>;

declare class TypesService extends BaseService {
    typesApiUrl: string;
    constructor(opts: BaseServiceOptions);
    list(req?: ListTypesRequest): Promise<Type[]>;
    search(req?: SearchTypesRequest): Promise<PagedResponse<Type>>;
    getById(id: string): Promise<Type>;
    listFromAssets(): Promise<Type[]>;
}

type SearchWishlistRequest = PagedRequest<{
    assetId?: string;
    userId?: string;
}>;
interface CreateWishlistRequest {
    assetId: string;
}

declare class WishlistService extends BaseService {
    wishlistApiUrl: string;
    constructor(opts: BaseServiceOptions);
    search(req?: SearchWishlistRequest): Promise<PagedResponse<WishlistExtended>>;
    add(req: CreateWishlistRequest): Promise<Wishlist>;
    getByAssetId(assetId: string): Promise<Wishlist>;
    remove(id: string): Promise<Wishlist>;
}

interface Order {
    id: string;
    listingId: string;
    assetId: string;
    sellerId: string;
    buyerId: string;
    price: number;
    status: string;
    createdAt: string;
    concurrencyStamp: string;
    flagged: boolean;
    suspended: boolean;
    attachments: OrderAttachment[][];
    listing: OrderListing;
    asset: OrderAsset;
}
interface OrderAttachment {
    id: string;
    orderId: string;
    classification: string;
    path: string;
    pathUrl?: string | null;
    createdAt: string;
}
interface OrderListing {
    id: string;
    assetId: string;
    createdBy: string;
    price: number;
    sellingMethod: string;
    status: string;
    startAt: string;
    endAt: string;
    concurrencyStamp: string;
}
interface OrderAsset {
    id: string;
    appName: string;
    qrCodeRef?: string | null;
    eventIdRef: string;
    name: string;
    level: string;
    ownerId: string;
    isVerifiedByWitness: boolean;
    isVerifiedByOfficial: boolean;
    platform: string;
    isListed: boolean;
    orgId?: string | null;
    typeId: string;
    createdAt: string;
}
interface OrderStore {
    id: string;
    orderId: string;
    prevActionId: string;
    operation: OrderStatusEnum;
    version: number;
    createdAt: string;
    createdBy: string;
    isEncrypted: true;
    data: OrderStoreData;
}
type OrderStoreData = Omit<DeliveredRequest, 'id' | 'feedback' | 'image'> & Omit<OrderShippingInfoRequest, 'id'> & {
    id: string;
    cvv?: string;
    paypalId?: string;
    createdAt?: string;
    cardNumber?: string;
    expiryDate?: string;
    nameOnCard?: string;
    paymentMethod?: string;
    paymentType?: string;
    transactionId?: string;
    ownershipChangedAt?: string;
    assetId?: string;
    buyerId?: string;
    sellerId?: string;
    listingId?: string;
    updatedAt?: string;
};
interface Question {
    id: string;
    question: string;
    parentId: string;
    hint: string;
    createdAt: string;
}
interface BuyerShippingAddress extends BaseAddress {
    phone?: string;
}
interface BuyerBillingAddress extends BaseAddress {
    phone?: string;
}
interface ExtraCharges {
    id: number;
    gasFee: number;
    costTax: number;
    shippingCost: number;
}
interface OrderFeedback {
    id: string;
    answer: string;
    parentId: string;
}
interface DeliveryOrderRequest {
    id?: string;
    concurrencyStamp?: string;
    status?: OrderStatusEnum;
    feedback?: OrderFeedback[];
    image?: string;
    courier?: string;
    trackingId?: string;
}
interface DeliveryOrderResponse {
    id: string;
    listingId: string;
    assetId: string;
    sellerId: string;
    buyerId: string;
    price: number;
    status: OrderStatusEnum;
    createdAt: string;
    concurrencyStamp: string;
}
interface TotalSales {
    monthlySales: number;
    totalSales: number;
    totalAssetsSold: number;
    totalListings: number;
}
interface OrderStatistics {
    month: string;
    sale: number;
}
interface SalesTaxRequest {
    listingId: string;
    country: string;
    city: string;
    state: string;
    zipCode: string;
}
interface SalesTax {
    listingId: string;
    costTax: number;
}
interface ShippingCostReq extends BaseAddress {
    listingId: string;
    phone?: string;
}
interface ShippingCost {
    service: {
        code: string;
        description: string;
    };
    totalCharges: {
        currencyCode: string;
        monetaryValue: string;
    };
    guaranteedDelivery: {
        businessDaysInTransit: string;
        deliveryByTime: string;
    };
}

interface Type {
    id: string;
    name: string;
    categoryId: string;
}

interface WishlistExtended {
    assetId: string;
    appName: string;
    qrCodeRef?: string | null;
    eventIdRef: string;
    name: string;
    level: string;
    isVerifiedByWitness: boolean;
    isVerifiedByOfficial: boolean;
    platform: WalletPlatformEnum;
    isListed: boolean;
    orgId: string;
    typeId: string;
    createdAt: string;
}
interface Wishlist {
    id: string;
    userId: string;
    assetId: string;
    createdAt: string;
}
interface WishlistItem {
    name: string;
    assetId: string;
    serializedSteps: SerializedStep[];
    serializedCategories: string[];
    serializedImages: SerializedImage[];
    typeName: string;
    level: string;
    orgId: string;
    ownerId: string;
    eventIdRef: string;
    startDate: string;
    endDate: string;
    createdAt: string;
}

interface GetMenuRequest {
    inventoryId: string;
    name?: string;
    isArchived?: string;
    $resolveImages?: boolean;
}
interface Menu {
    id: string;
    inventoryId: string;
    name: string;
    imageUrl: string;
    isPublished: boolean;
    isArchived: boolean;
    createdAt: string;
}
interface MenuRequest {
    inventoryId: string;
    name: string;
    image: string;
    isPublished: boolean;
}
interface MenuUpdateRequest {
    id: string;
    name: string;
    image: string;
    imageUrl: string;
    isPublished: boolean;
}
interface MenuItem {
    id: string;
    userId: string;
    orgId: string;
    name: string;
    imageUrl: string;
    reasonId: string;
    comment: string;
    isArchived: boolean;
    createdAt: string;
}
interface GetMenuItemRequest {
    name?: string;
    isArchived?: boolean;
    ids?: string[];
    inventoryItemId?: string;
    typeId?: string;
}
interface MenuItemRequest {
    name: string;
    image: string;
    reasonId: string;
    comment: string;
}
interface Allergen {
    id: string;
    name: string;
    imageUrl: string;
    isArchived: boolean;
    createdAt: string;
}
interface Dietary {
    id: string;
    name: string;
    imageUrl: string;
    isArchived: boolean;
    createdAt: string;
}
interface UpdateMenuItemRequest {
    id: string;
    name: string;
    image: string;
    imageUrl: string;
    reasonId: string;
    comment: string;
}
interface GetMenuItemMapRequest {
    menuId: string;
    name?: string;
    isArchived?: string;
}
interface MenuItemMap {
    menuId: string;
    menuItemId: string;
    order: number;
    menuItem?: MenuItem;
}
interface MenuItemMapRequest {
    menuItemMap: MenuItemMap[];
}
interface MenuItemAllergen {
    menuItemId: string;
    allergenId: string;
}
interface AllergenDietaryRequest {
    menuItemId: string;
    ids: string[];
}
interface MenuItemDietary {
    menuItemId: string;
    dietaryId: string;
}
interface Ingredient {
    menuItemId: string;
    typeId: string;
    createdAt: string;
}
interface AddIngredientsRequest {
    menuItemId: string;
    typeIds: string[];
}
interface UpdateIngredients {
    typeId: string;
    menuItemId: string;
    inventoryItemId?: string;
}
interface UpdateIngredientsRequest {
    menuItemIngredients: UpdateIngredients[];
}
type GetIngredientsRequest = PagedRequest<{
    menuItemId: string;
}>;
interface DeleteIngredientsRequest {
    typeId: string;
    menuItemId: string;
}
interface MenuExportRequest {
    menuId: string;
    fileName: string;
}

declare class MenuService extends BaseService {
    protected menuApiUrl: string;
    protected menuItemApiUrl: string;
    constructor(opts: BaseServiceOptions);
    getMenu(req: PagedRequest<GetMenuRequest>): Promise<PagedResponse<Menu>>;
    addMenu(req: MenuRequest): Promise<Menu>;
    getMenuById(id: string): Promise<Menu>;
    updateMenu(req: MenuUpdateRequest): Promise<Menu>;
    deleteMenu(id: string): Promise<Menu>;
    getMenuItems(req: PagedRequest<GetMenuItemRequest>): Promise<PagedResponse<MenuItem>>;
    addMenuItems(req: MenuItemRequest): Promise<MenuItem>;
    getAllergen(req: PagedRequest<GetMenuItemRequest>): Promise<PagedResponse<Allergen>>;
    getDietary(req: PagedRequest<GetMenuItemRequest>): Promise<PagedResponse<Dietary>>;
    getMenuItemsById(req: {
        id: string;
    }): Promise<MenuItem>;
    updateMenuItem(req: UpdateMenuItemRequest): Promise<MenuItem>;
    deleteMenuItem(req: {
        id: string;
    }): Promise<MenuItem>;
    getMenuItemMap(req: PagedRequest<GetMenuItemMapRequest>): Promise<PagedResponse<MenuItemMap>>;
    addMenuItemMap(req: MenuItemMapRequest): Promise<MenuItemMap[]>;
    updateMenuItemMap(req: MenuItemMapRequest): Promise<MenuItemMap[]>;
    deleteMenuItemMap(req: {
        menuId: string;
        menuItemId: string;
    }): Promise<void>;
    getMenuItemAllergen(req: PagedRequest<{
        menuItemId: string;
    }>): Promise<PagedResponse<MenuItemAllergen>>;
    addMenuItemAllergen(req: AllergenDietaryRequest): Promise<MenuItemAllergen[]>;
    updateMenuItemAllergen(req: AllergenDietaryRequest): Promise<MenuItemAllergen[]>;
    getMenuItemDietary(req: PagedRequest<{
        menuItemId: string;
    }>): Promise<PagedResponse<MenuItemDietary>>;
    addMenuItemDietary(req: AllergenDietaryRequest): Promise<MenuItemDietary[]>;
    updateMenuItemDietary(req: AllergenDietaryRequest): Promise<MenuItemDietary[]>;
    getMenuItemIngredients(req: GetIngredientsRequest): Promise<PagedResponse<Ingredient>>;
    addMenuItemIngredients(req: AddIngredientsRequest): Promise<Ingredient[]>;
    updateMenuItemIngredients(req: UpdateIngredientsRequest): Promise<Ingredient>;
    deleteMenuItemIngredients(req: DeleteIngredientsRequest): Promise<void>;
    menuExportById(req: MenuExportRequest, onProgress: (progressEvent: AxiosProgressEvent) => void): Promise<void>;
}

declare enum NotificationStatusEnum {
    Read = "READ",
    Unread = "UNREAD"
}
interface Notification {
    id: string;
    userId: string;
    title: string;
    message: string;
    status: NotificationStatusEnum;
    metadata: Record<string, any>;
    createdAt: string;
}
declare enum EndUserNotificationEventNameEnum {
    AcceptFollowRequest = "accept_follow_request",
    BlockEndUser = "block_end_user",
    BlockEndUserByOrg = "block_end_user_by_org",
    ChangeEmail = "change_email",
    CustomerAssetReport = "customer_asset_report",
    Following = "following",
    InviteAdmin = "invite_admin",
    InviteEndUser = "invite_end_user",
    GldInviteEndUser = "gld_invite_end_user",
    GldInviteExistingEndUser = "gld_invite_existing_end_user",
    GldAddedToCustomerFile = "gld_added_to_customer_file",
    GldCustomerIvdtCreated = "gld_customer_ivdt_created",
    GldReceivedCustomerFileRequest = "gld_received_customer_file_request",
    GldCancelledCustomerFileRequest = "gld_cancelled_customer_file_request",
    GldShareCustomerFileRequestHistory = "gld_share_customer_file_request_history",
    RecurringEmailReport = "recurring_email_report",
    ResetPassword = "reset_password",
    SendFollowRequest = "send_follow_request",
    ShareAsset = "share_asset",
    ShareEndUserDeepLink = "share_end_user_deep_link",
    ShareOrganizationDeepLink = "share_organization_deep_link",
    ShareIvdt = "share_ivdt",
    UnblockEndUser = "unblock_end_user",
    UnblockEndUserByOrg = "unblock_end_user_by_org",
    RemoveEndUser = "remove_end_user",
    VdtMinted = "vdt_minted",
    VerifyEmail = "verify_email",
    VerifyPhone = "verify_phone",
    MarketplaceEmail = "marketplace_email",
    ContactUs = "contact_us",
    SuspendOrder = "suspend_order",
    UnsuspendOrder = "unsuspend_order",
    BuyerBuyNow = "buyer_buy_now",
    SellerBuyerPaid = "seller_buyer_paid",
    BuyerOrderAccepted = "buyer_order_accepted",
    BuyerOrderShipped = "buyer_order_shipped",
    BuyerOrderDelivered = "buyer_order_delivered",
    BuyerVDTTransferred = "buyer_vdt_transferred",
    SellerOrderCancelled = "seller_order_cancelled",
    BuyerPaymentRefunded = "buyer_payment_refunded",
    SellerItemDelivered = "seller_item_delivered",
    SellerFundsTransferred = "seller_funds_transferred",
    SellerVDTTransferred = "seller_vdt_transferred",
    BuyerItemReceived = "buyer_item_received",
    SellerOrderAccepted = "seller_order_accepted",
    SellerOrderShipped = "seller_order_shipped",
    BuyerOrderCancelled = "buyer_order_cancelled",
    BuyerReturnDelivered = "buyer_return_delivered",
    SellerReturnDelivered = "seller_return_delivered",
    SellerOrderDelivered = "seller_order_delivered",
    SellerItemListed = "seller_item_listed",
    SellerFirstBid = "seller_first_bid",
    SellerAllBiddersRejected = "seller_all_bidders_rejected",
    SellerAuctionEnd = "seller_auction_end",
    SellerDelistAsset = "seller_delist_asset",
    SellerNewHighestBid = "seller_new_highestBid",
    BuyerNoLongerHighestBid = "buyer_no_longer_highest_bid",
    BuyerBidAccept = "buyer_bid_accept",
    BuyerTopFiveBidders = "buyer_top_five_bidders",
    BuyerAllOtherBidders = "buyer_all_other_bidders",
    BuyerBidRejected = "buyer_bid_rejected"
}
interface EndUserNotificationEvent {
    name: EndUserNotificationEventNameEnum;
    description: string;
    isSms: boolean;
    isPush: boolean;
    isEmail: boolean;
}

type SearchNotificationsRequest = PagedRequest<{
    userId?: string;
    status?: NotificationStatusEnum;
}>;
interface UpdateNotificationStatusRequest {
    status: NotificationStatusEnum;
}
interface RegisterPushNotificationTokenRequest {
    deviceId: string;
    token: string;
}
interface RegisterPushNotificationTokenResponse {
    userId: string;
    deviceId: string;
    token: string;
    createdAt: string;
}
interface SendSinglePushRequest {
    to?: string;
    userId?: string;
    deviceId?: string;
    title: string;
    message: string;
    templateId?: string;
}
interface SendMultiPushRequest {
    to?: string;
    userId?: string;
    title: string;
    message?: string;
    templateId?: string;
}
type SearchEndUserNotificationEventsRequest = PagedRequest<{
    names?: EndUserNotificationEventNameEnum;
}>;
interface UpdateEndUserNotificationEventsRequest {
    isSms: boolean;
    isPush: boolean;
    isEmail: boolean;
}

declare class NotificationService extends BaseService {
    private notifApiUrl;
    searchNotifications(req?: SearchNotificationsRequest): Promise<PagedResponse<Notification>>;
    listNotifications(req?: SearchNotificationsRequest): Promise<Notification[]>;
    searchAdminNotifications(req?: SearchNotificationsRequest): Promise<PagedResponse<Notification>>;
    listAdminNotifications(req?: SearchNotificationsRequest): Promise<Notification[]>;
    getNotificationById(id: string): Promise<Notification>;
    deleteNotifications(ids: string[]): Promise<void>;
    updateNotificationStatus(id: string, status: NotificationStatusEnum): Promise<Notification>;
    registerPushNotificationToken(req: RegisterPushNotificationTokenRequest): Promise<RegisterPushNotificationTokenResponse>;
    testSinglePush(req: SendSinglePushRequest): Promise<void>;
    testMultiPush(req: SendMultiPushRequest): Promise<void>;
    searchEndUserEvents(req?: SearchEndUserNotificationEventsRequest): Promise<PagedResponse<EndUserNotificationEvent>>;
    listEndUserEvents(req?: SearchEndUserNotificationEventsRequest): Promise<EndUserNotificationEvent[]>;
    updateEndUserEvents(name: EndUserNotificationEventNameEnum, req: UpdateEndUserNotificationEventsRequest): Promise<EndUserNotificationEvent>;
    updateAdminNotificationStatus(id: string, status: NotificationStatusEnum): Promise<Notification>;
    clearAdminNotification(): Promise<boolean>;
}

interface Contracts {
    id: string;
    name: string;
    email: string;
    contact: string;
    position: string;
}
interface OrganizationResponse {
    id: string;
    name: string;
    description: string;
    contacts: Contracts[];
    logoUrl: string;
    isActive: boolean;
    isSuper: boolean;
    createdAt: string;
    updatedAt: string;
}
interface OrganizationWallet {
    orgId: string;
    address: string;
    defaultPlatform: WalletPlatformEnum;
    createdAt: string;
}
interface InitVdtRequest {
    appName: string;
    deviceId: string;
    latitude: number;
    longitude: number;
    meanSeaLevel: number;
    recipientAddress: string;
    platform: WalletPlatformEnum;
}
interface OrganizationAddressResponse {
    id: string;
    orgId: string;
    type: AddressTypeEnum;
    name: string;
    address: string;
    city: string;
    state: string;
    zip: string;
    country: string;
    isMain: boolean;
}
type SearchOrganizationAddressRequest = PagedRequest<{
    orgId?: string;
    name?: string;
}>;
interface UpdateOrganizationRequest {
    name: string;
    description: string;
    logo?: string;
}
interface AddContactRequest {
    name: string;
    job: string;
    email: string;
    phone: string;
}
interface AddContactResponse extends AddContactRequest {
    id: string;
}
interface AddOrganizationAddressRequest {
    orgId: string;
    type: AddressTypeEnum;
    name: string;
    address: string;
    city: string;
    state: string;
    zip: string;
    country: string;
    isMain: boolean;
}
interface AddOrganizationAddressResponse extends AddOrganizationAddressRequest {
    id: string;
}
interface ShareOrganizationDeepLinkRequest {
    to: {
        email: string;
        name?: string;
    }[];
}
interface ListOrganizationRequest extends FilterParams {
    name?: string;
    isSuper?: boolean;
    appName?: string;
    isActive?: boolean;
}

interface WitnessVDTResponse {
    platform: string;
    immutableTime: string;
    nftTokenId: string;
    nftMetadataUrl: string;
    nftSmartContractAddress: string;
    immutableTransactionHash: string;
    walletAddress: string;
    witnessId: string;
}
interface MintRequest {
    recipientAddress: string;
    platform: string;
    eventId: string;
}
interface DeviceVdt {
    platform: string;
    immutableTime: string;
    nftTokenId: string;
    nftMetadataUrl: string;
    nftSmartContractAddress: string;
    immutableTransactionHash: string;
    walletAddress: string;
    deviceId: string;
}
interface UserVdt {
    platform: string;
    immutableTime: string;
    nftTokenId: string;
    nftMetadataUrl: string;
    nftSmartContractAddress: string;
    immutableTransactionHash: string;
    walletAddress: string;
    userId: string;
    qrId: string;
}
interface InitUserVdtRequest {
    appName: string;
    deviceId: string;
    latitude: number;
    longitude: number;
    meanSeaLevel: number;
    recipientAddress: string;
    platform: string;
}
interface UserVdtPublic {
    platform: string;
    immutableTime: string;
    nftTokenId: string;
    nftMetadataUrl: string;
    nftSmartContractAddress: string;
    immutableTransactionHash: string;
    walletAddress: string;
    userId: string;
    ipfsMetadata: IpfsMetadata;
}
interface OrganizationVdt {
    platform: string;
    immutableTime: string;
    nftTokenId: string;
    nftMetadataUrl: string;
    nftSmartContractAddress: string;
    immutableTransactionHash: string;
    walletAddress: string;
    orgId: string;
    qrId: string;
}
interface GasEstimation {
    network: string;
    gasFee: string;
    gasFeeInUsd: number;
}
interface PublishCustomerFileRequest {
    id: string;
    comment?: string;
}
type OrganizationVdtPublic = UserVdtPublic & {
    orgId: string;
};

declare class Web3Service extends BaseService {
    web3ApiUrl: string;
    constructor(opts: BaseServiceOptions);
    mint(chainType: ChainTypeEnum, req: MintRequest): Promise<void>;
    getWitnessVdt(witnessId: string): Promise<WitnessVDTResponse>;
    getDeviceVdt(deviceId: string): Promise<DeviceVdt>;
    getUserVdt(userId: string): Promise<UserVdt>;
    getUserVdtPublic(qrId: string): Promise<UserVdtPublic>;
    initUserVdt(req: InitUserVdtRequest): Promise<void>;
    initUserListVdt(): Promise<void>;
    initUserVdtV2(req: InitUserVdtRequest): Promise<void>;
    getOrganizationVdtPublic(qrId: string): Promise<OrganizationVdtPublic>;
    getGasEstimation(assetId: string): Promise<GasEstimation>;
    publishCustomerFile(id: string, comment?: string): Promise<void>;
}

declare class OrganizationService extends BaseService {
    getOrganizations(): Promise<any>;
    getOrganizationList(params: ListOrganizationRequest): Promise<OrganizationResponse[]>;
    getOrganization(orgId: string): Promise<OrganizationResponse>;
    searchOrganizationAddresses(req: SearchOrganizationAddressRequest): Promise<PagedResponse<OrganizationAddressResponse>>;
    getOrganizationMainAddress(orgId: string): Promise<OrganizationAddressResponse>;
    getWallet(orgId: string): Promise<OrganizationWallet>;
    initVdt(orgId: string, payload: InitVdtRequest): Promise<void>;
    canSetupOrg(orgId: string): Promise<boolean>;
    getOrganizationVdt(orgId: string): Promise<OrganizationVdt>;
    update(orgId: string, payload: UpdateOrganizationRequest): Promise<void>;
    addContact(orgId: string, payload: AddContactRequest): Promise<AddContactResponse>;
    addAddress(payload: AddOrganizationAddressRequest): Promise<AddOrganizationAddressResponse>;
    shareDeepLink(orgId: string, req: ShareOrganizationDeepLinkRequest): Promise<void>;
}

interface LocationAddress {
    addressLine1: string;
    addressLine2?: string;
    city: string;
    state: string;
    country: string;
    zip: string;
}
interface LocationAddressResponse {
    addressLine1: string;
    addressLine2?: string;
    city: string;
    state: string;
    country: string;
    zip: string;
}
interface Location {
    id: string;
    orgId: string;
    name: string;
    address?: LocationAddress;
    latitude: number;
    longitude: number;
    meanSeaLevel: number;
    createdAt: Date;
    updatedAt?: Date;
    deletedAt?: Date;
}
interface LocationResponse {
    id: string;
    orgId: string;
    name: string;
    address?: LocationAddressResponse;
    latitude: number;
    longitude: number;
    meanSeaLevel: number;
    createdAt?: Date;
    updatedAt?: Date;
}
interface ListLocationsRequest extends FilterParams {
    name?: string;
    orgId?: string;
    appName?: string;
}
interface AddLocationRequest {
    name: string;
    address: LocationAddress;
    latitude: number;
    longitude: number;
    meanSeaLevel: number;
}

declare class OrganizationLocationService extends BaseService {
    getLocationList(params: ListLocationsRequest): Promise<LocationResponse[]>;
    addLocation(orgId: string, req: AddLocationRequest): Promise<LocationResponse>;
    getLocation(params: {
        id: string;
        appName?: string;
    }): Promise<Location>;
}

declare enum ReportHistoryStatusEnum {
    REQUESTED = "REQUESTED",
    IN_PROGRESS = "IN_PROGRESS",
    COMPLETED = "COMPLETED",
    FAILED = "FAILED"
}
declare enum ReportHistoryTypeEnum {
    SELLER_LISTING = "SELLER_LISTING",
    SELLER_ORDERS = "SELLER_ORDERS",
    BUYER_ORDERS = "BUYER_ORDERS"
}

interface ReportHistory {
    id: string;
    reportType: ReportTypeEnum;
    reportFilters?: Record<string, unknown>;
    status: ReportHistoryStatusEnum;
    fileFormat: FileFormatEnum;
    filePath: string;
    createdAt: string;
    createdBy: string;
}

type SearchReportHistoriesRequest = PagedRequest<{
    createdBy?: string;
    reportType?: ReportHistoryTypeEnum;
    status?: ReportHistoryStatusEnum;
    fileFormat?: FileTypeEnum;
}>;

declare class ReportsService extends BaseService {
    reportsApiUrl: string;
    constructor(opts: BaseServiceOptions);
    searchHistories(req: SearchReportHistoriesRequest): Promise<PagedResponse<ReportHistory>>;
}

export { APP_ID, ASSET_STATUSES, ASSET_STEPS, type ActionReason, ActionType, type AddAddressRequest, type AddBidRequest, type AddContactRequest, type AddContactResponse, type AddCreatorProfileRequest, type AddDocumentRequest, type AddFeedbackRequest, type AddIngredientsRequest, type AddInventoryItemRequest, type AddLocationRequest, type AddOrganizationAddressRequest, type AddOrganizationAddressResponse, type AddPaymentDetailRequest, type AddProfileRequest, type AddReferenceVdtRequest, type AddReferenceVdtResponse, type AddSellerProfileRequest, type AddShippingAddressRequest, AddressService, AddressTypeEnum, type Allergen, type AllergenDietaryRequest, type ApiResponse, type ApiServiceError, type Application, type ApplicationData, type AssetCategory, AssetLevelEnum, type AssetReferenceVDTResponse, AssetService, type AssetStatus, AssetStatusEnum, type AssetTemplate, type AssetType, type AssetTypePropDataModel, type AssetTypePropertyData, type AssetTypeStep, type AssetWitness, AttachmentClassification, type AttachmentData, type AttachmentDocType, AttachmentType, type AuthClaims, BEING_ID_LEVELS, type BaseAddress, type BaseError, type BaseRefVdt, BaseService, type BaseServiceOptions, type BaseType, type BaseTypePropertyData, type BeingId, type BeingIdHistory$1 as BeingIdHistory, BeingLevelEnum, type Bid, BidReasonsEnum, BidService, BidStatusEnum, BiometricsModeEnum, BiometricsService, type BiometricsServiceOptions, BiometricsStorageKeyEnum, type BitAuthClaims, type BitDocument, type BitDocumentAttachmentData, type BuyerBillingAddress, type BuyerProfile, BuyerProfileService, type BuyerShippingAddress, type CancelOrderRequest, type CategoriesRequest, CategoriesService, type Category, CategoryStatusEnum, type ChainAssetEvent, type ChainAssetEventData, type ChainAssetEventMetadata, ChainAssetService, type ChainBaseEvent, type ChainBaseEventData, type ChainBaseEventMetadata, type ChainItDocumentType, type ChainServiceEvent, type ChainServiceEventData, type ChainServiceEventMetadata, ChainServiceService, ChainTypeEnum, ChainUtils, type ChangeEmailRequest, type ChangePhoneRequest, type CheckInEvent, type CheckInEventInput, type CheckInProperty, CheckInService, type CollectionReport, CommonAdminService, type CompleteFycOnboardingRequest, type CompleteOnboardingPayload, type ConsentActionRequest, type ConsentActionResponse, ConsentActionTypesEnum, CoreEventTypeEnum, type CreateAddressesRes, type CreateAttachmentInputData, type CreateAttachmentRequest, type CreateAttachmentsPayload, type CreateBuyerProfilePayload, type CreateChainAssetRequest, type CreateChainBaseRequest, type CreateChainServiceRequest, type CreateCheckInEventRequest, type CreateDocumentPayload, type CreateDocumentRes, type CreateListingRequest, type CreateListingResponse, type CreateOrderRequest, type CreateOrdersResponse, type CreatePaymentPayload, type CreatePaymentRes, type CreateProfileRes, type CreateQrAttachmentInputData, type CreateQrAttachmentRequest, type CreateSellerDocumentPayload, type CreateSellerDocumentRes, type CreateSellerProfilePayload, type CreateSellerProfileRes, type CreateShippingAddressesRes, type CreateWishlistRequest, type CreatorProfile, type CreatorProfilePayload, CreatorProfileService, type CustomerAsset, type CustomerAssetWitness, DEFAULT_APP_ID, DEFAULT_ORG_ID, DEVICE_LEVELS, type DeleteIngredientsRequest, type DeleteInventoryItemRequest, type DeleteShippingAddressPayload, type DeliveredRequest, type DeliveryOrderRequest, type DeliveryOrderResponse, type Device, type DeviceData, type DeviceInformation, type DeviceOwner, type DeviceRefVdt, DeviceService, DeviceTypeEnum, DeviceTypeIdEnum, type DeviceVdt, type Dietary, DocumentStatusEnum, type DocumentTypePhotoRequirement, DocumentTypesService, DocumentsService, type DocumentsServiceOptions, EAddressType, EAttachmentUploadStatus, EBeingLevel, EEventStatus, EFycCheckStatus, EGovIdType, ENCRYPTED_STORAGE_KEYS, EOrderStatus, type EditAddressRequest, type EditCreatorProfileRequest, type EditDocumentRequest, type EditPaymentDetailRequest, type EditPriceRequest, type EditProfileRequest, type EditSellerProfileRequest, type EditShippingAddressRequest, type EditUserRequest, type EndUser, type EndUserAddress, type EndUserNotificationEvent, EndUserNotificationEventNameEnum, type EndUserOrganizationResponse, type Event, type EventData, type EventGroupItem, type EventRelationType, EventService, type ExportListUsersRequest, type ExtraCharges, type FavoriteAsset, type Feedback, FeedbackEnum, type FeedbackRequest, FeedbackService, FileFormatEnum, FileTypeEnum, type FilterParams, type FilteredRequest, type FindMainPhotoByTypeClassOpts, type FycDocument, type FycDocumentsRequest, type GasEstimation, type GenerateQrRequest, type GeolocationData, type GetActiveAssetTemplateRequest, type GetAssetGroupsRes, type GetAssetGroupsResponse, type GetAssetWitnessesRequest, type GetAssetsRequest, type GetAssetsRes, type GetAttachmentLinkOpts, type GetBuyerProfileRes, type GetCheckInEventsRequest, type GetCreatorProfileRes, type GetCreatorProfilesListRes, type GetDeviceByExternalIdPayload, type GetDeviceByIdPayload, type GetDeviceVdtResponse, type GetDocumentsRes, type GetDocumentsTypesRes, type GetEndUserAddressesPayload, type GetIngredientsRequest, type GetListingsReportRequest, type GetMenuItemMapRequest, type GetMenuItemRequest, type GetMenuRequest, type GetOrdersReportRequest, type GetOrdersRequest, type GetOrganizationProfileByIdRes, type GetOrganizationProfileRes, type GetOrganizationsRes, type GetProfilePayload, type GetPublicAssetsRequest, type GetPublicWitnessesRequest, type GetSalesStatsRequest, type GetSellerProfileRes, type GetTotalSalesRequest, type GetUserBeingIdRes, type GetUserRolesRes, type GetUserRolesResponse, type GetWitnessAssetsRequest, HARDWARE_LEVELS, type IChainService, type IIdentityOrganization, type IIdentityOrganizationPermission, type IIncodeService, type IStorage, type IncodeExtendedOcrDataCommon, type IncodeExtendedOcrDataDriversLicense, type IncodeExtendedOcrDataPassport, type IncodeInitializeOptions, type IncodeOcrResult, InfoTypeEnum, type Ingredient, type InitDeviceVdtRequest, type InitUserVdtRequest, type InitVdtRequest, type Inventory, type InventoryItem, type InventoryItemRequest, InventoryService, type InvitationTicketClaims, type Invite, InviteTypeEnum, type IpfsMetadata, type IvdtRequestShareableRequest, type IvdtRequestShareableResponse, type IvdtShareableRequest, type IvdtShareableResponse, type LevelDetail, type LinkQrRequest, type ListAddressesRequest, type ListApplicationsRequest, type ListCategoriesRequest, type ListDocumentTypesRequest, type ListDocumentsRequest, type ListFinalWithTypes, type ListInvitesRequest, type ListLocationsRequest, type ListOrganizationRequest, type ListPaymentDetailsRequest, type ListProfilesRequest, type ListShippingAddressesRequest, type ListTypesRequest, type ListUserDocumentsRequest, type ListUsersRequest, ListedStatusEnum, type Listing, type ListingExtended, ListingService, type ListingWithAsset, type Location, LocationAccuracy, type LocationAddress, type LocationAddressResponse, type LocationResponse, type LogLevels, type LoggerType, type MakeCreateCheckInEventRequestOpts, type MakeUpdateCheckInAttachmentRequestOpts, type ManageUserRolesRequest, MeasurementUnitEnum, type Menu, type MenuExportRequest, type MenuItem, type MenuItemAllergen, type MenuItemDietary, type MenuItemMap, type MenuItemMapRequest, type MenuItemRequest, type MenuRequest, MenuService, type MenuUpdateRequest, type MintRequest, type MintStatus, type Notification, NotificationService, NotificationStatusEnum, type OldAttachmentData, type Order, type OrderDataDataResponse, type OrderFeedback, type OrderPaymentDetailsRequest, type OrderPaymentDetailsResponse, type OrderPaymentRequest, type OrderShippingInfoRequest, type OrderStatistics, OrderStatusEnum, type OrderStore, type OrderStoreData, OrderTypeEnum, OrdersService, type OrganizationAddressResponse, type OrganizationInviteResponse, OrganizationLocationService, type OrganizationResponse, OrganizationService, type OrganizationVdt, type OrganizationVdtPublic, type OrganizationWallet, type OwnershipHistoryResponse, type PagedRequest, type PagedResponse, type PaginatedResponse, type PaginationParams, type PaginationPayload, type PaymentDataProps, PaymentDetailsService, type PaymentDetailsServiceOptions, type PaymentInfo, PaymentTypeEnum, type PaymentTypeInfoData, type Profile, type ProfileAddShippingAddressRequest, ProfileService, type ProfileServiceOptions, ProfileTypeEnum, type PublicToken, type PublishCustomerFileRequest, type QrPackageCodeResponse, QrPackageTypeEnum, type Question, type ReasonsRequest, type RecalculateBeingIdRequest, type RecalculateUserBeingIdPayload, ReferenceType, type RegisterAdminDeviceRequest, type RegisterDeviceInput, type RegisterDevicePayload, type RegisterDeviceRequest, type RegisterPushNotificationTokenRequest, type RegisterPushNotificationTokenResponse, type RejectBidRequest, RelationTypeEnum, RelationsTypeEnum, type ReportHistory, ReportHistoryStatusEnum, ReportHistoryTypeEnum, ReportTypeEnum, ReportsService, type Role, RoleService, type RootEventData, S2CAssetService, type S2CCustomerAsset, SKIPPABLE_ASSET_STEPS, type SalesTax, type SalesTaxRequest, type SearchAddressesRequest, type SearchAssetTypesRequest, type SearchBidsRequest, type SearchCategoriesRequest, type SearchDevicesRequest, type SearchDocumentTypesRequest, type SearchEndUserNotificationEventsRequest, type SearchListingsRequest, type SearchListingsResponse, type SearchNotificationsRequest, type SearchOrderStoreRequest, type SearchOrganizationAddressRequest, type SearchOrgsRequest, type SearchOrgsResponse, type SearchQuestionRequest, type SearchReportHistoriesRequest, type SearchRolesRequest, type SearchTypesRequest, type SearchUserDocumentsRequest, type SearchUsersRequest, type SearchWishlistRequest, type SellerProfile, SellerProfileService, SellerTypeEnum, SellingMethodEnum, type SendMultiPushRequest, type SendSinglePushRequest, type SendVerificationCodeRequest, type SerializableValue, type SerializedImage, type SerializedProp, type SerializedStep, type ServiceTypePropertyData, type SetBeingIdRequest, type SetUserBeingIdPayload, type ShareAssetReq, type ShareAssetRequest, type ShareOrganizationDeepLinkRequest, type ShareUserDeepLinkRequest, type ShareableInfo, type ShippingAddress, ShippingAddressService, type ShippingAddressServiceOptions, type ShippingCost, type ShippingCostReq, type ShippingDetails, type ShippingOrderRequest, type SignInOptions, type SocialMediaSite, type SocialMediaSiteData, SocialMediaSiteTypeEnum, StepEnum, type SubjectData, type SubjectDataReferenceItem, SubjectTypeEnum, type TemplateRes, type TotalSales, TraitTypeEnum, type Type, TypesService, type UpdateAddressPayload, type UpdateAttachmentInputData, type UpdateAttachmentRequest, type UpdateAttachmentResponse, type UpdateAvatarInput, type UpdateChainAssetDetailsRequest, type UpdateChainBaseDetailsRequest, type UpdateChainServiceDetailsRequest, type UpdateCheckInAttachmentRequest, type UpdateEndUserNotificationEventsRequest, type UpdateFaceTemplateInput, type UpdateFavoriteRequest, type UpdateIngredients, type UpdateIngredientsRequest, type UpdateLocationPrivacyRequest, type UpdateMenuItemRequest, type UpdateMetadataRequest, type UpdateNotificationStatusRequest, type UpdateOrganizationRequest, type UploadedAttachmentData, type User, type UserAddress, type UserOrganization, type UserRefVdt, type UserRole, UserRoleEnum, UserRoleIdEnum, UserService, UserTypeEnum, type UserVdt, type UserVdtByQrIdResponse, type UserVdtPublic, type UserVdtResponse, type ValidateDevicePayload, type ValidateDeviceRequest, type ValidateDeviceResponse, type VdtAttribute, VerificationTypeEnum, type VerifyCodeRequest, type VerifyCodeResponse, VerifyCredentialTypeEnum, type VerifyCredentialsInput, type VerifyCredentialsPayload, type VerifyCredentialsRequest, type VerifyCredentialsRes, type VerifyCredentialsResponse, type VerifyCredentialsWitnessRequest, type VerifyCredentialsWitnessResponse, type VerifyEmailRequest, type VerifyPhoneRequest, VerifyType, VerifyTypeEnum, type ViewAttachmentResponse, WalletPlatformEnum, type WeatherData, Web3Service, type WhenDetails, type Wishlist, type WishlistExtended, type WishlistItem, WishlistService, type WithAddress, type WithDocumentsService, type WithPaymentDetails, type WithShippingAddress, type WitnessAsset, type WitnessCustomerAssetResponse, WitnessTypeEnum, type WitnessVDTResponse, assetStatuses, chainServiceStatuses, createAndUploadAttachments, createQueryParams, debounce, formatDate, formatNumber, getAssetStatusIndex, getAssetVerifyRejected, getAssetVerifyStatus, getAssetVerifyStatusBySteps, getAttachmentLink, getAuth0Id, getAuthEmail, getErrorMessage, isAssetStatusAfter, isAssetStatusBefore, isAssetStatusFinished, isTokenExpired, makeCreateAttachmentsRequest, makeCreateCheckInEventRequest, makeCreateQrAttachmentRequest, makeGetAssetsParams, makeSampleGeolocation, makeSampleWeatherData, makeUpdateCheckInAttachmentRequest };