@pix.js/dict/dist/index.d.ts

Dict API sdk

import { PixKeyType } from '@pix.js/core';

type AccountType = 'CACC' | 'TRAN' | 'SLRY' | 'SVGS';

type PixDictApiOptions = {
    /**
     * Dict api url
     */
    url: string;
    /**
     * If true, the validator will throw an error if the qrcode is invalid
     * Defaults to false
     */
    signature: {
        /**
         * Certificate private key
         */
        privateKey: string;
    };
};
type DictResponse = {
    /**
     * Error
     */
    error?: DictError;
    /**
     * Signature
     */
    signature: Record<string, unknown>;
    /**
     * Response time
     */
    responseTime: Date;
    /**
     * Correlation id
     */
    correlationId: string;
};
type DictError = {
    type: string;
    title: string;
    status: number;
    detail: string;
    violations: Violation[];
};
type Violation = {
    reason: string;
    value: string;
    property: string;
};

type OwnerNaturalPerson = {
    type: 'NATURAL_PERSON';
    /**
     * CPF number of the claimer
     */
    taxIdNumber: string;
    /**
     * Name of the claimer
     */
    name: string;
};
type OwnerLegalPerson = {
    type: 'LEGAL_PERSON';
    /**
     * CNPJ number of the claimer
     */
    taxIdNumber: string;
    /**
     * Name of the claimer
     */
    name: string;
    /**
     * Trade name of the claimer (aka. nome fantasia)
     */
    tradeName?: string;
};
type Owner = OwnerNaturalPerson | OwnerLegalPerson;
type DirectoryReason = 'USER_REQUESTED' | 'ACCOUNT_CLOSURE' | 'BRANCH_TRANSFER' | 'RECONCILIATION' | 'FRAUD' | 'RFB_VALIDATION';
type DirectoryEntry = {
    key: string;
    keyType: PixKeyType;
    account: {
        /**
         * ISBP of the bank
         */
        participant: string;
        /**
         * Branch of the bank account
         */
        branch?: string;
        /**
         * Account number
         */
        accountNumber: string;
        /**
         * Type of the bank account, can be "CACC" "TRAN" "SLRY" "SVGS"
         */
        accountType: AccountType;
        /**
         * Opening date of the bank account
         */
        openingDate: Date;
    };
    owner: Owner;
};
type CreateDirectoryRequest = {
    /**
     * Directory reason
     */
    reason: DirectoryReason;
    /**
     * Idempotency key
     */
    requestId: string;
    /**
     * Directory entry
     */
    entry: DirectoryEntry;
};
type UpdateDirectoryRequest = {
    /**
     * Key
     */
    key: string;
    /**
     * Reason to update the directory
     */
    reason: DirectoryReason;
    /**
     * Account data
     */
    account: {
        participant: string;
        branch: string;
        accountNumber: string;
        accountType: AccountType;
        openingDate: Date;
    };
    /**
     * Owner of the account
     */
    owner: Owner;
};
type DeleteEntryRequest = {
    /**
     * Key
     */
    key: string;
    /**
     * Participant
     */
    participant: string;
    /**
     * Reason to delete the entry
     * Enum: "USER_REQUESTED" "ACCOUNT_CLOSURE" "BRANCH_TRANSFER" "RECONCILIATION" "FRAUD" "RFB_VALIDATION"
     */
    reason: DirectoryReason;
};
type GetDirectoryParameters = {
    /**
     * Include antifraud statistics
     */
    includeStatistics?: boolean;
    /**
     * ISBP of the bank or 8 first digits of the CNPJ for payment initiators
     */
    piRequestingParticipant: string;
    /**
     * Payer id used for rate limiting
     */
    piPayerId: string;
    /**
     * End to end id used for rate limiting
     */
    piEndToEndId: string;
};
type Directory = {
    key: string;
    keyType: string;
    account: {
        participant: string;
        branch: string;
        accountNumber: string;
        accountType: string;
        openingDate: string;
    };
    owner: Owner;
    creationDate: Date;
    keyOwnershipDate: Date;
    openClaimCreationDate?: Date;
};
type DeleteEntryResponse = DictResponse & {
    key: string;
};
type CheckKeyResponse = DictResponse & {
    keys: {
        key: {
            hasEntry: boolean;
            value: string;
        }[];
    };
};
type GetDirectoryResponse = DictResponse & {
    entry: Directory;
};
type CreateDirectoryResponse = DictResponse & {
    entry: Directory;
};
type UpdateDirectoryResponse = DictResponse & {
    entry: Directory;
};
type GetDirectoryByCidParameters = {
    /**
     * Content identifier
     */
    cid: string;
    /**
     * Participant requesting the directory
     */
    piRequestingParticipant: string;
};
type GetDirectoryByCidResponse = DictResponse & {
    cid: string;
    entry: Directory;
};

type ClaimType = 'OWNERSHIP' | 'PORTABILITY';
type ClaimStatus = 'OPEN' | 'WAITING_RESOLUTION' | 'CONFIRMED' | 'CANCELLED' | 'COMPLETED';
type ConfirmReason = 'USER_REQUESTED' | 'ACCOUNT_CLOSURE' | 'FRAUD' | 'DEFAULT_OPERATION' | 'RECONCILIATION';
type CancelReason = 'USER_REQUESTED' | 'ACCOUNT_CLOSURE' | 'FRAUD' | 'DEFAULT_OPERATION' | 'RECONCILIATION';
type CancelledBy = 'DONOR' | 'CLAIMER';
type ClaimerNaturalPerson = {
    type: 'NATURAL_PERSON';
    /**
     * CPF number of the claimer
     */
    taxIdNumber: string;
    /**
     * Name of the claimer
     */
    name: string;
};
type ClaimerLegalPerson = {
    type: 'LEGAL_PERSON';
    /**
     * CNPJ number of the claimer
     */
    taxIdNumber: string;
    /**
     * Name of the claimer
     */
    name: string;
    /**
     * Trade name of the claimer (aka. nome fantasia)
     */
    tradeName?: string;
};
type Claimer = ClaimerNaturalPerson | ClaimerLegalPerson;
type ClaimerAccount = {
    participant: string;
    branch?: string;
    accountNumber: string;
    accountType: AccountType;
    openingDate: Date;
};
type CreatePortabilityRequest = {
    claim: {
        /**
         * Claim type can be "OWNERSHIP" or "PORTABILITY"
         */
        type: ClaimType;
        /**
         * Key of the account to be claimed
         */
        key: string;
        /**
         * Key type
         */
        keyType: PixKeyType;
        /**
         * Bank account of the claimer
         */
        claimerAccount: ClaimerAccount;
        /**
         * Data of the claimer
         */
        claimer: Claimer;
    };
};
type CreatePortabilityResponse = DictResponse & {
    claim: {
        type: ClaimType;
        key: string;
        keyType: PixKeyType;
        claimerAccount: ClaimerAccount;
        claimer: Claimer;
        donorParticipant: string;
        id: string;
        status: ClaimStatus;
        completionPeriodEnd?: Date;
        resolutionPeriodEnd: Date;
        lastModified: Date;
    };
};
type ListPortabilityParameters = {
    /**
     * ISPB of the direct or indirect participant of interest
     */
    participant: string;
    /**
     * Includes additional claims of indirect participants
     * Default: false
     */
    includeIndirectParticipants?: boolean;
    /**
     * Restricts claims in which the participant is a donor
     * Default: false
     */
    isDonor?: boolean;
    /**
     * Restricts claims in which the participant is a claimant
     * Default: false
     */
    isClaimer?: boolean;
    /**
     * Array of ClaimStatus to be searched
     * Items Enum: "OPEN" "WAITING_RESOLUTION" "CONFIRMED" "CANCELLED" "COMPLETED"
     */
    status?: ClaimStatus[];
    /**
     * Type of the claim
     * Items Enum: "OWNERSHIP" "PORTABILITY"
     */
    type?: ClaimType;
    /**
     * Filter claims modified after this date
     */
    modifiedAfter?: Date;
    /**
     * Filter claims modified before this date
     */
    modifiedBefore?: Date;
    /**
     * Limit the number of claims to be returned
     * Default: 20
     */
    limit?: number;
};
type ListPortabilityResponse = DictResponse & {
    claims: {
        claim: {
            type: ClaimType;
            key: string;
            keyType: PixKeyType;
            claimerAccount: ClaimerAccount;
            claimer: Claimer;
            donorParticipant: string;
            id: string;
            status: ClaimStatus;
            resolutionPeriodEnd: Date;
            completionPeriodEnd?: Date;
            lastModified: Date;
            confirmReason?: ConfirmReason;
            cancelReason?: CancelReason;
            cancelledBy?: CancelledBy;
        }[];
    };
    hasMoreElements: boolean;
};
type GetPortabilityParameters = {
    /**
     * ISPB of the direct or indirect participant of interest
     */
    participant: string;
    /**
     * Id of the claim
     */
    id: string;
};
type GetPortabilityResponse = DictResponse & {
    claim: {
        type: ClaimType;
        key: string;
        keyType: PixKeyType;
        claimerAccount: ClaimerAccount;
        claimer: Claimer;
        donorParticipant: string;
        id: string;
        status: ClaimStatus;
        completionPeriodEnd: Date;
        resolutionPeriodEnd: Date;
        lastModified: Date;
    };
};
type AcknowledgePortabilityParameters = {
    /**
     * Id of the claim
     */
    claimId: string;
    /**
     * ISPB of the direct or indirect participant of interest
     */
    participant: string;
};
type AcknowledgePortabilityResponse = DictResponse & {
    claim: {
        type: ClaimType;
        key: string;
        keyType: PixKeyType;
        claimerAccount: ClaimerAccount;
        claimer: Claimer;
        donorParticipant: string;
        id: string;
        status: ClaimStatus;
        resolutionPeriodEnd: Date;
        completionPeriodEnd?: Date;
        lastModified: Date;
    };
};
type ConfirmPortabilityParameters = {
    /**
     * Id of the claim
     */
    claimId: string;
    /**
     * ISPB of the direct or indirect participant of interest
     */
    participant: string;
    /**
     * Confirmation reason
     */
    reason: ConfirmReason;
};
type ConfirmPortabilityResponse = DictResponse & {
    claim: {
        type: ClaimType;
        key: string;
        keyType: PixKeyType;
        claimerAccount: ClaimerAccount;
        claimer: Claimer;
        donorParticipant: string;
        id: string;
        status: ClaimStatus;
        resolutionPeriodEnd: Date;
        completionPeriodEnd?: Date;
        lastModified: Date;
        confirmReason?: ConfirmReason;
    };
};
type CancelPortabilityParameters = {
    /**
     * Id of the claim
     */
    claimId: string;
    /**
     * ISPB of the direct or indirect participant of interest
     */
    participant: string;
    /**
     * Confirmation reason
     */
    reason: CancelReason;
};
type CancelPortabilityResponse = DictResponse & {
    claim: {
        type: ClaimType;
        key: string;
        keyType: PixKeyType;
        claimerAccount: ClaimerAccount;
        claimer: Claimer;
        donorParticipant: string;
        id: string;
        status: ClaimStatus;
        resolutionPeriodEnd: Date;
        completionPeriodEnd?: Date;
        lastModified: Date;
        cancelReason?: CancelReason;
        cancelledBy?: CancelledBy;
    };
};
type CompletePortabilityParameters = {
    /**
     * Id of the claim
     */
    claimId: string;
    /**
     * ISPB of the direct or indirect participant of interest
     */
    participant: string;
    /**
     * Idempotency key
     */
    requestId: string;
};
type CompletePortabilityResponse = DictResponse & {
    claim: {
        type: ClaimType;
        key: string;
        keyType: PixKeyType;
        claimerAccount: ClaimerAccount;
        claimer: Claimer;
        donorParticipant: string;
        id: string;
        status: ClaimStatus;
        completionPeriodEnd: Date;
        resolutionPeriodEnd: Date;
        lastModified: Date;
        confirmReason?: ConfirmReason;
    };
    entryCreationDate: Date;
    keyOwnershipDate: Date;
};

interface VerifySyncParameters {
    /**
     * The participant ID to verify the sync for.
     */
    participantId: string;
    /**
     * The key type to verify the sync for.
     */
    keyType: PixKeyType;
    /**
     * The participant sync verifier. Calculated by the participant.
     */
    participantSyncVerifier: string;
}
type VerifySyncResponse = DictResponse & {
    syncVerification: {
        participant: string;
        keyType: PixKeyType;
        participantSyncVerifier: string;
        id: string;
        result: 'OK' | 'NOK';
    };
};
interface CreateCidsFileParameters {
    /**
     * The participant ID to create the CIDs file for.
     */
    participantId: string;
    /**
     * The key type to create the CIDs file for.
     */
    keyType: PixKeyType;
}
type CidSetFile = {
    /**
     * The ID of the CIDs file.
     */
    id: string;
    /**
     * The status of the CIDs file.
     */
    status: 'REQUESTED' | 'PROCESSING' | 'AVAILABLE' | 'UNAVAILABLE' | 'ERROR';
    /**
     * The participant ID of the CIDs file.
     */
    participant: string;
    /**
     * The key type of the CIDs file.
     */
    keyType: PixKeyType;
    /**
     * The request time of the CIDs file.
     */
    requestTime: Date;
    /**
     * The creation time of the CIDs file. only available if the status is AVAILABLE.
     */
    creationTime?: Date;
    /**
     * The URL of the CIDs file. only available if the status is AVAILABLE.
     */
    url?: string;
    /**
     * The size of the CIDs file in bytes. only available if the status is AVAILABLE.
     */
    bytes?: number;
    /**
     * The SHA-256 hash of the CIDs file. only available if the status is AVAILABLE.
     */
    sha256?: string;
};
type CreateCidsFileResponse = DictResponse & {
    cidSetFile: CidSetFile;
};
interface GetCidsFileParameters {
    /**
     * The ID of the CIDs file to get.
     */
    id: string;
    /**
     * The participant ID to get the CIDs file for.
     */
    piRequestingParticipant: string;
}
type GetCidsFileResponse = DictResponse & {
    cidSetFile: CidSetFile;
};
interface ListCidsEventsParameters {
    /**
     * The participant ID to list the CIDs events for.
     */
    participant: string;
    /**
     * The key type to list the CIDs events for.
     */
    keyType: PixKeyType;
    /**
     * The start time to list the CIDs events for.
     */
    startTime: Date;
    /**
     * The end time to list the CIDs events for.
     */
    endTime: Date;
    /**
     * The limit of the CIDs events to list.
     */
    limit: number;
}
type CidSetEvent = {
    type: 'ADDED' | 'REMOVED';
    cid: string;
    timestamp: Date;
};
type ListCidsEventsResponse = DictResponse & {
    cidSetEvents: {
        cidSetEvent: CidSetEvent[];
    };
    hasMoreElements: boolean;
    participant: string;
    keyType: PixKeyType;
    startTime: Date;
    endTime: Date;
    syncVerifierStart: string;
    syncVerifierEnd: string;
};

type FraudType$1 = 'APPLICATION_FRAUD' | 'MULE_ACCOUNT' | 'SCAMMER_ACCOUNT' | 'OTHER' | 'UNKNOWN';
type FraudMarkerStatus = 'REGISTERED' | 'CANCELLED';
type MarkFraudParameters = {
    participant: string;
    fraudMarker: {
        taxIdNumber: string;
        fraudType: FraudType$1;
        key?: string;
    };
    requestId: string;
};
type FraudMarker = {
    taxIdNumber: string;
    key?: string;
    fraudType: FraudType$1;
    id: string;
    status: FraudMarkerStatus;
    creationTime: string;
    lastModified: string;
};
type MarkFraudResponse = DictResponse & {
    fraudMarker: FraudMarker;
};
type GetFraudMarkerParameters = {
    id: string;
    piRequestingParticipant: string;
};
type GetFraudMarkerResponse = DictResponse & {
    fraudMarker: FraudMarker;
};
type CancelFraudMarkerParameters = {
    participant: string;
    fraudMarkerId: string;
};
type CancelFraudMarkerResponse = DictResponse & {
    fraudMarker: FraudMarker;
};

type ContactInformation = {
    /**
     * The email address of the contact.
     */
    email?: string;
    /**
     * The phone number of the contact.
     */
    phone?: string;
};
type SituationType = 'SCAM' | 'ACCOUNT_TAKEOVER' | 'COERCION' | 'FRAUDULENT_ACCESS' | 'OTHER' | 'UNKNOWN';
type Reason = 'REFUND_REQUEST' | 'REFUND_CANCELLED';
type InfractionReport = {
    /**
     * The transaction ID.
     */
    transactionId: string;
    /**
     * The reason for the infraction report.
     */
    reason: Reason;
    /**
     * The situation type for the infraction report.
     */
    situationType: SituationType;
    /**
     * The details of the infraction report. only required for OTHER situation type.
     */
    reportDetails?: string;
    /**
     * The contact information for the infraction report.
     */
    contactInformation?: ContactInformation;
};
type ReportInfractionParameters = {
    /**
     * The participant ID to report the infraction for.
     */
    participantId: string;
    /**
     * The infraction report.
     */
    infractionReport: InfractionReport;
};
type InfractionReportStatus = 'OPEN' | 'ACKNOWLEDGED' | 'CLOSED' | 'CANCELLED';
type AnalysisResult = 'AGREED' | 'DISAGREED';
type FraudType = 'APPLICATION_FRAUD' | 'MULE_ACCOUNT' | 'SCAMMER_ACCOUNT' | 'OTHER' | 'UNKNOWN';
type InfractionReportResponse = {
    /**
     * The transaction ID.
     */
    transactionId: string;
    /**
     * The reason for the infraction report.
     */
    reason: Reason;
    /**
     * The situation type for the infraction report.
     */
    situationType: SituationType;
    /**
     * The details of the infraction report. only required for OTHER situation type.
     */
    reportDetails?: string;
    /**
     * The ID of the infraction report.
     */
    id: string;
    /**
     * The status of the infraction report.
     */
    status: InfractionReportStatus;
    /**
     * The participant ID of the reporter.
     */
    reporterParticipant: string;
    /**
     * The participant ID of the counterparty.
     */
    counterpartyParticipant: string;
    /**
     * The contact information for the infraction report.
     */
    contactInformation?: ContactInformation;
    /**
     * The creation time of the infraction report.
     */
    creationTime: Date;
    /**
     * The last modified time of the infraction report.
     */
    lastModified: Date;
    /**
     * The fraud marker ID.
     */
    fraudMarkerId?: string;
    /**
     * The analysis result.
     */
    analysisResult?: AnalysisResult;
    /**
     * The analysis details.
     */
    analysisDetails?: string;
};
type ReportInfractionResponse = DictResponse & {
    /**
     * The infraction report.
     */
    infractionReport: InfractionReportResponse;
};
type ListInfractionsParameters = {
    /**
     * The participant ID to list the infractions for.
     */
    participant: string;
    /**
     * Whether to include indirect participants.
     */
    includeIndirectParticipants?: boolean;
    /**
     * Whether to include the reporter.
     */
    isReporter?: boolean;
    /**
     * Whether to include the counterparty.
     */
    isCounterparty?: boolean;
    /**
     * The status of the infractions to list.
     */
    status?: InfractionReportStatus[];
    /**
     * Whether to include the details.
     */
    includeDetails?: boolean;
    /**
     * The modified after date.
     */
    modifiedAfter?: Date;
    /**
     * The modified before date.
     */
    modifiedBefore?: Date;
    /**
     * The limit of the infractions to list.
     */
    limit?: number;
};
type ListInfractionsResponse = DictResponse & {
    /**
     * The infractions.
     */
    infractionsReports: {
        infractionReport: InfractionReportResponse[];
    };
    /**
     * Whether there are more infractions to list.
     */
    hasMoreElements: boolean;
};
type GetInfractionParameters = {
    /**
     * The ID of the infraction to get.
     */
    id: string;
    /**
     * The participant ID to get the infraction for.
     */
    piRequestingParticipant: string;
};
type GetInfractionResponse = DictResponse & {
    /**
     * The infraction object.
     */
    infractionReport: InfractionReportResponse;
};
type AcknowledgeInfractionParameters = {
    /**
     * The ID of the infraction to acknowledge.
     */
    infractionReportId: string;
    /**
     * The participant ID to acknowledge the infraction for.
     */
    participantId: string;
};
type AcknowledgeInfractionResponse = DictResponse & {
    /**
     * The infraction report.
     */
    infractionReport: InfractionReportResponse;
};
type CancelInfractionParameters = {
    /**
     * The ID of the infraction to cancel.
     */
    infractionReportId: string;
    /**
     * The participant ID to cancel the infraction for.
     */
    participantId: string;
};
type CancelInfractionResponse = DictResponse & {
    /**
     * The infraction report.
     */
    infractionReport: InfractionReportResponse;
};
type CloseInfractionParameters = {
    /**
     * The ID of the infraction to close.
     */
    infractionReportId: string;
    /**
     * The participant ID to close the infraction for.
     */
    participantId: string;
    /**
     * The type of fraud.
     */
    fraudType?: FraudType;
    /**
     * The analysis result.
     */
    analysisResult: AnalysisResult;
    /**
     * The analysis details.
     */
    analysisDetails?: string;
};
type CloseInfractionResponse = DictResponse & {
    /**
     * The infraction report.
     */
    infractionReport: InfractionReportResponse;
};
type RefundReason = 'FRAUD' | 'OPERATIONAL_FLAW' | 'REFUND_CANCELLED' | 'PIX_AUTOMATICO';
type RefundStatus = 'OPEN' | 'CLOSED' | 'CANCELLED';
type RefundRejectionReason = 'NO_BALANCE' | 'ACCOUNT_CLOSURE' | 'INVALID_REQUEST' | 'OTHER';
type RefundRequestRole = 'REQUESTING' | 'CONTESTED';
type RefundAnalysisResult = 'TOTALLY_ACCEPTED' | 'PARTIALLY_ACCEPTED' | 'REJECTED';
type CreateRefundParameters = {
    /**
     * The participant ID to create the refund for.
     */
    participant: string;
    refund: {
        /**
         * The transaction ID to create the refund for.
         */
        transactionId: string;
        /**
         * The reason for the refund.
         */
        refundReason: RefundReason;
        /**
         * The amount for the refund.
         */
        refundAmount: number;
        /**
         * The details for the refund.
         */
        refundDetails?: string;
    };
};
type RefundResponse = {
    /**
     * The transaction ID.
     */
    transactionId: string;
    /**
     * The reason for the refund.
     */
    refundReason: RefundReason;
    /**
     * The amount for the refund.
     */
    refundAmount: number;
    /**
     * The details for the refund.
     */
    refundDetails?: string;
    /**
     * The ID of the refund.
     */
    id: string;
    /**
     * The status of the refund.
     */
    status: RefundStatus;
    /**
     * The participant ID of the contested party.
     */
    contestedParticipant: string;
    /**
     * The participant ID of the requesting party.
     */
    requestingParticipant: string;
    /**
     * The creation time of the refund.
     */
    creationTime: Date;
    /**
     * The last modified time of the refund.
     */
    lastModified: Date;
    /**
     * The infraction report ID.
     */
    infractionReportId?: string;
    /**
     * The analysis result.
     */
    analysisResult?: AnalysisResult;
    /**
     * The analysis details.
     */
    analysisDetails?: string;
    /**
     * The rejection reason.
     */
    refundRejectionReason?: RefundRejectionReason;
    /**
     * The transaction ID.
     */
    refundTransactionId?: string;
};
type CreateRefundResponse = DictResponse & {
    /**
     * The refund object.
     */
    refund: RefundResponse;
};
type ListRefundsParameters = {
    /**
     * The participant ID to list the refunds for.
     */
    participant: string;
    /**
     * Whether to include indirect participants.
     */
    includeIndirectParticipants?: boolean;
    /**
     * The role of the participant.
     */
    role?: RefundRequestRole;
    /**
     * The status of the refunds to list.
     */
    status?: RefundStatus[];
    /**
     * Whether to include the details.
     */
    includeDetails?: boolean;
    /**
     * The modified after date.
     */
    modifiedAfter?: Date;
    /**
     * The modified before date.
     */
    modifiedBefore?: Date;
    /**
     * The limit of the refunds to list.
     */
    limit?: number;
};
type ListRefundsResponse = DictResponse & {
    /**
     * The refunds.
     */
    refunds: {
        refund: RefundResponse[];
    };
    /**
     * Whether there are more refunds to list.
     */
    hasMoreElements: boolean;
};
type GetRefundParameters = {
    /**
     * The ID of the refund to get.
     */
    id: string;
    /**
     * The participant ID to get the refund for.
     */
    piRequestingParticipant: string;
};
type GetRefundResponse = DictResponse & {
    /**
     * The refund object.
     */
    refund: RefundResponse;
};
type CancelRefundParameters = {
    /**
     * The ID of the refund to cancel.
     */
    refundId: string;
    /**
     * The participant ID to cancel the refund for.
     */
    participant: string;
};
type CancelRefundResponse = DictResponse & {
    /**
     * The refund object.
     */
    refund: RefundResponse;
};
type CloseRefundParameters = {
    /**
     * The ID of the refund to close.
     */
    refundId: string;
    /**
     * The participant ID to close the refund for.
     */
    participant: string;
    /**
     * The analysis result.
     */
    refundAnalysisResult: RefundAnalysisResult;
    /**
     * The analysis details.
     */
    refundAnalysisDetails?: string;
    /**
     * The rejection reason.
     */
    refundRejectionReason?: RefundRejectionReason;
    /**
     * The transaction ID.
     */
    refundTransactionId?: string;
};
type CloseRefundResponse = DictResponse & {
    /**
     * The refund object.
     */
    refund: RefundResponse;
};

declare class PixDictApi {
    private readonly url;
    constructor(options: PixDictApiOptions);
    /**
     * Creates a new key binding with a transactional account.
     * @param request - The CreateDirectoryRequest object containing the key and transactional account information.
     * @returns A Promise that resolves to the CreateDirectoryResponse object containing the operation result.
     */
    createDirectory(request: CreateDirectoryRequest): Promise<CreateDirectoryResponse>;
    /**
     * Retrieves directory information for a specific key.
     * @param key - The key to retrieve information for.
     * @param parameters - The GetDirectoryParameters object containing the parameters for the request.
     * @returns A Promise that resolves to the GetDirectoryResponse object containing the directory information.
     */
    getDirectory(key: string, parameters: GetDirectoryParameters): Promise<GetDirectoryResponse>;
    /**
     * Retrieves directory information for a specific CID.
     * @param parameters - The GetDirectoryByCidParameters object containing the parameters for the request.
     * @returns A Promise that resolves to the GetDirectoryByCidResponse object containing the directory information.
     */
    getDirectoryByCid(parameters: GetDirectoryByCidParameters): Promise<GetDirectoryByCidResponse>;
    /**
     * Updates the directory information for a specific key.
     * @param request - The UpdateDirectoryRequest object containing the key and updated information.
     * @returns A Promise that resolves to the UpdateDirectoryResponse object containing the operation result.
     */
    updateDirectory(request: UpdateDirectoryRequest): Promise<UpdateDirectoryResponse>;
    /**
     * Deletes the directory information for a specific key.
     * @param key - The key to delete information for.
     * @returns A Promise that resolves to the DeleteEntryResponse object containing the operation result.
     */
    deleteDirectory(request: DeleteEntryRequest): Promise<DeleteEntryResponse>;
    /**
     * Checks the status of multiple keys.
     * @param keys - An array of keys to check.
     * @returns A Promise that resolves to the CheckKeyResponse object containing the status of the keys.
     */
    checkKey(keys: string[]): Promise<CheckKeyResponse>;
    /**
     * Creates a portability request for a specific key. (aka. Reivindicação)
     * @param request - The CreatePortabilityRequest object containing the key and portability information.
     * @returns A Promise that resolves to the CreatePortabilityResponse object containing the operation result.
     */
    createPortability(request: CreatePortabilityRequest): Promise<CreatePortabilityResponse>;
    /**
     * Retrieves a list of portabilities, ordered by the LastModified field in ascending order, according to the filters passed.
     * @param parameters - The ListPortabilityParameters object containing the parameters for the request.
     * @returns A Promise that resolves to the ListPortabilityResponse object containing the portability information.
     */
    listPortability(parameters: ListPortabilityParameters): Promise<ListPortabilityResponse>;
    /**
     * Retrieves the details of a specific portability claim.
     * @param parameters - The GetPortabilityParameters object containing the parameters for the request.
     * @returns A Promise that resolves to the GetPortabilityResponse object containing the portability claim details.
     */
    getPortability(parameters: GetPortabilityParameters): Promise<GetPortabilityResponse>;
    /**
     * Acknowledges a portability from the donor participant.
     * @param parameters - The AcknowledgePortabilityParameters object containing the parameters for the request.
     * @returns A Promise that resolves to the AcknowledgePortabilityResponse object containing the operation result.
     */
    acknowledgePortability(parameters: AcknowledgePortabilityParameters): Promise<AcknowledgePortabilityResponse>;
    /**
     * Confirms a portability from the donor participant.
     * @param parameters - The ConfirmPortabilityParameters object containing the parameters for the request.
     * @returns A Promise that resolves to the ConfirmPortabilityResponse object containing the operation result.
     */
    confirmPortability(parameters: ConfirmPortabilityParameters): Promise<ConfirmPortabilityResponse>;
    /**
     * Cancels a portability or ownership claim.
     * @param parameters - The CancelPortabilityParameters object containing the parameters for the request.
     * @returns A Promise that resolves to the CancelPortabilityResponse object containing the operation result.
     */
    cancelPortability(parameters: CancelPortabilityParameters): Promise<CancelPortabilityResponse>;
    /**
     * Completes a portability or ownership claim.
     * @param parameters - The CompletePortabilityParameters object containing the parameters for the request.
     * @returns A Promise that resolves to the CompletePortabilityResponse object containing the operation result.
     */
    completePortability(parameters: CompletePortabilityParameters): Promise<CompletePortabilityResponse>;
    /**
     * Creates a sync verification for a participant and key type.
     * @param parameters - The VerifySyncParameters object containing the parameters for the request.
     * @returns A Promise that resolves to the VerifySyncResponse object containing the operation result.
     */
    verifySync(parameters: VerifySyncParameters): Promise<VerifySyncResponse>;
    /**
     * Creates a CIDs file for a participant and key type.
     * @param parameters - The CreateCidsFileParameters object containing the parameters for the request.
     * @returns A Promise that resolves to the CreateCidsFileResponse object containing the operation result.
     */
    createCidsFile(parameters: CreateCidsFileParameters): Promise<CreateCidsFileResponse>;
    /**
     * Retrieves a CIDs file by ID.
     * @param parameters - The GetCidsFileParameters object containing the parameters for the request.
     * @returns A Promise that resolves to the GetCidsFileResponse object containing the CIDs file details.
     */
    getCidsFile(parameters: GetCidsFileParameters): Promise<GetCidsFileResponse>;
    /**
     * Retrieves a list of CIDs events for a participant and key type.
     * @param parameters - The ListCidsEventsParameters object containing the parameters for the request.
     * @returns A Promise that resolves to the ListCidsEventsResponse object containing the CIDs events.
     */
    listCidsEvents(parameters: ListCidsEventsParameters): Promise<ListCidsEventsResponse>;
    /**
     * Reports an infraction for a participant.
     * @param parameters - The ReportInfractionParameters object containing the parameters for the request.
     * @returns A Promise that resolves to the ReportInfractionResponse object containing the operation result.
     */
    reportInfraction(parameters: ReportInfractionParameters): Promise<ReportInfractionResponse>;
    /**
     * Retrieves a list of infractions for a participant.
     * @param parameters - The ListInfractionsParameters object containing the parameters for the request.
     * @returns A Promise that resolves to the ListInfractionsResponse object containing the infractions.
     */
    listInfractions(parameters: ListInfractionsParameters): Promise<ListInfractionsResponse>;
    /**
     * Retrieves an infraction by ID.
     * @param parameters - The GetInfractionParameters object containing the parameters for the request.
     * @returns A Promise that resolves to the GetInfractionResponse object containing the infraction.
     */
    getInfraction(parameters: GetInfractionParameters): Promise<GetInfractionResponse>;
    /**
     * Acknowledges an infraction.
     * @param parameters - The AcknowledgeInfractionParameters object containing the parameters for the request.
     * @returns A Promise that resolves to the AcknowledgeInfractionResponse object containing the operation result.
     */
    acknowledgeInfraction(parameters: AcknowledgeInfractionParameters): Promise<AcknowledgeInfractionResponse>;
    /**
     * Cancels an infraction.
     * @param parameters - The CancelInfractionParameters object containing the parameters for the request.
     * @returns A Promise that resolves to the CancelInfractionResponse object containing the operation result.
     */
    cancelInfraction(parameters: CancelInfractionParameters): Promise<CancelInfractionResponse>;
    /**
     * Closes an infraction.
     * @param parameters - The CloseInfractionParameters object containing the parameters for the request.
     * @returns A Promise that resolves to the CloseInfractionResponse object containing the operation result.
     */
    closeInfraction(parameters: CloseInfractionParameters): Promise<CloseInfractionResponse>;
    /**
     * The refund request can be created by the payer's PSP in cases where there is a well-founded suspicion of fraud and in those where there is an operational failure in the system of any of the participants involved in the transaction.
     * @param parameters - The CreateRefundParameters object containing the parameters for the request.
     * @returns A Promise that resolves to the CreateRefundResponse object containing the operation result.
     */
    createRefund(parameters: CreateRefundParameters): Promise<CreateRefundResponse>;
    /**
     * Retrieves a list of refunds for a participant.
     * @param parameters - The ListRefundsParameters object containing the parameters for the request.
     * @returns A Promise that resolves to the ListRefundsResponse object containing the refunds.
     */
    listRefunds(parameters: ListRefundsParameters): Promise<ListRefundsResponse>;
    /**
     * Retrieves a refund by ID.
     * @param parameters - The GetRefundParameters object containing the parameters for the request.
     * @returns A Promise that resolves to the GetRefundResponse object containing the refund.
     */
    getRefund(parameters: GetRefundParameters): Promise<GetRefundResponse>;
    /**
     * Cancels a refund.
     * @param parameters - The CancelRefundParameters object containing the parameters for the request.
     * @returns A Promise that resolves to the CancelRefundResponse object containing the operation result.
     */
    cancelRefund(parameters: CancelRefundParameters): Promise<CancelRefundResponse>;
    /**
     * Closes a refund.
     * @param parameters - The CloseRefundParameters object containing the parameters for the request.
     * @returns A Promise that resolves to the CloseRefundResponse object containing the operation result.
     */
    closeRefund(parameters: CloseRefundParameters): Promise<CloseRefundResponse>;
    markFraud(parameters: MarkFraudParameters): Promise<MarkFraudResponse>;
    getFraudMarker(parameters: GetFraudMarkerParameters): Promise<GetFraudMarkerResponse>;
    cancelFraudMarker(parameters: CancelFraudMarkerParameters): Promise<CancelFraudMarkerResponse>;
}

export { PixDictApi };