@mittwald/api-models 4.338.1 → 4.339.0

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";

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/joinedId.d.ts

@@ -0,0 +1 @@
+export declare const joinedId: (...parts: Array<number | string>) => string;

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

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

package/dist/types/marketplace/Contributor/Contributor.d.ts

@@ -0,0 +1,49 @@
+import { DataModel } from "../../base/DataModel.js";
+import { ReferenceModel } from "../../base/ReferenceModel.js";
+import { AsyncResourceVariant } from "../../react/provideReact.js";
+import { ListQueryModel } from "../../base/ListQueryModel.js";
+import { ListDataModel } from "../../base/ListDataModel.js";
+import { ContributorIncomingInvoiceListQuery } from "./ContributorIncomingInvoice.js";
+import type { ContributorData, ContributorListItemData, ContributorListQueryData } from "./types.js";
+export declare class Contributor extends ReferenceModel {
+    readonly incomingInvoices: ContributorIncomingInvoiceListQuery;
+    constructor(id: string);
+    static ofId(id: string): Contributor;
+    static find: AsyncResourceVariant<(id: string) => Promise<ContributorDetailed | undefined>>;
+    static query(query?: ContributorListQueryData): ContributorListQuery;
+    static get: AsyncResourceVariant<(id: string) => Promise<ContributorDetailed>>;
+    getDetailed: AsyncResourceVariant<() => Promise<ContributorDetailed>>;
+    findDetailed: AsyncResourceVariant<() => Promise<ContributorDetailed | undefined>>;
+}
+declare const ContributorCommon_base: import("polytype").Polytype.ClusteredConstructor<[{
+    new (data: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.MarketplaceContributor): DataModel<import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.MarketplaceContributor>;
+}, typeof Contributor]>;
+declare class ContributorCommon extends ContributorCommon_base {
+    constructor(data: ContributorListItemData | ContributorData);
+}
+declare const ContributorDetailed_base: import("polytype").Polytype.ClusteredConstructor<[typeof ContributorCommon, {
+    new (data: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.MarketplaceContributor): DataModel<import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.MarketplaceContributor>;
+}]>;
+export declare class ContributorDetailed extends ContributorDetailed_base {
+    constructor(data: ContributorData);
+}
+declare const ContributorListItem_base: import("polytype").Polytype.ClusteredConstructor<[typeof ContributorCommon, {
+    new (data: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.MarketplaceContributor): DataModel<import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.MarketplaceContributor>;
+}]>;
+export declare class ContributorListItem extends ContributorListItem_base {
+    constructor(data: ContributorListItemData);
+}
+export declare class ContributorListQuery extends ListQueryModel<ContributorListQueryData> {
+    constructor(query?: ContributorListQueryData);
+    refine(query: ContributorListQueryData): ContributorListQuery;
+    execute: AsyncResourceVariant<() => Promise<ContributorList>>;
+    getTotalCount: AsyncResourceVariant<() => Promise<number>>;
+    findOneAndOnly: AsyncResourceVariant<() => Promise<ContributorListItem | undefined>>;
+}
+declare const ContributorList_base: import("polytype").Polytype.ClusteredConstructor<[typeof ContributorListQuery, {
+    new (items: ContributorListItem[], totalCount: number): ListDataModel<ContributorListItem>;
+}]>;
+export declare class ContributorList extends ContributorList_base {
+    constructor(query: ContributorListQueryData, contributors: ContributorListItem[], totalCount: number);
+}
+export {};

package/dist/types/marketplace/Contributor/ContributorIncomingInvoice.d.ts

@@ -0,0 +1,31 @@
+import { ListQueryModel } from "../../base/ListQueryModel.js";
+import { Money } from "../../base/Money.js";
+import { DateTime } from "luxon";
+import type { Contributor } from "./Contributor.js";
+import type { ContributorIncomingInvoiceData, ContributorListIncomingInvoiceQueryData } from "./types.js";
+import { ListDataModel } from "../../base/ListDataModel.js";
+import { DataModel } from "../../base/DataModel.js";
+export declare class ContributorIncomingInvoice extends DataModel<ContributorIncomingInvoiceData> {
+    readonly contributor: Contributor;
+    readonly id: string;
+    readonly pdfId: string;
+    readonly invoiceNumber: string;
+    readonly date: DateTime;
+    readonly totalNet: Money;
+    readonly totalGross: Money;
+    constructor(contributor: Contributor, data: ContributorIncomingInvoiceData);
+}
+export declare class ContributorIncomingInvoiceListQuery extends ListQueryModel<ContributorListIncomingInvoiceQueryData> {
+    readonly contributor: Contributor;
+    constructor(contributor: Contributor, query?: ContributorListIncomingInvoiceQueryData);
+    refine(query: ContributorListIncomingInvoiceQueryData): ContributorIncomingInvoiceListQuery;
+    execute: import("../../react.js").AsyncResourceVariant<() => Promise<ContributorIncomingInvoicesList>>;
+    getTotalCount: import("../../react.js").AsyncResourceVariant<() => Promise<number>>;
+}
+declare const ContributorIncomingInvoicesList_base: import("polytype").Polytype.ClusteredConstructor<[typeof ContributorIncomingInvoiceListQuery, {
+    new (items: ContributorIncomingInvoice[], totalCount: number): ListDataModel<ContributorIncomingInvoice>;
+}]>;
+export declare class ContributorIncomingInvoicesList extends ContributorIncomingInvoicesList_base {
+    constructor(contributor: Contributor, query: ContributorListIncomingInvoiceQueryData, invoices: ContributorIncomingInvoice[], totalCount: number);
+}
+export {};

package/dist/types/marketplace/Contributor/behaviors/api.d.ts

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

package/dist/types/marketplace/Contributor/behaviors/index.d.ts

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

package/dist/types/marketplace/Contributor/behaviors/types.d.ts

@@ -0,0 +1,10 @@
+import type { QueryResponseData } from "../../../base/types.js";
+import type { ContributorData, ContributorIncomingInvoiceData, ContributorListIncomingInvoiceQueryData, ContributorListItemData, ContributorListQueryData } from "../types.js";
+export interface ContributorBehaviors {
+    find: (contributorId: string) => Promise<ContributorData | undefined>;
+    list: (query?: ContributorListQueryData) => Promise<QueryResponseData<ContributorListItemData>>;
+    listIncomingInvoices: (contributorId: string, queryParameters?: ContributorListIncomingInvoiceQueryData) => Promise<{
+        items: ContributorIncomingInvoiceData[];
+        totalCount: number;
+    }>;
+}

package/dist/types/marketplace/Contributor/index.d.ts

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

package/dist/types/marketplace/Contributor/types.d.ts

@@ -0,0 +1,6 @@
+import type { MittwaldAPIV2 } from "@mittwald/api-client";
+export type ContributorData = MittwaldAPIV2.Components.Schemas.MarketplaceContributor;
+export type ContributorListItemData = MittwaldAPIV2.Operations.ExtensionListContributors.ResponseData[number];
+export type ContributorListQueryData = MittwaldAPIV2.Paths.V2Contributors.Get.Parameters.Query;
+export type ContributorIncomingInvoiceData = MittwaldAPIV2.Operations.ContributorListIncomingInvoices.ResponseData[number];
+export type ContributorListIncomingInvoiceQueryData = MittwaldAPIV2.Paths.V2ContributorsContributorIdInvoicesIncoming.Get.Parameters.Query;

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

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