@mittwald/api-models 4.242.3 → 4.244.0

package/dist/types/base/types.d.ts

@@ -0,0 +1,6 @@
+import { DataModel } from "./DataModel.js";
+export type DataType<T> = T extends DataModel<infer TData> ? TData : never;
+export type QueryResponseData<T> = {
+    items: readonly T[];
+    totalCount: number;
+};

package/dist/types/config/behaviors/api.d.ts

@@ -0,0 +1,12 @@
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+declare class ApiSetupState {
+    private _client;
+    setupWithClient(client: MittwaldAPIV2Client): void;
+    setupWithApiToken(apiToken: string): void;
+    setupUnauthenticated(): void;
+    get client(): MittwaldAPIV2Client;
+    get defaults(): (typeof this.client)["axios"]["defaults"];
+    get interceptors(): (typeof this.client)["axios"]["interceptors"];
+}
+export declare const api: ApiSetupState;
+export {};

package/dist/types/config/behaviors/index.d.ts

@@ -0,0 +1 @@
+export * from "./api.js";

package/dist/types/config/config.d.ts

@@ -0,0 +1,23 @@
+import { ProjectBehaviors } from "../project/Project/behaviors/index.js";
+import { ServerBehaviors } from "../server/Server/behaviors/index.js";
+import { CustomerBehaviors } from "../customer/Customer/behaviors/index.js";
+import { IngressBehaviors } from "../domain/Ingress/behaviors/index.js";
+import { ContractBehaviors } from "../contract/Contract/behaviors/index.js";
+import { AppInstallationBehaviors } from "../app/AppInstallation/behaviors/index.js";
+import { ContractItemBehaviors } from "../contract/ContractItem/behaviors/index.js";
+import { ArticleBehaviors } from "../article/Article/behaviors/index.js";
+interface Config {
+    defaultPaginationLimit: number;
+    behaviors: {
+        contract: ContractBehaviors;
+        contractItem: ContractItemBehaviors;
+        article: ArticleBehaviors;
+        project: ProjectBehaviors;
+        server: ServerBehaviors;
+        customer: CustomerBehaviors;
+        ingress: IngressBehaviors;
+        appInstallation: AppInstallationBehaviors;
+    };
+}
+export declare const config: Config;
+export {};

package/dist/types/config/index.d.ts

@@ -0,0 +1 @@
+export * from "./behaviors/index.js";

package/dist/types/contract/Contract/Contract.d.ts

@@ -0,0 +1,68 @@
+import { DataModel, ListDataModel, ListQueryModel, ReferenceModel } from "../../base/index.js";
+import { ContractData, ContractListItemData, ContractListQueryData, ContractListQueryModelData } from "./types.js";
+export declare class Contract extends ReferenceModel {
+    static ofId(id: string): Contract;
+    static find: import("../../react/provideReact.js").AsyncResourceVariant<(id: string) => Promise<ContractDetailed | undefined>>;
+    static query(query: ContractListQueryModelData): ContractListQuery;
+    static get: import("../../react/provideReact.js").AsyncResourceVariant<(id: string) => Promise<ContractDetailed>>;
+}
+declare const ContractCommon_base: import("polytype").Polytype.ClusteredConstructor<[{
+    new (data: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ContractContract | {
+        additionalItems?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ContractContractItem[] | undefined;
+        baseItem: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ContractContractItem;
+        contractId: string;
+        contractNumber: string;
+        customerId: string;
+        termination?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ContractTermination | undefined;
+    }): DataModel<import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ContractContract | {
+        additionalItems?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ContractContractItem[] | undefined;
+        baseItem: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ContractContractItem;
+        contractId: string;
+        contractNumber: string;
+        customerId: string;
+        termination?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ContractTermination | undefined;
+    }>;
+}, typeof Contract]>;
+declare class ContractCommon extends ContractCommon_base {
+    constructor(data: ContractListItemData | ContractData);
+}
+declare const ContractDetailed_base: import("polytype").Polytype.ClusteredConstructor<[typeof ContractCommon, {
+    new (data: {
+        additionalItems?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ContractContractItem[] | undefined;
+        baseItem: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ContractContractItem;
+        contractId: string;
+        contractNumber: string;
+        customerId: string;
+        termination?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ContractTermination | undefined;
+    }): DataModel<{
+        additionalItems?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ContractContractItem[] | undefined;
+        baseItem: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ContractContractItem;
+        contractId: string;
+        contractNumber: string;
+        customerId: string;
+        termination?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ContractTermination | undefined;
+    }>;
+}]>;
+export declare class ContractDetailed extends ContractDetailed_base {
+    constructor(data: ContractData);
+}
+declare const ContractListItem_base: import("polytype").Polytype.ClusteredConstructor<[typeof ContractCommon, {
+    new (data: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ContractContract): DataModel<import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ContractContract>;
+}]>;
+export declare class ContractListItem extends ContractListItem_base {
+    constructor(data: ContractListItemData);
+}
+export declare class ContractListQuery extends ListQueryModel<ContractListQueryModelData> {
+    constructor(query: ContractListQueryModelData);
+    refine(query: ContractListQueryData): ContractListQuery;
+    execute: import("../../react/provideReact.js").AsyncResourceVariant<() => Promise<ContractList>>;
+    getTotalCount: import("../../react/provideReact.js").AsyncResourceVariant<() => Promise<number>>;
+    findOneAndOnly: import("../../react/provideReact.js").AsyncResourceVariant<() => Promise<ContractListItem | undefined>>;
+}
+declare const ContractList_base: import("polytype").Polytype.ClusteredConstructor<[typeof ContractListQuery, {
+    new (items: ContractListItem[], totalCount: number): ListDataModel<ContractListItem>;
+}]>;
+export declare class ContractList extends ContractList_base {
+    constructor(query: ContractListQueryModelData, contracts: ContractListItem[], totalCount: number);
+}
+export {};

package/dist/types/contract/Contract/behaviors/api.d.ts

@@ -0,0 +1,3 @@
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ContractBehaviors } from "./types.js";
+export declare const apiContractBehaviors: (client: MittwaldAPIV2Client) => ContractBehaviors;

package/dist/types/contract/Contract/behaviors/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./api.js";
+export * from "./types.js";

package/dist/types/contract/Contract/behaviors/types.d.ts

@@ -0,0 +1,9 @@
+import { ContractData, ContractListItemData, ContractListQueryData } from "../types.js";
+import { QueryResponseData } from "../../../base/index.js";
+export interface ContractBehaviors {
+    find: (id: string) => Promise<ContractData | undefined>;
+    list: (request: {
+        customerId: string;
+        queryParameters?: ContractListQueryData;
+    }) => Promise<QueryResponseData<ContractListItemData>>;
+}

package/dist/types/contract/Contract/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Contract.js";
+export * from "./types.js";

package/dist/types/contract/Contract/types.d.ts

@@ -0,0 +1,8 @@
+import { MittwaldAPIV2 } from "@mittwald/api-client";
+import { Customer } from "../../customer/index.js";
+export type ContractListQueryData = MittwaldAPIV2.Paths.V2ContractsContractId.Get.Parameters.Query;
+export type ContractListQueryModelData = Omit<ContractListQueryData, "customerId"> & {
+    customer: Customer;
+};
+export type ContractData = MittwaldAPIV2.Operations.ContractGetDetailOfContract.ResponseData;
+export type ContractListItemData = MittwaldAPIV2.Operations.ContractListContracts.ResponseData[number];

package/dist/types/contract/ContractItem/ContractItem.d.ts

@@ -0,0 +1,64 @@
+import { ContractItemData } from "./types.js";
+import { DataModel, ReferenceModel } from "../../base/index.js";
+export declare class ContractItem extends ReferenceModel {
+    static ofId(contractId: string, id: string): ContractItem;
+    static find: import("../../react/provideReact.js").AsyncResourceVariant<(contractId: string, contractItemId: string) => Promise<ContractItemDetailed | undefined>>;
+    static get: import("../../react/provideReact.js").AsyncResourceVariant<(contractId: string, contractItemId: string) => Promise<ContractItemDetailed>>;
+    readonly contractId: string;
+    constructor(contractId: string, id: string);
+}
+declare const ContractItemDetailed_base: import("polytype").Polytype.ClusteredConstructor<[{
+    new (data: {
+        activationDate?: string | undefined;
+        aggregateReference?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ContractAggregateReference | undefined;
+        articles: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ContractArticle[];
+        contractPeriod: number;
+        description: string;
+        freeTrialDays?: number | undefined;
+        groupByProjectId?: string | undefined;
+        invoiceStop?: string | undefined;
+        invoicingPeriod?: number | undefined;
+        isActivated: boolean;
+        isBaseItem: boolean;
+        isInFreeTrial?: boolean | undefined;
+        isInclusive?: boolean | undefined;
+        itemId: string;
+        nextPossibleDowngradeDate?: string | undefined;
+        nextPossibleTerminationDate?: string | undefined;
+        nextPossibleUpgradeDate?: string | undefined;
+        orderDate?: string | undefined;
+        orderId?: string | undefined;
+        replacedByItem?: string | undefined;
+        tariffChange?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ContractTariffChange | undefined;
+        termination?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ContractTermination | undefined;
+        totalPrice: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ContractPrice;
+    }): DataModel<{
+        activationDate?: string | undefined;
+        aggregateReference?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ContractAggregateReference | undefined;
+        articles: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ContractArticle[];
+        contractPeriod: number;
+        description: string;
+        freeTrialDays?: number | undefined;
+        groupByProjectId?: string | undefined;
+        invoiceStop?: string | undefined;
+        invoicingPeriod?: number | undefined;
+        isActivated: boolean;
+        isBaseItem: boolean;
+        isInFreeTrial?: boolean | undefined;
+        isInclusive?: boolean | undefined;
+        itemId: string;
+        nextPossibleDowngradeDate?: string | undefined;
+        nextPossibleTerminationDate?: string | undefined;
+        nextPossibleUpgradeDate?: string | undefined;
+        orderDate?: string | undefined;
+        orderId?: string | undefined;
+        replacedByItem?: string | undefined;
+        tariffChange?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ContractTariffChange | undefined;
+        termination?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ContractTermination | undefined;
+        totalPrice: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ContractPrice;
+    }>;
+}, typeof ContractItem]>;
+export declare class ContractItemDetailed extends ContractItemDetailed_base {
+    constructor(contractId: string, data: ContractItemData);
+}
+export {};

package/dist/types/contract/ContractItem/behaviors/api.d.ts

@@ -0,0 +1,3 @@
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ContractItemBehaviors } from "./types.js";
+export declare const apiContractItemBehaviors: (client: MittwaldAPIV2Client) => ContractItemBehaviors;

package/dist/types/contract/ContractItem/behaviors/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./api.js";
+export * from "./types.js";

package/dist/types/contract/ContractItem/behaviors/types.d.ts

@@ -0,0 +1,4 @@
+import { ContractItemData } from "../types.js";
+export interface ContractItemBehaviors {
+    find: (contractId: string, contractItemId: string) => Promise<ContractItemData | undefined>;
+}

package/dist/types/contract/ContractItem/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./ContractItem.js";
+export * from "./types.js";

package/dist/types/contract/ContractItem/types.d.ts

@@ -0,0 +1,2 @@
+import { MittwaldAPIV2 } from "@mittwald/api-client";
+export type ContractItemData = MittwaldAPIV2.Operations.ContractGetDetailOfContractItem.ResponseData;

package/dist/types/contract/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Contract/index.js";
+export * from "./ContractItem/index.js";

package/dist/types/customer/Customer/Customer.d.ts

@@ -0,0 +1,138 @@
+import { DataModel } from "../../base/DataModel.js";
+import { ReferenceModel } from "../../base/ReferenceModel.js";
+import { AsyncResourceVariant } from "../../react/provideReact.js";
+import { CustomerData, CustomerListItemData, CustomerListQueryData, CustomerUpdateRequestData } from "./types.js";
+import { ListQueryModel } from "../../base/ListQueryModel.js";
+import { ListDataModel } from "../../base/ListDataModel.js";
+import { ServerListQuery } from "../../server/index.js";
+import { ProjectListQuery } from "../../project/index.js";
+export declare class Customer extends ReferenceModel {
+    readonly servers: ServerListQuery;
+    readonly projects: ProjectListQuery;
+    constructor(id: string);
+    static ofId(id: string): Customer;
+    static find: AsyncResourceVariant<(id: string) => Promise<CustomerDetailed | undefined>>;
+    static query(query?: CustomerListQueryData): CustomerListQuery;
+    /** @deprecated Use query() */
+    static list: AsyncResourceVariant<(query?: CustomerListQueryData) => Promise<Readonly<Array<CustomerListItem>>>>;
+    static get: AsyncResourceVariant<(id: string) => Promise<CustomerDetailed>>;
+    getDetailed: AsyncResourceVariant<() => Promise<CustomerDetailed>>;
+    findDetailed: AsyncResourceVariant<() => Promise<CustomerDetailed | undefined>>;
+    update(data: CustomerUpdateRequestData): Promise<void>;
+}
+declare const CustomerCommon_base: import("polytype").Polytype.ClusteredConstructor<[{
+    new (data: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.CustomerCustomer | {
+        activeSuspension?: {
+            createdAt: string;
+        } | undefined;
+        avatarRefId?: string | undefined;
+        categoryId?: string | undefined;
+        creationDate: string;
+        customerId: string;
+        customerNumber: string;
+        executingUserRoles?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.CustomerRole[] | undefined;
+        flags?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.CustomerCustomerFlag[] | undefined;
+        isAllowedToPlaceOrders?: boolean | undefined;
+        isBanned?: boolean | undefined;
+        isInDefaultOfPayment?: boolean | undefined;
+        levelOfUndeliverableDunningNotice?: "first" | "second" | undefined;
+        memberCount: number;
+        name: string;
+        owner?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.CustomerContact | undefined;
+        projectCount: number;
+        vatId?: string | undefined;
+        vatIdValidationState?: "valid" | "invalid" | "pending" | "unspecified" | undefined;
+    }): DataModel<import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.CustomerCustomer | {
+        activeSuspension?: {
+            createdAt: string;
+        } | undefined;
+        avatarRefId?: string | undefined;
+        categoryId?: string | undefined;
+        creationDate: string;
+        customerId: string;
+        customerNumber: string;
+        executingUserRoles?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.CustomerRole[] | undefined;
+        flags?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.CustomerCustomerFlag[] | undefined;
+        isAllowedToPlaceOrders?: boolean | undefined;
+        isBanned?: boolean | undefined;
+        isInDefaultOfPayment?: boolean | undefined;
+        levelOfUndeliverableDunningNotice?: "first" | "second" | undefined;
+        memberCount: number;
+        name: string;
+        owner?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.CustomerContact | undefined;
+        projectCount: number;
+        vatId?: string | undefined;
+        vatIdValidationState?: "valid" | "invalid" | "pending" | "unspecified" | undefined;
+    }>;
+}, typeof Customer]>;
+declare class CustomerCommon extends CustomerCommon_base {
+    constructor(data: CustomerListItemData | CustomerData);
+}
+declare const CustomerDetailed_base: import("polytype").Polytype.ClusteredConstructor<[typeof CustomerCommon, {
+    new (data: {
+        activeSuspension?: {
+            createdAt: string;
+        } | undefined;
+        avatarRefId?: string | undefined;
+        categoryId?: string | undefined;
+        creationDate: string;
+        customerId: string;
+        customerNumber: string;
+        executingUserRoles?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.CustomerRole[] | undefined;
+        flags?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.CustomerCustomerFlag[] | undefined;
+        isAllowedToPlaceOrders?: boolean | undefined;
+        isBanned?: boolean | undefined;
+        isInDefaultOfPayment?: boolean | undefined;
+        levelOfUndeliverableDunningNotice?: "first" | "second" | undefined;
+        memberCount: number;
+        name: string;
+        owner?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.CustomerContact | undefined;
+        projectCount: number;
+        vatId?: string | undefined;
+        vatIdValidationState?: "valid" | "invalid" | "pending" | "unspecified" | undefined;
+    }): DataModel<{
+        activeSuspension?: {
+            createdAt: string;
+        } | undefined;
+        avatarRefId?: string | undefined;
+        categoryId?: string | undefined;
+        creationDate: string;
+        customerId: string;
+        customerNumber: string;
+        executingUserRoles?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.CustomerRole[] | undefined;
+        flags?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.CustomerCustomerFlag[] | undefined;
+        isAllowedToPlaceOrders?: boolean | undefined;
+        isBanned?: boolean | undefined;
+        isInDefaultOfPayment?: boolean | undefined;
+        levelOfUndeliverableDunningNotice?: "first" | "second" | undefined;
+        memberCount: number;
+        name: string;
+        owner?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.CustomerContact | undefined;
+        projectCount: number;
+        vatId?: string | undefined;
+        vatIdValidationState?: "valid" | "invalid" | "pending" | "unspecified" | undefined;
+    }>;
+}]>;
+export declare class CustomerDetailed extends CustomerDetailed_base {
+    constructor(data: CustomerData);
+}
+declare const CustomerListItem_base: import("polytype").Polytype.ClusteredConstructor<[typeof CustomerCommon, {
+    new (data: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.CustomerCustomer): DataModel<import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.CustomerCustomer>;
+}]>;
+export declare class CustomerListItem extends CustomerListItem_base {
+    constructor(data: CustomerListItemData);
+}
+export declare class CustomerListQuery extends ListQueryModel<CustomerListQueryData> {
+    constructor(query?: CustomerListQueryData);
+    refine(query: CustomerListQueryData): CustomerListQuery;
+    execute: AsyncResourceVariant<() => Promise<CustomerList>>;
+    getTotalCount: AsyncResourceVariant<() => Promise<number>>;
+    findOneAndOnly: AsyncResourceVariant<() => Promise<CustomerListItem | undefined>>;
+}
+declare const CustomerList_base: import("polytype").Polytype.ClusteredConstructor<[typeof CustomerListQuery, {
+    new (items: CustomerListItem[], totalCount: number): ListDataModel<CustomerListItem>;
+}]>;
+export declare class CustomerList extends CustomerList_base {
+    constructor(query: CustomerListQueryData, customers: CustomerListItem[], totalCount: number);
+}
+export {};

package/dist/types/customer/Customer/behaviors/api.d.ts

@@ -0,0 +1,3 @@
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+import { CustomerBehaviors } from "./types.js";
+export declare const apiCustomerBehaviors: (client: MittwaldAPIV2Client) => CustomerBehaviors;

package/dist/types/customer/Customer/behaviors/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./api.js";
+export * from "./types.js";

package/dist/types/customer/Customer/behaviors/types.d.ts

@@ -0,0 +1,7 @@
+import { CustomerListItemData, CustomerData, CustomerListQueryData, CustomerUpdateRequestData } from "../types.js";
+import { QueryResponseData } from "../../../base/index.js";
+export interface CustomerBehaviors {
+    find: (id: string) => Promise<CustomerData | undefined>;
+    list: (query?: CustomerListQueryData) => Promise<QueryResponseData<CustomerListItemData>>;
+    update: (id: string, data: CustomerUpdateRequestData) => Promise<void>;
+}

package/dist/types/customer/Customer/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Customer.js";
+export * from "./types.js";

package/dist/types/customer/Customer/types.d.ts

@@ -0,0 +1,5 @@
+import { MittwaldAPIV2 } from "@mittwald/api-client";
+export type CustomerListQueryData = MittwaldAPIV2.Paths.V2Customers.Get.Parameters.Query;
+export type CustomerData = MittwaldAPIV2.Operations.CustomerGetCustomer.ResponseData;
+export type CustomerListItemData = MittwaldAPIV2.Operations.CustomerListCustomers.ResponseData[number];
+export type CustomerUpdateRequestData = MittwaldAPIV2.Paths.V2CustomersCustomerId.Put.Parameters.RequestBody;

package/dist/types/customer/index.d.ts

@@ -0,0 +1 @@
+export * from "./Customer/index.js";

package/dist/types/domain/Ingress/Ingress.d.ts

@@ -0,0 +1,109 @@
+import { DataModel } from "../../base/DataModel.js";
+import { ReferenceModel } from "../../base/ReferenceModel.js";
+import { AsyncResourceVariant } from "../../react/provideReact.js";
+import { IngressData, IngressListItemData, IngressListQueryData, IngressListQueryModelData } from "./types.js";
+import { IngressPath } from "../IngressPath/IngressPath.js";
+import { ListQueryModel } from "../../base/ListQueryModel.js";
+import { ListDataModel } from "../../base/ListDataModel.js";
+export declare class Ingress extends ReferenceModel {
+    static ofId(id: string): Ingress;
+    static ofHostname(hostname: string): Ingress;
+    /** @deprecated: use query() or project.ingresses */
+    static list: AsyncResourceVariant<(query?: IngressListQueryData) => Promise<Readonly<Array<IngressListItem>>>>;
+    static find: AsyncResourceVariant<(id: string) => Promise<IngressDetailed | undefined>>;
+    static get: AsyncResourceVariant<(id: string) => Promise<IngressDetailed>>;
+    getDetailed: AsyncResourceVariant<() => Promise<IngressDetailed>>;
+    findDetailed: AsyncResourceVariant<() => Promise<IngressDetailed | undefined>>;
+}
+declare const IngressCommon_base: import("polytype").Polytype.ClusteredConstructor<[{
+    new (data: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.IngressIngress | {
+        dnsValidationErrors: ("ERROR_UNSPECIFIED" | "ERROR_QUAD_A" | "ERROR_NO_A_RECORD" | "ERROR_ACME_CERTIFICATE_REQUEST_DEADLINE_EXCEEDED")[];
+        hostname: string;
+        id: string;
+        ips: {
+            v4: string[];
+        };
+        isDefault: boolean;
+        isDomain?: boolean | undefined;
+        isEnabled: boolean;
+        ownership: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.IngressOwnership;
+        paths: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.IngressPath[];
+        projectId: string;
+        tls: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.IngressTlsAcme | import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.IngressTlsCertificate;
+    }): DataModel<import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.IngressIngress | {
+        dnsValidationErrors: ("ERROR_UNSPECIFIED" | "ERROR_QUAD_A" | "ERROR_NO_A_RECORD" | "ERROR_ACME_CERTIFICATE_REQUEST_DEADLINE_EXCEEDED")[];
+        hostname: string;
+        id: string;
+        ips: {
+            v4: string[];
+        };
+        isDefault: boolean;
+        isDomain?: boolean | undefined;
+        isEnabled: boolean;
+        ownership: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.IngressOwnership;
+        paths: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.IngressPath[];
+        projectId: string;
+        tls: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.IngressTlsAcme | import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.IngressTlsCertificate;
+    }>;
+}, typeof Ingress]>;
+export declare class IngressCommon extends IngressCommon_base {
+    readonly baseUrl: string;
+    readonly paths: ReadonlyArray<IngressPath>;
+    readonly defaultPath: IngressPath;
+    constructor(data: IngressListItemData | IngressData);
+}
+declare const IngressDetailed_base: import("polytype").Polytype.ClusteredConstructor<[typeof IngressCommon, {
+    new (data: {
+        dnsValidationErrors: ("ERROR_UNSPECIFIED" | "ERROR_QUAD_A" | "ERROR_NO_A_RECORD" | "ERROR_ACME_CERTIFICATE_REQUEST_DEADLINE_EXCEEDED")[];
+        hostname: string;
+        id: string;
+        ips: {
+            v4: string[];
+        };
+        isDefault: boolean;
+        isDomain?: boolean | undefined;
+        isEnabled: boolean;
+        ownership: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.IngressOwnership;
+        paths: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.IngressPath[];
+        projectId: string;
+        tls: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.IngressTlsAcme | import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.IngressTlsCertificate;
+    }): DataModel<{
+        dnsValidationErrors: ("ERROR_UNSPECIFIED" | "ERROR_QUAD_A" | "ERROR_NO_A_RECORD" | "ERROR_ACME_CERTIFICATE_REQUEST_DEADLINE_EXCEEDED")[];
+        hostname: string;
+        id: string;
+        ips: {
+            v4: string[];
+        };
+        isDefault: boolean;
+        isDomain?: boolean | undefined;
+        isEnabled: boolean;
+        ownership: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.IngressOwnership;
+        paths: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.IngressPath[];
+        projectId: string;
+        tls: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.IngressTlsAcme | import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.IngressTlsCertificate;
+    }>;
+}]>;
+export declare class IngressDetailed extends IngressDetailed_base {
+    constructor(data: IngressData);
+}
+declare const IngressListItem_base: import("polytype").Polytype.ClusteredConstructor<[typeof IngressCommon, {
+    new (data: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.IngressIngress): DataModel<import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.IngressIngress>;
+}]>;
+export declare class IngressListItem extends IngressListItem_base {
+    constructor(data: IngressListItemData);
+}
+export declare class IngressListQuery extends ListQueryModel<IngressListQueryModelData> {
+    constructor(query?: IngressListQueryModelData);
+    refine(query?: IngressListQueryModelData): IngressListQuery;
+    execute: AsyncResourceVariant<() => Promise<IngressList>>;
+    getTotalCount: AsyncResourceVariant<() => Promise<number>>;
+    findOneAndOnly: AsyncResourceVariant<() => Promise<IngressListItem | undefined>>;
+}
+declare const IngressList_base: import("polytype").Polytype.ClusteredConstructor<[typeof IngressListQuery, {
+    new (items: IngressListItem[], totalCount: number): ListDataModel<IngressListItem>;
+}]>;
+export declare class IngressList extends IngressList_base {
+    constructor(query: IngressListQueryModelData, ingresses: IngressListItem[], totalCount: number);
+    getDefault(): IngressListItem;
+}
+export {};

package/dist/types/domain/Ingress/behaviors/api.d.ts

@@ -0,0 +1,3 @@
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+import { IngressBehaviors } from "./types.js";
+export declare const apiIngressBehaviors: (client: MittwaldAPIV2Client) => IngressBehaviors;

package/dist/types/domain/Ingress/behaviors/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./api.js";
+export * from "./types.js";

package/dist/types/domain/Ingress/behaviors/types.d.ts

@@ -0,0 +1,6 @@
+import { IngressListItemData, IngressData, IngressListQueryData } from "../types.js";
+import { QueryResponseData } from "../../../base/index.js";
+export interface IngressBehaviors {
+    find: (id: string) => Promise<IngressData | undefined>;
+    list: (query?: IngressListQueryData) => Promise<QueryResponseData<IngressListItemData>>;
+}

package/dist/types/domain/Ingress/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Ingress.js";
+export * from "./types.js";

package/dist/types/domain/Ingress/types.d.ts

@@ -0,0 +1,8 @@
+import { MittwaldAPIV2 } from "@mittwald/api-client";
+import { Project } from "../../project/index.js";
+export type IngressListQueryData = MittwaldAPIV2.Paths.V2Ingresses.Get.Parameters.Query;
+export type IngressListQueryModelData = Omit<IngressListQueryData, "projectId"> & {
+    project?: Project;
+};
+export type IngressData = MittwaldAPIV2.Operations.IngressGetIngress.ResponseData;
+export type IngressListItemData = MittwaldAPIV2.Operations.IngressListIngresses.ResponseData[number];

package/dist/types/domain/IngressPath/IngressPath.d.ts

@@ -0,0 +1,11 @@
+import { DataModel } from "../../base/DataModel.js";
+import { IngressPathData } from "./types.js";
+import { IngressCommon, Ingress } from "../Ingress/index.js";
+import { IngressTarget } from "../IngressTarget/IngressTarget.js";
+export declare class IngressPath extends DataModel<IngressPathData> {
+    readonly ingress: Ingress;
+    readonly path: string;
+    readonly url: URL;
+    readonly target: IngressTarget;
+    constructor(ingress: IngressCommon, data: IngressPathData);
+}

package/dist/types/domain/IngressPath/IngressPath.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/domain/IngressPath/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./IngressPath.js";
+export * from "./types.js";

package/dist/types/domain/IngressPath/types.d.ts

@@ -0,0 +1,2 @@
+import { MittwaldAPIV2 } from "@mittwald/api-client";
+export type IngressPathData = MittwaldAPIV2.Components.Schemas.IngressPath;

package/dist/types/domain/IngressTarget/IngressTarget.d.ts

@@ -0,0 +1,24 @@
+import { DataModel } from "../../base/DataModel.js";
+import { IngressUndefinedTargetData, IngressAppInstallationTargetData, IngressRedirectTargetData, IngressTargetData } from "./types.js";
+import { IngressPath } from "../IngressPath/IngressPath.js";
+import { AppInstallation } from "../../app/AppInstallation/index.js";
+declare abstract class IngressTargetBase<T extends IngressTargetData> extends DataModel<T> {
+    readonly path: IngressPath;
+    constructor(path: IngressPath, data: T);
+}
+export declare class IngressRedirectTarget extends IngressTargetBase<IngressRedirectTargetData> {
+    readonly type = "redirect";
+    readonly url: URL;
+    constructor(path: IngressPath, data: IngressRedirectTargetData);
+}
+export declare class IngressAppInstallationTarget extends IngressTargetBase<IngressAppInstallationTargetData> {
+    readonly type = "appInstallation";
+    readonly appInstallation: AppInstallation;
+    constructor(path: IngressPath, data: IngressAppInstallationTargetData);
+}
+export declare class IngressUndefinedTarget extends IngressTargetBase<IngressUndefinedTargetData> {
+    readonly type = "undefined";
+}
+export type IngressTarget = IngressRedirectTarget | IngressAppInstallationTarget | IngressUndefinedTarget;
+export declare const ingressTargetFactory: (path: IngressPath, data: IngressTargetData) => IngressTarget;
+export {};

package/dist/types/domain/IngressTarget/IngressTarget.test-types.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/domain/IngressTarget/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./IngressTarget.js";
+export * from "./types.js";

package/dist/types/domain/IngressTarget/types.d.ts

@@ -0,0 +1,6 @@
+import { MittwaldAPIV2 } from "@mittwald/api-client";
+export type IngressRedirectTargetData = MittwaldAPIV2.Components.Schemas.IngressTargetUrl;
+export type IngressAppInstallationTargetData = MittwaldAPIV2.Components.Schemas.IngressTargetInstallation;
+export type IngressContainerTargetData = MittwaldAPIV2.Components.Schemas.IngressTargetContainer;
+export type IngressUndefinedTargetData = MittwaldAPIV2.Components.Schemas.IngressTargetUseDefaultPage;
+export type IngressTargetData = IngressRedirectTargetData | IngressAppInstallationTargetData | IngressUndefinedTargetData | IngressContainerTargetData;

package/dist/types/domain/index.d.ts

@@ -0,0 +1 @@
+export * from "./Ingress/index.js";