import type { IConnection, Primitive } from "@nestia/fetcher";
import typia from "typia";
import type { Format } from "typia/lib/tags/Format";
import type { IPaymentCancelHistory } from "../../../structures/payments/IPaymentCancelHistory";
import type { IPaymentHistory } from "../../../structures/payments/IPaymentHistory";
import type { IPaymentSource } from "../../../structures/payments/IPaymentSource";
export declare function get(connection: IConnection, input: get.Input): Promise<get.Output>;
export declare namespace get {
    type Input = Primitive<IPaymentSource.IAccessor>;
    type Output = Primitive<IPaymentHistory>;
    const METADATA: {
        readonly method: "PATCH";
        readonly path: "/payments/histories/get";
        readonly request: {
            readonly type: "text/plain";
            readonly encrypted: true;
        };
        readonly response: {
            readonly type: "text/plain";
            readonly encrypted: true;
        };
        readonly status: null;
    };
    const path: () => string;
    const random: (g?: Partial<typia.IRandomGenerator>) => Primitive<IPaymentHistory>;
    const simulate: (connection: IConnection, input: get.Input) => Promise<Output>;
}
export declare function at(connection: IConnection, id: string & Format<"uuid">, input: at.Input): Promise<at.Output>;
export declare namespace at {
    type Input = Primitive<IPaymentSource.IPassword>;
    type Output = Primitive<IPaymentHistory>;
    const METADATA: {
        readonly method: "PATCH";
        readonly path: "/payments/histories/:id";
        readonly request: {
            readonly type: "text/plain";
            readonly encrypted: true;
        };
        readonly response: {
            readonly type: "text/plain";
            readonly encrypted: true;
        };
        readonly status: null;
    };
    const path: (id: string & Format<"uuid">) => string;
    const random: (g?: Partial<typia.IRandomGenerator>) => Primitive<IPaymentHistory>;
    const simulate: (connection: IConnection, id: string & Format<"uuid">, input: at.Input) => Promise<Output>;
}
export declare function store(connection: IConnection, input: store.Input): Promise<store.Output>;
export declare namespace store {
    type Input = Primitive<IPaymentHistory.IStore>;
    type Output = Primitive<IPaymentHistory>;
    const METADATA: {
        readonly method: "POST";
        readonly path: "/payments/histories";
        readonly request: {
            readonly type: "text/plain";
            readonly encrypted: true;
        };
        readonly response: {
            readonly type: "text/plain";
            readonly encrypted: true;
        };
        readonly status: null;
    };
    const path: () => string;
    const random: (g?: Partial<typia.IRandomGenerator>) => Primitive<IPaymentHistory>;
    const simulate: (connection: IConnection, input: store.Input) => Promise<Output>;
}
export declare function cancel(connection: IConnection, input: cancel.Input): Promise<cancel.Output>;
export declare namespace cancel {
    type Input = Primitive<IPaymentCancelHistory.IStore>;
    type Output = Primitive<IPaymentHistory>;
    const METADATA: {
        readonly method: "PUT";
        readonly path: "/payments/histories/cancel";
        readonly request: {
            readonly type: "text/plain";
            readonly encrypted: true;
        };
        readonly response: {
            readonly type: "text/plain";
            readonly encrypted: true;
        };
        readonly status: null;
    };
    const path: () => string;
    const random: (g?: Partial<typia.IRandomGenerator>) => Primitive<IPaymentHistory>;
    const simulate: (connection: IConnection, input: cancel.Input) => Promise<Output>;
}