@chevre/domain/lib/chevre/repository.d.ts

Chevre Domain Library for Node.js

/**
 * リポジトリ
 */
import type { AcceptedOfferRepo } from './repo/acceptedOffer';
import type { AccountRepo } from './repo/account';
import type { AccountingReportRepo } from './repo/accountingReport';
import type { AccountTitleRepo } from './repo/accountTitle';
import type { AccountTransactionRepo } from './repo/accountTransaction';
import type { ActionRepo } from './repo/action';
import type { AdditionalPropertyRepo } from './repo/additionalProperty';
import type { AdvanceBookingRequirementRepo } from './repo/advanceBookingRequirement';
import type { AggregateOfferRepo } from './repo/aggregateOffer';
import type { AggregateOrderRepo } from './repo/aggregateOrder';
import type { AggregateReservationRepo } from './repo/aggregateReservation';
import type { AggregationRepo } from './repo/aggregation';
import type { AssetTransactionRepo } from './repo/assetTransaction';
import type { AuthorizationRepo } from './repo/authorization';
import type { CategoryCodeRepo } from './repo/categoryCode';
import type { CommentRepo } from './repo/comment';
import type { CreativeWorkRepo } from './repo/creativeWork';
import type { CredentialsRepo } from './repo/credentials';
import type { CustomerRepo } from './repo/customer';
import type { CustomerTypeRepo } from './repo/customerType';
import type { EmailMessageRepo } from './repo/emailMessage';
import type { EventRepo } from './repo/event';
import type { EventSellerMakesOfferRepo } from './repo/eventSellerMakesOffer';
import type { EventSeriesRepo } from './repo/eventSeries';
import type { IdentityRepo } from './repo/identity';
import type { IdentityProviderRepo } from './repo/identityProvider';
import type { IssuerRepo } from './repo/issuer';
import type { MemberRepo } from './repo/member';
import type { MemberProgramRepo } from './repo/memberProgram';
import type { MerchantReturnPolicyRepo } from './repo/merchantReturnPolicy';
import type { MessageRepo } from './repo/message';
import type { NoteRepo } from './repo/note';
import type { EventOfferRepo } from './repo/offer/event';
import type { OfferRepo } from './repo/offer/unitPriceInCatalog';
import type { OfferCatalogRepo } from './repo/offerCatalog';
import type { OfferCatalogItemRepo } from './repo/offerCatalogItem';
import type { OfferItemConditionRepo } from './repo/offerItemCondition';
import type { OrderRepo } from './repo/order';
import type { OrderInTransactionRepo } from './repo/orderInTransaction';
import type { OwnershipInfoRepo } from './repo/ownershipInfo';
import type { PassportRepo } from './repo/passport';
import type { PaymentServiceRepo } from './repo/paymentService';
import type { PaymentServiceChannelRepo } from './repo/paymentServiceChannel';
import type { PaymentServiceProviderRepo } from './repo/paymentServiceProvider';
import type { PendingReservationRepo } from './repo/pendingReservation';
import type { PermitRepo } from './repo/permit';
import type { BusStopRepo } from './repo/place/busStop';
import type { HasPOSRepo } from './repo/place/hasPOS';
import type { MovieTheaterRepo } from './repo/place/movieTheater';
import type { ScreeningRoomRepo } from './repo/place/screeningRoom';
import type { SeatRepo } from './repo/place/seat';
import type { SectionRepo } from './repo/place/section';
import type { PotentialActionRepo } from './repo/potentialAction';
import type { PriceSpecificationRepo } from './repo/priceSpecification';
import type { ProductRepo } from './repo/product';
import type { ProductModelRepo } from './repo/productModel';
import type { ProductOfferRepo } from './repo/productOffer';
import type { ProjectRepo } from './repo/project';
import type { ProjectMakesOfferRepo } from './repo/projectMakesOffer';
import type { OfferRateLimitRepo } from './repo/rateLimit/offer';
import type { ReservationRepo } from './repo/reservation';
import type { ReserveInterfaceRepo } from './repo/reserveInterface';
import type { RoleRepo } from './repo/role';
import type { ScheduleRepo } from './repo/schedule';
import type { SellerRepo } from './repo/seller';
import type { SellerPaymentAcceptedRepo } from './repo/sellerPaymentAccepted';
import type { SellerReturnPolicyRepo } from './repo/sellerReturnPolicy';
import type { ServiceAvailableHourRepo } from './repo/service/availableHour';
import type { ServiceOutputRepo } from './repo/serviceOutput';
import type { ServiceOutputIdentifierRepo } from './repo/serviceOutputIdentifier';
import type { SettingRepo } from './repo/setting';
import type { JWTSettingRepo } from './repo/setting/jwt';
import type { StockHolderRepo } from './repo/stockHolder';
import type { TaskRepo } from './repo/task';
import type { TelemetryRepo } from './repo/telemetry';
import type { TicketRepo } from './repo/ticket';
import type { TransactionRepo } from './repo/transaction';
import type { TransactionNumberRepo } from './repo/transactionNumber';
import type { TransactionProcessRepo } from './repo/transactionProcess';
import type { TripRepo } from './repo/trip';
import type { WebSiteRepo } from './repo/webSite';
import type { ConfirmationNumberRepo } from './repo/confirmationNumber';
import type { OrderNumberRepo } from './repo/orderNumber';
import type { CreditCardRepo } from './repo/paymentMethod/creditCard';
import type { PersonRepo } from './repo/person';
export type AcceptedOffer = AcceptedOfferRepo;
export declare namespace AcceptedOffer {
    function createInstance(...params: ConstructorParameters<typeof AcceptedOfferRepo>): Promise<AcceptedOfferRepo>;
}
export type Account = AccountRepo;
export declare namespace Account {
    function createInstance(...params: ConstructorParameters<typeof AccountRepo>): Promise<AccountRepo>;
}
export type AccountingReport = AccountingReportRepo;
export declare namespace AccountingReport {
    function createInstance(...params: ConstructorParameters<typeof AccountingReportRepo>): Promise<AccountingReportRepo>;
}
export type AccountTitle = AccountTitleRepo;
export declare namespace AccountTitle {
    function createInstance(...params: ConstructorParameters<typeof AccountTitleRepo>): Promise<AccountTitleRepo>;
}
export type AccountTransaction = AccountTransactionRepo;
export declare namespace AccountTransaction {
    function createInstance(...params: ConstructorParameters<typeof AccountTransactionRepo>): Promise<AccountTransactionRepo>;
}
export type Action = ActionRepo;
export declare namespace Action {
    function createInstance(...params: ConstructorParameters<typeof ActionRepo>): Promise<ActionRepo>;
}
export type AdditionalProperty = AdditionalPropertyRepo;
export declare namespace AdditionalProperty {
    function createInstance(...params: ConstructorParameters<typeof AdditionalPropertyRepo>): Promise<AdditionalPropertyRepo>;
}
export type AdvanceBookingRequirement = AdvanceBookingRequirementRepo;
export declare namespace AdvanceBookingRequirement {
    function createInstance(...params: ConstructorParameters<typeof AdvanceBookingRequirementRepo>): Promise<AdvanceBookingRequirementRepo>;
}
export type AggregateOffer = AggregateOfferRepo;
export declare namespace AggregateOffer {
    function createInstance(...params: ConstructorParameters<typeof AggregateOfferRepo>): Promise<AggregateOfferRepo>;
}
export type AggregateOrder = AggregateOrderRepo;
export declare namespace AggregateOrder {
    function createInstance(...params: ConstructorParameters<typeof AggregateOrderRepo>): Promise<AggregateOrderRepo>;
}
export type AggregateReservation = AggregateReservationRepo;
export declare namespace AggregateReservation {
    function createInstance(...params: ConstructorParameters<typeof AggregateReservationRepo>): Promise<AggregateReservationRepo>;
}
export type Aggregation = AggregationRepo;
export declare namespace Aggregation {
    function createInstance(...params: ConstructorParameters<typeof AggregationRepo>): Promise<AggregationRepo>;
}
export type AssetTransaction = AssetTransactionRepo;
export declare namespace AssetTransaction {
    function createInstance(...params: ConstructorParameters<typeof AssetTransactionRepo>): Promise<AssetTransactionRepo>;
}
export type CategoryCode = CategoryCodeRepo;
export declare namespace CategoryCode {
    function createInstance(...params: ConstructorParameters<typeof CategoryCodeRepo>): Promise<CategoryCodeRepo>;
}
export type Authorization = AuthorizationRepo;
export declare namespace Authorization {
    function createInstance(...params: ConstructorParameters<typeof AuthorizationRepo>): Promise<AuthorizationRepo>;
}
export type Comment = CommentRepo;
export declare namespace Comment {
    function createInstance(...params: ConstructorParameters<typeof CommentRepo>): Promise<CommentRepo>;
}
export type ConfirmationNumber = ConfirmationNumberRepo;
export declare namespace ConfirmationNumber {
    function createInstance(...params: ConstructorParameters<typeof ConfirmationNumberRepo>): Promise<ConfirmationNumberRepo>;
}
export type CreativeWork = CreativeWorkRepo;
export declare namespace CreativeWork {
    function createInstance(...params: ConstructorParameters<typeof CreativeWorkRepo>): Promise<CreativeWorkRepo>;
}
export type Credentials = CredentialsRepo;
export declare namespace Credentials {
    function createInstance(...params: ConstructorParameters<typeof CredentialsRepo>): Promise<CredentialsRepo>;
}
export type Customer = CustomerRepo;
export declare namespace Customer {
    function createInstance(...params: ConstructorParameters<typeof CustomerRepo>): Promise<CustomerRepo>;
}
export type CustomerType = CustomerTypeRepo;
export declare namespace CustomerType {
    function createInstance(...params: ConstructorParameters<typeof CustomerTypeRepo>): Promise<CustomerTypeRepo>;
}
export type EmailMessage = EmailMessageRepo;
export declare namespace EmailMessage {
    function createInstance(...params: ConstructorParameters<typeof EmailMessageRepo>): Promise<EmailMessageRepo>;
}
export type Event = EventRepo;
export declare namespace Event {
    function createInstance(...params: ConstructorParameters<typeof EventRepo>): Promise<EventRepo>;
}
export type EventOffer = EventOfferRepo;
export declare namespace EventOffer {
    function createInstance(...params: ConstructorParameters<typeof EventOfferRepo>): Promise<EventOfferRepo>;
}
export type EventSellerMakesOffer = EventSellerMakesOfferRepo;
export declare namespace EventSellerMakesOffer {
    function createInstance(...params: ConstructorParameters<typeof EventSellerMakesOfferRepo>): Promise<EventSellerMakesOfferRepo>;
}
export type EventSeries = EventSeriesRepo;
export declare namespace EventSeries {
    function createInstance(...params: ConstructorParameters<typeof EventSeriesRepo>): Promise<EventSeriesRepo>;
}
export type Identity = IdentityRepo;
export declare namespace Identity {
    function createInstance(...params: ConstructorParameters<typeof IdentityRepo>): Promise<IdentityRepo>;
}
export type IdentityProvider = IdentityProviderRepo;
export declare namespace IdentityProvider {
    function createInstance(...params: ConstructorParameters<typeof IdentityProviderRepo>): Promise<IdentityProviderRepo>;
}
export type Issuer = IssuerRepo;
export declare namespace Issuer {
    function createInstance(...params: ConstructorParameters<typeof IssuerRepo>): Promise<IssuerRepo>;
}
export type Member = MemberRepo;
export declare namespace Member {
    function createInstance(...params: ConstructorParameters<typeof MemberRepo>): Promise<MemberRepo>;
}
export type MemberProgram = MemberProgramRepo;
export declare namespace MemberProgram {
    function createInstance(...params: ConstructorParameters<typeof MemberProgramRepo>): Promise<MemberProgramRepo>;
}
export type MerchantReturnPolicy = MerchantReturnPolicyRepo;
export declare namespace MerchantReturnPolicy {
    function createInstance(...params: ConstructorParameters<typeof MerchantReturnPolicyRepo>): Promise<MerchantReturnPolicyRepo>;
}
export type Message = MessageRepo;
export declare namespace Message {
    function createInstance(...params: ConstructorParameters<typeof MessageRepo>): Promise<MessageRepo>;
}
export type Note = NoteRepo;
export declare namespace Note {
    function createInstance(...params: ConstructorParameters<typeof NoteRepo>): Promise<NoteRepo>;
}
export type OfferCatalog = OfferCatalogRepo;
export declare namespace OfferCatalog {
    function createInstance(...params: ConstructorParameters<typeof OfferCatalogRepo>): Promise<OfferCatalogRepo>;
}
export type OfferCatalogItem = OfferCatalogItemRepo;
export declare namespace OfferCatalogItem {
    function createInstance(...params: ConstructorParameters<typeof OfferCatalogItemRepo>): Promise<OfferCatalogItemRepo>;
}
export type OfferItemCondition = OfferItemConditionRepo;
export declare namespace OfferItemCondition {
    function createInstance(...params: ConstructorParameters<typeof OfferItemConditionRepo>): Promise<OfferItemConditionRepo>;
}
export type Offer = OfferRepo;
export declare namespace Offer {
    function createInstance(...params: ConstructorParameters<typeof OfferRepo>): Promise<OfferRepo>;
}
export type Order = OrderRepo;
export declare namespace Order {
    function createInstance(...params: ConstructorParameters<typeof OrderRepo>): Promise<OrderRepo>;
}
export type OrderInTransaction = OrderInTransactionRepo;
export declare namespace OrderInTransaction {
    function createInstance(...params: ConstructorParameters<typeof OrderInTransactionRepo>): Promise<OrderInTransactionRepo>;
}
export type OrderNumber = OrderNumberRepo;
export declare namespace OrderNumber {
    function createInstance(...params: ConstructorParameters<typeof OrderNumberRepo>): Promise<OrderNumberRepo>;
}
export type OwnershipInfo = OwnershipInfoRepo;
export declare namespace OwnershipInfo {
    function createInstance(...params: ConstructorParameters<typeof OwnershipInfoRepo>): Promise<OwnershipInfoRepo>;
}
export type Passport = PassportRepo;
export declare namespace Passport {
    function createInstance(...params: ConstructorParameters<typeof PassportRepo>): Promise<PassportRepo>;
}
export type PaymentService = PaymentServiceRepo;
export declare namespace PaymentService {
    function createInstance(...params: ConstructorParameters<typeof PaymentServiceRepo>): Promise<PaymentServiceRepo>;
}
export type PaymentServiceChannel = PaymentServiceChannelRepo;
export declare namespace PaymentServiceChannel {
    function createInstance(...params: ConstructorParameters<typeof PaymentServiceChannelRepo>): Promise<PaymentServiceChannelRepo>;
}
export type PaymentServiceProvider = PaymentServiceProviderRepo;
export declare namespace PaymentServiceProvider {
    function createInstance(...params: ConstructorParameters<typeof PaymentServiceProviderRepo>): Promise<PaymentServiceProviderRepo>;
}
export type PendingReservation = PendingReservationRepo;
export declare namespace PendingReservation {
    function createInstance(...params: ConstructorParameters<typeof PendingReservationRepo>): Promise<PendingReservationRepo>;
}
export declare namespace paymentMethod {
    /**
     * クレジットカードリポジトリ
     */
    type CreditCard = CreditCardRepo;
    namespace CreditCard {
        function createInstance(...params: ConstructorParameters<typeof CreditCardRepo>): Promise<CreditCardRepo>;
    }
}
export type Person = PersonRepo;
export declare namespace Person {
    function createInstance(...params: ConstructorParameters<typeof PersonRepo>): Promise<PersonRepo>;
}
export type Permit = PermitRepo;
export declare namespace Permit {
    function createInstance(...params: ConstructorParameters<typeof PermitRepo>): Promise<PermitRepo>;
}
export declare namespace place {
    type BusStop = BusStopRepo;
    /**
     * ターミナルリポジトリ
     */
    namespace BusStop {
        function createInstance(...params: ConstructorParameters<typeof BusStopRepo>): Promise<BusStopRepo>;
    }
    type HasPOS = HasPOSRepo;
    /**
     * 施設PointOfSalesリポジトリ
     */
    namespace HasPOS {
        function createInstance(...params: ConstructorParameters<typeof HasPOSRepo>): Promise<HasPOSRepo>;
    }
    type MovieTheater = MovieTheaterRepo;
    /**
     * 施設リポジトリ
     */
    namespace MovieTheater {
        function createInstance(...params: ConstructorParameters<typeof MovieTheaterRepo>): Promise<MovieTheaterRepo>;
    }
    type ScreeningRoom = ScreeningRoomRepo;
    /**
     * ルームリポジトリ
     */
    namespace ScreeningRoom {
        function createInstance(...params: ConstructorParameters<typeof ScreeningRoomRepo>): Promise<ScreeningRoomRepo>;
    }
    type Seat = SeatRepo;
    /**
     * 座席リポジトリ
     */
    namespace Seat {
        function createInstance(...params: ConstructorParameters<typeof SeatRepo>): Promise<SeatRepo>;
    }
    type Section = SectionRepo;
    /**
     * セクションリポジトリ
     */
    namespace Section {
        function createInstance(...params: ConstructorParameters<typeof SectionRepo>): Promise<SectionRepo>;
    }
}
export type PotentialAction = PotentialActionRepo;
export declare namespace PotentialAction {
    function createInstance(...params: ConstructorParameters<typeof PotentialActionRepo>): Promise<PotentialActionRepo>;
}
export type PriceSpecification = PriceSpecificationRepo;
export declare namespace PriceSpecification {
    function createInstance(...params: ConstructorParameters<typeof PriceSpecificationRepo>): Promise<PriceSpecificationRepo>;
}
export type Product = ProductRepo;
export declare namespace Product {
    function createInstance(...params: ConstructorParameters<typeof ProductRepo>): Promise<ProductRepo>;
}
export type ProductModel = ProductModelRepo;
export declare namespace ProductModel {
    function createInstance(...params: ConstructorParameters<typeof ProductModelRepo>): Promise<ProductModelRepo>;
}
export type ProductOffer = ProductOfferRepo;
export declare namespace ProductOffer {
    function createInstance(...params: ConstructorParameters<typeof ProductOfferRepo>): Promise<ProductOfferRepo>;
}
export type Project = ProjectRepo;
export declare namespace Project {
    function createInstance(...params: ConstructorParameters<typeof ProjectRepo>): Promise<ProjectRepo>;
}
export type ProjectMakesOffer = ProjectMakesOfferRepo;
export declare namespace ProjectMakesOffer {
    function createInstance(...params: ConstructorParameters<typeof ProjectMakesOfferRepo>): Promise<ProjectMakesOfferRepo>;
}
export type Reservation = ReservationRepo;
export declare namespace Reservation {
    function createInstance(...params: ConstructorParameters<typeof ReservationRepo>): Promise<ReservationRepo>;
}
export type ReserveInterface = ReserveInterfaceRepo;
export declare namespace ReserveInterface {
    function createInstance(...params: ConstructorParameters<typeof ReserveInterfaceRepo>): Promise<ReserveInterfaceRepo>;
}
export type Role = RoleRepo;
export declare namespace Role {
    function createInstance(...params: ConstructorParameters<typeof RoleRepo>): Promise<RoleRepo>;
}
export type Schedule = ScheduleRepo;
export declare namespace Schedule {
    function createInstance(...params: ConstructorParameters<typeof ScheduleRepo>): Promise<ScheduleRepo>;
}
export type Seller = SellerRepo;
export declare namespace Seller {
    function createInstance(...params: ConstructorParameters<typeof SellerRepo>): Promise<SellerRepo>;
}
export type SellerPaymentAccepted = SellerPaymentAcceptedRepo;
export declare namespace SellerPaymentAccepted {
    function createInstance(...params: ConstructorParameters<typeof SellerPaymentAcceptedRepo>): Promise<SellerPaymentAcceptedRepo>;
}
export type SellerReturnPolicy = SellerReturnPolicyRepo;
export declare namespace SellerReturnPolicy {
    function createInstance(...params: ConstructorParameters<typeof SellerReturnPolicyRepo>): Promise<SellerReturnPolicyRepo>;
}
export type ServiceAvailableHour = ServiceAvailableHourRepo;
export declare namespace ServiceAvailableHour {
    function createInstance(...params: ConstructorParameters<typeof ServiceAvailableHourRepo>): Promise<ServiceAvailableHourRepo>;
}
export type ServiceOutput = ServiceOutputRepo;
export declare namespace ServiceOutput {
    function createInstance(...params: ConstructorParameters<typeof ServiceOutputRepo>): Promise<ServiceOutputRepo>;
}
export type ServiceOutputIdentifier = ServiceOutputIdentifierRepo;
export declare namespace ServiceOutputIdentifier {
    function createInstance(...params: ConstructorParameters<typeof ServiceOutputIdentifierRepo>): Promise<ServiceOutputIdentifierRepo>;
}
export type Setting = SettingRepo;
export declare namespace Setting {
    function createInstance(...params: ConstructorParameters<typeof SettingRepo>): Promise<SettingRepo>;
}
export declare namespace setting {
    type JWT = JWTSettingRepo;
    namespace JWT {
        function createInstance(...params: ConstructorParameters<typeof JWTSettingRepo>): Promise<JWTSettingRepo>;
    }
}
export type StockHolder = StockHolderRepo;
export declare namespace StockHolder {
    function createInstance(...params: ConstructorParameters<typeof StockHolderRepo>): Promise<StockHolderRepo>;
}
export type Task = TaskRepo;
export declare namespace Task {
    function createInstance(...params: ConstructorParameters<typeof TaskRepo>): Promise<TaskRepo>;
}
export type Telemetry = TelemetryRepo;
export declare namespace Telemetry {
    function createInstance(...params: ConstructorParameters<typeof TelemetryRepo>): Promise<TelemetryRepo>;
}
export type Ticket = TicketRepo;
export declare namespace Ticket {
    function createInstance(...params: ConstructorParameters<typeof TicketRepo>): Promise<TicketRepo>;
}
export type Transaction = TransactionRepo;
export declare namespace Transaction {
    function createInstance(...params: ConstructorParameters<typeof TransactionRepo>): Promise<TransactionRepo>;
}
export type TransactionNumber = TransactionNumberRepo;
export declare namespace TransactionNumber {
    function createInstance(...params: ConstructorParameters<typeof TransactionNumberRepo>): Promise<TransactionNumberRepo>;
}
export type TransactionProcess = TransactionProcessRepo;
export declare namespace TransactionProcess {
    function createInstance(...params: ConstructorParameters<typeof TransactionProcessRepo>): Promise<TransactionProcessRepo>;
}
export type Trip = TripRepo;
export declare namespace Trip {
    function createInstance(...params: ConstructorParameters<typeof TripRepo>): Promise<TripRepo>;
}
export declare namespace rateLimit {
    type Offer = OfferRateLimitRepo;
    namespace Offer {
        function createInstance(...params: ConstructorParameters<typeof OfferRateLimitRepo>): Promise<OfferRateLimitRepo>;
    }
}
export type WebSite = WebSiteRepo;
export declare namespace WebSite {
    function createInstance(...params: ConstructorParameters<typeof WebSiteRepo>): Promise<WebSiteRepo>;
}