@mittwald/api-models 0.1.0-alpha.1 → 4.10.0

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,102 @@
+import { DataModel } from "../../base/DataModel.js";
+import { ReferenceModel } from "../../base/ReferenceModel.js";
+import { IngressListItemData, IngressData, IngressListQuery } from "./types.js";
+import { IngressPath } from "../IngressPath/IngressPath.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;
+    };
+}
+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 {};

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,5 @@
+import { IngressListItemData, IngressData, IngressListQuery } from "../types.js";
+export interface IngressBehaviors {
+    find: (id: string) => Promise<IngressData | undefined>;
+    list: (query?: IngressListQuery) => Promise<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,6 @@
+import { MittwaldAPIV2 } from "@mittwald/api-client";
+export interface IngressListQuery {
+    projectId?: string;
+}
+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,29 @@
+import { DataModel } from "../../base/DataModel.js";
+import { IngressUndefinedTargetData, IngressDirectoryTargetData, 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 IngressDirectoryTarget extends IngressTargetBase<IngressDirectoryTargetData> {
+    readonly type = "directory";
+    readonly directory: string;
+    constructor(path: IngressPath, data: IngressDirectoryTargetData);
+}
+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 | IngressDirectoryTarget | 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 IngressDirectoryTargetData = MittwaldAPIV2.Components.Schemas.IngressTargetDirectory;
+export type IngressAppInstallationTargetData = MittwaldAPIV2.Components.Schemas.IngressTargetInstallation;
+export type IngressUndefinedTargetData = MittwaldAPIV2.Components.Schemas.IngressTargetUseDefaultPage;
+export type IngressTargetData = IngressRedirectTargetData | IngressDirectoryTargetData | IngressAppInstallationTargetData | IngressUndefinedTargetData;

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

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

package/dist/types/errors/ObjectNotFoundError.d.ts

@@ -0,0 +1,3 @@
+export default class ObjectNotFoundError extends Error {
+    constructor(type: string, refName: string);
+}

package/dist/types/index.d.ts

@@ -0,0 +1,7 @@
+export { MittwaldAPIV2Client } from "@mittwald/api-client";
+export * from "./config/index.js";
+export * from "./project/index.js";
+export * from "./server/index.js";
+export * from "./domain/index.js";
+export * from "./customer/index.js";
+export * from "./base/index.js";

package/dist/types/lib/deepFreeze.d.ts

@@ -0,0 +1,5 @@
+import type { ReadonlyDeep } from "type-fest";
+export type { ReadonlyDeep } from "type-fest";
+type DeepFreeze = <T>(subject: T) => ReadonlyDeep<T>;
+declare const deepFreeze: DeepFreeze;
+export default deepFreeze;

package/dist/types/lib/provideReact.d.ts

@@ -0,0 +1,11 @@
+import { AsyncResource } from "../react/reactUsePromise.js";
+type FnParameters = unknown[];
+type AsyncFn<TResult, TParams extends FnParameters> = (...args: TParams) => Promise<TResult>;
+export declare const provideReact: <TValue, TParams extends FnParameters>(loader: AsyncFn<TValue, TParams>) => AsyncResourceVariant<TValue, TParams>;
+export type AsyncResourceVariant<TValue, TParams extends FnParameters> = TParams extends null ? AsyncFn<TValue, TParams> & {
+    asResource: () => AsyncResource<TValue>;
+} : AsyncFn<TValue, TParams> & {
+    asResource: (...params: TParams) => AsyncResource<TValue>;
+    use: (...params: TParams) => TValue;
+};
+export {};

package/dist/types/lib/types.d.ts

@@ -0,0 +1,2 @@
+export type ParamsExceptFirst<T extends (...args: any) => any> = T extends (ignoredFirst: any, ...args: infer P) => any ? P : never;
+export type FirstParameter<T extends (...args: any) => any> = T extends (first: infer P, ...args: any[]) => any ? P : never;

package/dist/types/project/Project/Project.d.ts

@@ -0,0 +1,230 @@
+import { ProjectListItemData, ProjectData } from "./types.js";
+import { DataModel } from "../../base/DataModel.js";
+import { Server } from "../../server/index.js";
+import { Customer } from "../../customer/Customer/Customer.js";
+import { ReferenceModel } from "../../base/ReferenceModel.js";
+import { IngressListItem } from "../../domain/index.js";
+export declare class Project extends ReferenceModel {
+    static ofId(id: string): Project;
+    static find: ((id: string) => Promise<ProjectDetailed | undefined>) & {
+        asResource: (id: string) => import("@mittwald/react-use-promise").AsyncResource<ProjectDetailed | undefined>;
+        use: (id: string) => ProjectDetailed | undefined;
+    };
+    static get: ((id: string) => Promise<ProjectDetailed>) & {
+        asResource: (id: string) => import("@mittwald/react-use-promise").AsyncResource<ProjectDetailed>;
+        use: (id: string) => ProjectDetailed;
+    };
+    static list: ((query?: import("@mittwald/api-client").MittwaldAPIV2.Paths.V2Projects.Get.Parameters.Query | undefined) => Promise<readonly ProjectListItem[]>) & {
+        asResource: (query?: import("@mittwald/api-client").MittwaldAPIV2.Paths.V2Projects.Get.Parameters.Query | undefined) => import("@mittwald/react-use-promise").AsyncResource<readonly ProjectListItem[]>;
+        use: (query?: import("@mittwald/api-client").MittwaldAPIV2.Paths.V2Projects.Get.Parameters.Query | undefined) => readonly ProjectListItem[];
+    };
+    static create(serverId: string, description: string): Promise<Project>;
+    getDetailed: (() => Promise<ProjectDetailed>) & {
+        asResource: () => import("@mittwald/react-use-promise").AsyncResource<ProjectDetailed>;
+        use: () => ProjectDetailed;
+    };
+    listIngresses: (() => Promise<IngressListItem[]>) & {
+        asResource: () => import("@mittwald/react-use-promise").AsyncResource<IngressListItem[]>;
+        use: () => IngressListItem[];
+    };
+    getDefaultIngress: (() => Promise<IngressListItem>) & {
+        asResource: () => import("@mittwald/react-use-promise").AsyncResource<IngressListItem>;
+        use: () => IngressListItem;
+    };
+    updateDescription(description: string): Promise<void>;
+    leave(): Promise<void>;
+    delete(): Promise<void>;
+}
+declare const ProjectCommon_base: import("polytype").Polytype.ClusteredConstructor<[{
+    new (data: {
+        clusterDomain?: string | undefined;
+        clusterID?: string | undefined;
+        createdAt: string;
+        customerId: string;
+        description: string;
+        directories: {
+            [k: string]: string;
+        };
+        disableReason?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectDisableReason | undefined;
+        disabledAt?: string | undefined;
+        enabled: boolean;
+        id: string;
+        imageRefId?: string | undefined;
+        isReady: boolean;
+        projectHostingId?: string | undefined;
+        readiness: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectDeprecatedProjectReadinessStatus;
+        serverId?: string | undefined;
+        serverShortId?: string | undefined;
+        shortId: string;
+        spec?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectHardwareSpec | import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectVisitorSpec | undefined;
+        statisticsBaseDomain?: string | undefined;
+        status: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectProjectStatus;
+        statusSetAt: string;
+    } | {
+        createdAt: string;
+        customerId: string;
+        customerMeta: {
+            id: string;
+        };
+        description: string;
+        disableReason?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectDisableReason | undefined;
+        disabledAt?: string | undefined;
+        enabled: boolean;
+        id: string;
+        imageRefId?: string | undefined;
+        isReady: boolean;
+        projectHostingId?: string | undefined;
+        readiness: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectDeprecatedProjectReadinessStatus;
+        serverId?: string | undefined;
+        shortId: string;
+        status: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectProjectStatus;
+        statusSetAt: string;
+    }): DataModel<{
+        clusterDomain?: string | undefined;
+        clusterID?: string | undefined;
+        createdAt: string;
+        customerId: string;
+        description: string;
+        directories: {
+            [k: string]: string;
+        };
+        disableReason?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectDisableReason | undefined;
+        disabledAt?: string | undefined;
+        enabled: boolean;
+        id: string;
+        imageRefId?: string | undefined;
+        isReady: boolean;
+        projectHostingId?: string | undefined;
+        readiness: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectDeprecatedProjectReadinessStatus;
+        serverId?: string | undefined;
+        serverShortId?: string | undefined;
+        shortId: string;
+        spec?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectHardwareSpec | import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectVisitorSpec | undefined;
+        statisticsBaseDomain?: string | undefined;
+        status: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectProjectStatus;
+        statusSetAt: string;
+    } | {
+        createdAt: string;
+        customerId: string;
+        customerMeta: {
+            id: string;
+        };
+        description: string;
+        disableReason?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectDisableReason | undefined;
+        disabledAt?: string | undefined;
+        enabled: boolean;
+        id: string;
+        imageRefId?: string | undefined;
+        isReady: boolean;
+        projectHostingId?: string | undefined;
+        readiness: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectDeprecatedProjectReadinessStatus;
+        serverId?: string | undefined;
+        shortId: string;
+        status: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectProjectStatus;
+        statusSetAt: string;
+    }>;
+}, typeof Project]>;
+declare class ProjectCommon extends ProjectCommon_base {
+    readonly server: Server | undefined;
+    readonly customer: Customer;
+    constructor(data: ProjectListItemData | ProjectData);
+}
+declare const ProjectDetailed_base: import("polytype").Polytype.ClusteredConstructor<[typeof ProjectCommon, {
+    new (data: {
+        clusterDomain?: string | undefined;
+        clusterID?: string | undefined;
+        createdAt: string;
+        customerId: string;
+        description: string;
+        directories: {
+            [k: string]: string;
+        };
+        disableReason?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectDisableReason | undefined;
+        disabledAt?: string | undefined;
+        enabled: boolean;
+        id: string;
+        imageRefId?: string | undefined;
+        isReady: boolean;
+        projectHostingId?: string | undefined;
+        readiness: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectDeprecatedProjectReadinessStatus;
+        serverId?: string | undefined;
+        serverShortId?: string | undefined;
+        shortId: string;
+        spec?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectHardwareSpec | import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectVisitorSpec | undefined;
+        statisticsBaseDomain?: string | undefined;
+        status: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectProjectStatus;
+        statusSetAt: string;
+    }): DataModel<{
+        clusterDomain?: string | undefined;
+        clusterID?: string | undefined;
+        createdAt: string;
+        customerId: string;
+        description: string;
+        directories: {
+            [k: string]: string;
+        };
+        disableReason?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectDisableReason | undefined;
+        disabledAt?: string | undefined;
+        enabled: boolean;
+        id: string;
+        imageRefId?: string | undefined;
+        isReady: boolean;
+        projectHostingId?: string | undefined;
+        readiness: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectDeprecatedProjectReadinessStatus;
+        serverId?: string | undefined;
+        serverShortId?: string | undefined;
+        shortId: string;
+        spec?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectHardwareSpec | import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectVisitorSpec | undefined;
+        statisticsBaseDomain?: string | undefined;
+        status: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectProjectStatus;
+        statusSetAt: string;
+    }>;
+}]>;
+export declare class ProjectDetailed extends ProjectDetailed_base {
+    constructor(data: ProjectData);
+}
+declare const ProjectListItem_base: import("polytype").Polytype.ClusteredConstructor<[typeof ProjectCommon, {
+    new (data: {
+        createdAt: string;
+        customerId: string;
+        customerMeta: {
+            id: string;
+        };
+        description: string;
+        disableReason?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectDisableReason | undefined;
+        disabledAt?: string | undefined;
+        enabled: boolean;
+        id: string;
+        imageRefId?: string | undefined;
+        isReady: boolean;
+        projectHostingId?: string | undefined;
+        readiness: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectDeprecatedProjectReadinessStatus;
+        serverId?: string | undefined;
+        shortId: string;
+        status: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectProjectStatus;
+        statusSetAt: string;
+    }): DataModel<{
+        createdAt: string;
+        customerId: string;
+        customerMeta: {
+            id: string;
+        };
+        description: string;
+        disableReason?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectDisableReason | undefined;
+        disabledAt?: string | undefined;
+        enabled: boolean;
+        id: string;
+        imageRefId?: string | undefined;
+        isReady: boolean;
+        projectHostingId?: string | undefined;
+        readiness: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectDeprecatedProjectReadinessStatus;
+        serverId?: string | undefined;
+        shortId: string;
+        status: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectProjectStatus;
+        statusSetAt: string;
+    }>;
+}]>;
+export declare class ProjectListItem extends ProjectListItem_base {
+    constructor(data: ProjectListItemData);
+}
+export {};

package/dist/types/project/Project/behaviors/api.d.ts

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

package/dist/types/project/Project/behaviors/inMem.d.ts

@@ -0,0 +1,3 @@
+import { ProjectBehaviors } from "./types.js";
+import { ProjectData } from "../types.js";
+export declare const inMemProjectBehaviors: (store: Map<string, ProjectData>) => ProjectBehaviors;

package/dist/types/project/Project/behaviors/index.d.ts

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

package/dist/types/project/Project/behaviors/types.d.ts

@@ -0,0 +1,11 @@
+import { ProjectListItemData, ProjectData, ProjectListQuery } from "../types.js";
+export interface ProjectBehaviors {
+    find: (id: string) => Promise<ProjectData | undefined>;
+    list: (query?: ProjectListQuery) => Promise<ProjectListItemData[]>;
+    create: (serverId: string, description: string) => Promise<{
+        id: string;
+    }>;
+    leave: (projectId: string) => Promise<void>;
+    delete: (projectId: string) => Promise<void>;
+    updateDescription: (projectId: string, description: string) => Promise<void>;
+}

package/dist/types/project/Project/index.d.ts

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

package/dist/types/project/Project/types.d.ts

@@ -0,0 +1,4 @@
+import { MittwaldAPIV2 } from "@mittwald/api-client";
+export type ProjectListQuery = MittwaldAPIV2.Paths.V2Projects.Get.Parameters.Query;
+export type ProjectData = MittwaldAPIV2.Operations.ProjectGetProject.ResponseData;
+export type ProjectListItemData = MittwaldAPIV2.Operations.ProjectListProjects.ResponseData[number];

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

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

package/dist/types/react/MittwaldApiModelProvider.d.ts

@@ -0,0 +1,2 @@
+import { FC, PropsWithChildren } from "react";
+export declare const MittwaldApiModelProvider: FC<PropsWithChildren>;

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

@@ -0,0 +1,4 @@
+export * from "./MittwaldApiModelProvider.js";
+export * from "./reactUsePromise.js";
+export { type AsyncResourceVariant } from "../lib/provideReact.js";
+export { provideReact } from "../lib/provideReact.js";

package/dist/types/react/reactUsePromise.d.ts

@@ -0,0 +1 @@
+export type { AsyncResource, getAsyncResource, } from "@mittwald/react-use-promise";

package/dist/types/react.d.ts

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

package/dist/types/server/Server/Server.d.ts

@@ -0,0 +1,72 @@
+import { ReferenceModel } from "../../base/ReferenceModel.js";
+import { ServerListItemData, ServerData } from "./types.js";
+import { DataModel } from "../../base/DataModel.js";
+import { Project } from "../../project/index.js";
+import { ParamsExceptFirst } from "../../lib/types.js";
+export declare class Server extends ReferenceModel {
+    static find: ((id: string) => Promise<Server | undefined>) & {
+        asResource: (id: string) => import("@mittwald/react-use-promise").AsyncResource<Server | undefined>;
+        use: (id: string) => Server | undefined;
+    };
+    static get: ((id: string) => Promise<Server>) & {
+        asResource: (id: string) => import("@mittwald/react-use-promise").AsyncResource<Server>;
+        use: (id: string) => Server;
+    };
+    static list: ((query?: import("@mittwald/api-client").MittwaldAPIV2.Paths.V2Servers.Get.Parameters.Query | undefined) => Promise<ServerListItem[]>) & {
+        asResource: (query?: import("@mittwald/api-client").MittwaldAPIV2.Paths.V2Servers.Get.Parameters.Query | undefined) => import("@mittwald/react-use-promise").AsyncResource<ServerListItem[]>;
+        use: (query?: import("@mittwald/api-client").MittwaldAPIV2.Paths.V2Servers.Get.Parameters.Query | undefined) => ServerListItem[];
+    };
+    static ofId(id: string): Server;
+    createProject(...parameters: ParamsExceptFirst<typeof Project.create>): ReturnType<typeof Project.create>;
+    listProjects: ((query?: Omit<import("@mittwald/api-client").MittwaldAPIV2.Paths.V2Projects.Get.Parameters.Query | undefined, "serverId"> | undefined) => Promise<readonly import("../../project/index.js").ProjectListItem[]>) & {
+        asResource: (query?: Omit<import("@mittwald/api-client").MittwaldAPIV2.Paths.V2Projects.Get.Parameters.Query | undefined, "serverId"> | undefined) => import("@mittwald/react-use-promise").AsyncResource<readonly import("../../project/index.js").ProjectListItem[]>;
+        use: (query?: Omit<import("@mittwald/api-client").MittwaldAPIV2.Paths.V2Projects.Get.Parameters.Query | undefined, "serverId"> | undefined) => readonly import("../../project/index.js").ProjectListItem[];
+    };
+    getDetailed: (() => Promise<ServerDetailed>) & {
+        asResource: () => import("@mittwald/react-use-promise").AsyncResource<ServerDetailed>;
+        use: () => ServerDetailed;
+    };
+}
+declare const ServerCommon_base: import("polytype").Polytype.ClusteredConstructor<[{
+    new (data: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectServer | {
+        clusterName: string;
+        createdAt: string;
+        customerId: string;
+        description: string;
+        disabledReason?: "suspended" | undefined;
+        id: string;
+        imageRefId?: string | undefined;
+        isReady: boolean;
+        machineType: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectMachineType;
+        readiness: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectDeprecatedServerReadinessStatus;
+        shortId: string;
+        statisticsBaseDomain?: string | undefined;
+        status: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectServerStatus;
+        storage: string;
+    }): DataModel<import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectServer | {
+        clusterName: string;
+        createdAt: string;
+        customerId: string;
+        description: string;
+        disabledReason?: "suspended" | undefined;
+        id: string;
+        imageRefId?: string | undefined;
+        isReady: boolean;
+        machineType: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectMachineType;
+        readiness: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectDeprecatedServerReadinessStatus;
+        shortId: string;
+        statisticsBaseDomain?: string | undefined;
+        status: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectServerStatus;
+        storage: string;
+    }>;
+}, typeof Server]>;
+declare class ServerCommon extends ServerCommon_base {
+    constructor(data: ServerListItemData | ServerData);
+}
+declare const ServerListItem_base: import("polytype").Polytype.ClusteredConstructor<[typeof ServerCommon, typeof DataModel<ServerListItemData>]>;
+export declare class ServerListItem extends ServerListItem_base {
+}
+declare const ServerDetailed_base: import("polytype").Polytype.ClusteredConstructor<[typeof ServerCommon, typeof DataModel<ServerData>]>;
+export declare class ServerDetailed extends ServerDetailed_base {
+}
+export {};

package/dist/types/server/Server/behaviors/api.d.ts

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

package/dist/types/server/Server/behaviors/index.d.ts

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

package/dist/types/server/Server/behaviors/types.d.ts

@@ -0,0 +1,5 @@
+import { ServerListItemData, ServerData, ServerListQuery } from "../types.js";
+export interface ServerBehaviors {
+    find: (id: string) => Promise<ServerData | undefined>;
+    list: (query?: ServerListQuery) => Promise<ServerListItemData[]>;
+}

package/dist/types/server/Server/index.d.ts

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

package/dist/types/server/Server/types.d.ts

@@ -0,0 +1,4 @@
+import { MittwaldAPIV2 } from "@mittwald/api-client";
+export type ServerListQuery = MittwaldAPIV2.Paths.V2Servers.Get.Parameters.Query;
+export type ServerData = MittwaldAPIV2.Operations.ProjectGetServer.ResponseData;
+export type ServerListItemData = MittwaldAPIV2.Operations.ProjectListServers.ResponseData[number];

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

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