@mittwald/api-models 0.0.0-development-74e1fd1-20240611 → 0.0.0-development-e096ee7-20240924

package/dist/esm/react/provideReact.js

@@ -0,0 +1,24 @@
+import { reactUsePromise } from "./reactUsePromise.js";
+import { hash } from "object-code";
+import { reactProvisionContext } from "./reactProvisionContext.js";
+export const provideReact = (loader, dependencies) => {
+    const provisionId = String(hash({
+        loader,
+        dependencies,
+    }));
+    const getAsyncResource = (params) => {
+        const paramsHash = params && params.length > 0 ? String(hash(params)) : "";
+        const contextId = provisionId + paramsHash;
+        const loaderWithContext = reactProvisionContext.bind({
+            id: contextId,
+        }, loader);
+        return reactUsePromise.getAsyncResource(loaderWithContext, params, {
+            loaderId: provisionId,
+            tags: [contextId],
+        });
+    };
+    return Object.assign(loader, {
+        asResource: (...params) => getAsyncResource(params),
+        use: (...params) => getAsyncResource(params).use(),
+    });
+};

package/dist/esm/react/provideReact.test-types.js

@@ -0,0 +1,21 @@
+import { provideReact } from "./provideReact.js";
+import { expectType } from "tsd";
+const reactProvided = provideReact(async (ignoredP1, ignoredP2) => Promise.resolve("foo"));
+function ignoredTestReturnTypesOfProvideReact() {
+    const usedValue = reactProvided.use("foo");
+    const asAsyncResource = reactProvided.asResource("foo");
+    expectType(usedValue);
+    expectType(asAsyncResource.use());
+}
+function ignoredTestParameterTypesOfProvideReact() {
+    reactProvided.use("foo", true);
+    reactProvided.asResource("foo", true);
+    reactProvided.use("foo");
+    reactProvided.asResource("foo");
+    // @ts-expect-error Not assignable
+    reactProvided.asResource(42);
+    // @ts-expect-error Not assignable
+    reactProvided.asResource("foo", 42);
+    // @ts-expect-error Not assignable
+    reactProvided.asResource("foo", true, 42);
+}

package/dist/esm/react/reactProvisionContext.js

@@ -0,0 +1,2 @@
+import { createCascade } from "context";
+export const reactProvisionContext = createCascade();

package/dist/esm/server/Server/Server.js

@@ -3,37 +3,51 @@ import { config } from "../../config/config.js";
 import { classes } from "polytype";
 import { DataModel } from "../../base/DataModel.js";
 import assertObjectFound from "../../base/assertObjectFound.js";
-import { Project } from "../../project/index.js";
-import { provideReact } from "../../lib/provideReact.js";
+import { Project, ProjectListQuery } from "../../project/index.js";
+import { provideReact, } from "../../react/provideReact.js";
+import { ListQueryModel } from "../../base/ListQueryModel.js";
+import { ListDataModel } from "../../base/ListDataModel.js";
 export class Server extends ReferenceModel {
+    projects;
+    constructor(id) {
+        super(id);
+        this.projects = new ProjectListQuery({
+            server: this,
+        });
+    }
+    static ofId(id) {
+        return new Server(id);
+    }
     static find = provideReact(async (id) => {
-        const serverData = await config.behaviors.server.find(id);
-        if (serverData !== undefined) {
-            return new ServerDetailed([serverData]);
+        const data = await config.behaviors.server.find(id);
+        if (data !== undefined) {
+            return new ServerDetailed(data);
         }
     });
     static get = provideReact(async (id) => {
-        const server = await ServerDetailed.find(id);
+        const server = await this.find(id);
         assertObjectFound(server, this, id);
         return server;
     });
+    static query(query = {}) {
+        return new ServerListQuery(query);
+    }
+    /** @deprecated: use query() or customer.servers */
     static list = provideReact(async (query = {}) => {
-        const projectListData = await config.behaviors.server.list(query);
-        return projectListData.map((d) => new ServerListItem([d]));
+        return new ServerListQuery(query).execute().then((r) => r.items);
     });
-    static ofId(id) {
-        return new Server(id);
-    }
     async createProject(...parameters) {
         return Project.create(this.id, ...parameters);
     }
+    /** @deprecated Use Server.projects property */
     listProjects = provideReact(async (query = {}) => {
         return Project.list({
             ...query,
             serverId: this.id,
         });
     });
-    getDetailed = provideReact(() => ServerDetailed.get(this.id));
+    getDetailed = provideReact(() => Server.get(this.id), [this.id]);
+    findDetailed = provideReact(() => Server.find(this.id), [this.id]);
 }
 // Common class for future extension
 class ServerCommon extends classes((DataModel), Server) {
@@ -41,7 +55,48 @@ class ServerCommon extends classes((DataModel), Server) {
         super([data], [data.id]);
     }
 }
+export class ServerDetailed extends classes(ServerCommon, (DataModel)) {
+    constructor(data) {
+        super([data], [data]);
+    }
+}
 export class ServerListItem extends classes(ServerCommon, (DataModel)) {
+    constructor(data) {
+        super([data], [data]);
+    }
 }
-export class ServerDetailed extends classes(ServerCommon, (DataModel)) {
+export class ServerListQuery extends ListQueryModel {
+    constructor(query = {}) {
+        super(query);
+    }
+    refine(query) {
+        return new ServerListQuery({
+            ...this.query,
+            ...query,
+        });
+    }
+    execute = provideReact(async () => {
+        const { customer, ...query } = this.query;
+        const { items, totalCount } = await config.behaviors.server.list({
+            limit: config.defaultPaginationLimit,
+            customerId: customer?.id,
+            ...query,
+        });
+        return new ServerList(this.query, items.map((d) => new ServerListItem(d)), totalCount);
+    }, [this.queryId]);
+    getTotalCount = provideReact(async () => {
+        const { totalCount } = await this.refine({ limit: 1 }).execute();
+        return totalCount;
+    }, [this.queryId]);
+    findOneAndOnly = provideReact(async () => {
+        const { items, totalCount } = await this.refine({ limit: 2 }).execute();
+        if (totalCount === 1) {
+            return items[0];
+        }
+    }, [this.queryId]);
+}
+export class ServerList extends classes(ServerListQuery, (ListDataModel)) {
+    constructor(query, servers, totalCount) {
+        super([query], [servers, totalCount]);
+    }
 }

package/dist/esm/server/Server/behaviors/api.js

@@ -1,4 +1,4 @@
-import { assertStatus, assertOneOfStatus, } from "@mittwald/api-client";
+import { assertStatus, assertOneOfStatus, extractTotalCountHeader, } from "@mittwald/api-client";
 export const apiServerBehaviors = (client) => ({
     find: async (id) => {
         const response = await client.project.getServer({
@@ -14,6 +14,9 @@ export const apiServerBehaviors = (client) => ({
             queryParameters: query,
         });
         assertStatus(response, 200);
-        return response.data;
+        return {
+            items: response.data,
+            totalCount: extractTotalCountHeader(response),
+        };
     },
 });

package/dist/types/app/AppInstallation/AppInstallation.d.ts

@@ -1,24 +1,19 @@
 import { DataModel } from "../../base/DataModel.js";
 import { ReferenceModel } from "../../base/ReferenceModel.js";
-import { AppInstallationListItemData, AppInstallationData } from "./types.js";
+import { AsyncResourceVariant } from "../../react/provideReact.js";
+import { AppInstallationData, AppInstallationListItemData, AppInstallationListQueryData } from "./types.js";
+import { ListQueryModel } from "../../base/ListQueryModel.js";
+import { ListDataModel } from "../../base/ListDataModel.js";
+import { Project } from "../../project/index.js";
 export declare class AppInstallation extends ReferenceModel {
-    static find: ((id: string) => Promise<AppInstallationDetailed | undefined>) & {
-        asResource: (id: string) => import("@mittwald/react-use-promise").AsyncResource<AppInstallationDetailed | undefined>;
-        use: (id: string) => AppInstallationDetailed | undefined;
-    };
-    static get: ((id: string) => Promise<AppInstallationDetailed>) & {
-        asResource: (id: string) => import("@mittwald/react-use-promise").AsyncResource<AppInstallationDetailed>;
-        use: (id: string) => AppInstallationDetailed;
-    };
+    static find: AsyncResourceVariant<(id: string) => Promise<AppInstallationDetailed | undefined>>;
+    static get: AsyncResourceVariant<(id: string) => Promise<AppInstallationDetailed>>;
     static ofId(id: string): AppInstallation;
-    static list: ((projectId: string, query?: import("@mittwald/api-client").MittwaldAPIV2.Paths.V2ProjectsProjectIdAppInstallations.Get.Parameters.Query | undefined) => Promise<AppInstallationListItem[]>) & {
-        asResource: (projectId: string, query?: import("@mittwald/api-client").MittwaldAPIV2.Paths.V2ProjectsProjectIdAppInstallations.Get.Parameters.Query | undefined) => import("@mittwald/react-use-promise").AsyncResource<AppInstallationListItem[]>;
-        use: (projectId: string, query?: import("@mittwald/api-client").MittwaldAPIV2.Paths.V2ProjectsProjectIdAppInstallations.Get.Parameters.Query | undefined) => AppInstallationListItem[];
-    };
-    getDetailed: (() => Promise<AppInstallationDetailed>) & {
-        asResource: () => import("@mittwald/react-use-promise").AsyncResource<AppInstallationDetailed>;
-        use: () => AppInstallationDetailed;
-    };
+    query(project: Project, query?: AppInstallationListQueryData): AppInstallationListQuery;
+    /** @deprecated: use query() or project.appInstallations */
+    static list: AsyncResourceVariant<(projectId: string, query?: AppInstallationListQueryData) => Promise<Readonly<Array<AppInstallationListItem>>>>;
+    getDetailed: AsyncResourceVariant<() => Promise<AppInstallationDetailed>>;
+    findDetailed: AsyncResourceVariant<() => Promise<AppInstallationDetailed | undefined>>;
 }
 declare const AppInstallationCommon_base: import("polytype").Polytype.ClusteredConstructor<[{
     new (data: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.AppAppInstallation | {
@@ -106,4 +101,18 @@ declare const AppInstallationListItem_base: import("polytype").Polytype.Clustere
 export declare class AppInstallationListItem extends AppInstallationListItem_base {
     constructor(data: AppInstallationListItemData);
 }
+export declare class AppInstallationListQuery extends ListQueryModel<AppInstallationListQueryData> {
+    readonly project: Project;
+    constructor(project: Project, query?: AppInstallationListQueryData);
+    refine(query: AppInstallationListQueryData): AppInstallationListQuery;
+    execute: AsyncResourceVariant<() => Promise<AppInstallationList>>;
+    getTotalCount: AsyncResourceVariant<() => Promise<number>>;
+    findOneAndOnly: AsyncResourceVariant<() => Promise<AppInstallationListItem | undefined>>;
+}
+declare const AppInstallationList_base: import("polytype").Polytype.ClusteredConstructor<[typeof AppInstallationListQuery, {
+    new (items: AppInstallationListItem[], totalCount: number): ListDataModel<AppInstallationListItem>;
+}]>;
+export declare class AppInstallationList extends AppInstallationList_base {
+    constructor(project: Project, query: AppInstallationListQueryData, appInstallations: AppInstallationListItem[], totalCount: number);
+}
 export {};

package/dist/types/app/AppInstallation/behaviors/types.d.ts

@@ -1,5 +1,6 @@
-import { AppInstallationListItemData, AppInstallationData, AppInstallationListQuery } from "../types.js";
+import { AppInstallationListItemData, AppInstallationData, AppInstallationListQueryData } from "../types.js";
+import { QueryResponseData } from "../../../base/index.js";
 export interface AppInstallationBehaviors {
     find: (id: string) => Promise<AppInstallationData | undefined>;
-    list: (projectId: string, query?: AppInstallationListQuery) => Promise<AppInstallationListItemData[]>;
+    list: (projectId: string, query?: AppInstallationListQueryData) => Promise<QueryResponseData<AppInstallationListItemData>>;
 }

package/dist/types/app/AppInstallation/types.d.ts

@@ -1,4 +1,4 @@
 import { MittwaldAPIV2 } from "@mittwald/api-client";
-export type AppInstallationListQuery = MittwaldAPIV2.Paths.V2ProjectsProjectIdAppInstallations.Get.Parameters.Query;
+export type AppInstallationListQueryData = MittwaldAPIV2.Paths.V2ProjectsProjectIdAppInstallations.Get.Parameters.Query;
 export type AppInstallationData = MittwaldAPIV2.Operations.AppGetAppinstallation.ResponseData;
 export type AppInstallationListItemData = MittwaldAPIV2.Operations.AppListAppinstallations.ResponseData[number];

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

@@ -0,0 +1,5 @@
+export declare class ListDataModel<TItem> {
+    readonly items: readonly TItem[];
+    readonly totalCount: number;
+    constructor(items: TItem[], totalCount: number);
+}

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

@@ -0,0 +1,5 @@
+export declare abstract class ListQueryModel<TQuery> {
+    protected readonly query: TQuery;
+    readonly queryId: string;
+    constructor(query: TQuery);
+}

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

@@ -1 +1,6 @@
+export * from "./assertObjectFound.js";
+export * from "./DataModel.js";
+export * from "./ReferenceModel.js";
+export * from "./ListDataModel.js";
+export * from "./ListQueryModel.js";
 export * from "./types.js";

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

@@ -1,2 +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/config.d.ts

@@ -4,6 +4,7 @@ import { CustomerBehaviors } from "../customer/Customer/behaviors/index.js";
 import { IngressBehaviors } from "../domain/Ingress/behaviors/index.js";
 import { AppInstallationBehaviors } from "../app/AppInstallation/behaviors/index.js";
 interface Config {
+    defaultPaginationLimit: number;
     behaviors: {
         project: ProjectBehaviors;
         server: ServerBehaviors;

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

@@ -1,24 +1,24 @@
 import { DataModel } from "../../base/DataModel.js";
 import { ReferenceModel } from "../../base/ReferenceModel.js";
-import { CustomerListItemData, CustomerData } from "./types.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: ((id: string) => Promise<CustomerDetailed | undefined>) & {
-        asResource: (id: string) => import("@mittwald/react-use-promise").AsyncResource<CustomerDetailed | undefined>;
-        use: (id: string) => CustomerDetailed | undefined;
-    };
-    static list: ((query?: import("@mittwald/api-client").MittwaldAPIV2.Paths.V2Customers.Get.Parameters.Query | undefined) => Promise<readonly CustomerListItem[]>) & {
-        asResource: (query?: import("@mittwald/api-client").MittwaldAPIV2.Paths.V2Customers.Get.Parameters.Query | undefined) => import("@mittwald/react-use-promise").AsyncResource<readonly CustomerListItem[]>;
-        use: (query?: import("@mittwald/api-client").MittwaldAPIV2.Paths.V2Customers.Get.Parameters.Query | undefined) => readonly CustomerListItem[];
-    };
-    static get: ((id: string) => Promise<CustomerDetailed>) & {
-        asResource: (id: string) => import("@mittwald/react-use-promise").AsyncResource<CustomerDetailed>;
-        use: (id: string) => CustomerDetailed;
-    };
-    getDetailed: (() => Promise<CustomerDetailed>) & {
-        asResource: () => import("@mittwald/react-use-promise").AsyncResource<CustomerDetailed>;
-        use: () => CustomerDetailed;
-    };
+    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 | {
@@ -38,7 +38,7 @@ declare const CustomerCommon_base: import("polytype").Polytype.ClusteredConstruc
         owner?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.CustomerContact | undefined;
         projectCount: number;
         vatId?: string | undefined;
-        vatIdValidationState?: "pending" | "unspecified" | "valid" | "invalid" | undefined;
+        vatIdValidationState?: ("valid" | "invalid" | "pending" | "unspecified") | undefined;
     }): DataModel<import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.CustomerCustomer | {
         activeSuspension?: {
             createdAt: string;
@@ -56,7 +56,7 @@ declare const CustomerCommon_base: import("polytype").Polytype.ClusteredConstruc
         owner?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.CustomerContact | undefined;
         projectCount: number;
         vatId?: string | undefined;
-        vatIdValidationState?: "pending" | "unspecified" | "valid" | "invalid" | undefined;
+        vatIdValidationState?: ("valid" | "invalid" | "pending" | "unspecified") | undefined;
     }>;
 }, typeof Customer]>;
 declare class CustomerCommon extends CustomerCommon_base {
@@ -80,7 +80,7 @@ declare const CustomerDetailed_base: import("polytype").Polytype.ClusteredConstr
         owner?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.CustomerContact | undefined;
         projectCount: number;
         vatId?: string | undefined;
-        vatIdValidationState?: "pending" | "unspecified" | "valid" | "invalid" | undefined;
+        vatIdValidationState?: ("valid" | "invalid" | "pending" | "unspecified") | undefined;
     }): DataModel<{
         activeSuspension?: {
             createdAt: string;
@@ -98,7 +98,7 @@ declare const CustomerDetailed_base: import("polytype").Polytype.ClusteredConstr
         owner?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.CustomerContact | undefined;
         projectCount: number;
         vatId?: string | undefined;
-        vatIdValidationState?: "pending" | "unspecified" | "valid" | "invalid" | undefined;
+        vatIdValidationState?: ("valid" | "invalid" | "pending" | "unspecified") | undefined;
     }>;
 }]>;
 export declare class CustomerDetailed extends CustomerDetailed_base {
@@ -110,4 +110,17 @@ declare const CustomerListItem_base: import("polytype").Polytype.ClusteredConstr
 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/types.d.ts

@@ -1,5 +1,7 @@
-import { CustomerListItemData, CustomerData, CustomerListQuery } from "../types.js";
+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?: CustomerListQuery) => Promise<CustomerListItemData[]>;
+    list: (query?: CustomerListQueryData) => Promise<QueryResponseData<CustomerListItemData>>;
+    update: (id: string, data: CustomerUpdateRequestData) => Promise<void>;
 }

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

@@ -1,4 +1,5 @@
 import { MittwaldAPIV2 } from "@mittwald/api-client";
-export type CustomerListQuery = MittwaldAPIV2.Paths.V2Customers.Get.Parameters.Query;
+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/domain/Ingress/Ingress.d.ts

@@ -1,26 +1,19 @@
 import { DataModel } from "../../base/DataModel.js";
 import { ReferenceModel } from "../../base/ReferenceModel.js";
-import { IngressListItemData, IngressData, IngressListQuery } from "./types.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;
-    static list: ((query?: IngressListQuery | undefined) => Promise<IngressListItem[]>) & {
-        asResource: (query?: IngressListQuery | undefined) => import("@mittwald/react-use-promise").AsyncResource<IngressListItem[]>;
-        use: (query?: IngressListQuery | undefined) => IngressListItem[];
-    };
-    static find: ((id: string) => Promise<IngressDetailed | undefined>) & {
-        asResource: (id: string) => import("@mittwald/react-use-promise").AsyncResource<IngressDetailed | undefined>;
-        use: (id: string) => IngressDetailed | undefined;
-    };
-    static get: ((id: string) => Promise<IngressDetailed>) & {
-        asResource: (id: string) => import("@mittwald/react-use-promise").AsyncResource<IngressDetailed>;
-        use: (id: string) => IngressDetailed;
-    };
-    getDetailed: (() => Promise<IngressDetailed>) & {
-        asResource: () => import("@mittwald/react-use-promise").AsyncResource<IngressDetailed>;
-        use: () => IngressDetailed;
-    };
+    /** @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 | {
@@ -99,4 +92,18 @@ declare const IngressListItem_base: import("polytype").Polytype.ClusteredConstru
 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/types.d.ts

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

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

@@ -1,6 +1,8 @@
 import { MittwaldAPIV2 } from "@mittwald/api-client";
-export interface IngressListQuery {
-    projectId?: string;
-}
+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];