@solibo/home-api 1.15.9 → 1.15.11

package/solibo-sdk-sdk-home-api.d.mts

@@ -392,6 +392,37 @@ export declare namespace AdHocInvoiceLinesUpdateInputCommand {
         const constructor: abstract new () => AdHocInvoiceLinesUpdateInputCommand;
     }
 }
+export declare class AdHocSettlementInvoiceItem {
+    constructor(at: Nullable<bigint> | undefined, companyId: bigint, ids?: Nullable<KtList<bigint>>);
+    get at(): Nullable<bigint>;
+    get companyId(): bigint;
+    get ids(): Nullable<KtList<bigint>>;
+    copy(at?: Nullable<bigint>, companyId?: bigint, ids?: Nullable<KtList<bigint>>): AdHocSettlementInvoiceItem;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace AdHocSettlementInvoiceItem {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AdHocSettlementInvoiceItem;
+    }
+}
+export declare class AdHocSettlementInvoiceListCommand {
+    constructor(items: KtList<AdHocSettlementInvoiceItem>, provider: SettlementProvider);
+    get items(): KtList<AdHocSettlementInvoiceItem>;
+    get provider(): SettlementProvider;
+    copy(items?: KtList<AdHocSettlementInvoiceItem>, provider?: SettlementProvider): AdHocSettlementInvoiceListCommand;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace AdHocSettlementInvoiceListCommand {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AdHocSettlementInvoiceListCommand;
+    }
+}
 export declare class AddAgreementDocumentToInsuranceCommand {
     constructor(documentId: bigint);
     get documentId(): bigint;
@@ -482,6 +513,243 @@ export declare namespace AddressSpecifics {
         const constructor: abstract new () => AddressSpecifics;
     }
 }
+export declare class AltinnCommonActor {
+    constructor(actorId?: Nullable<string>, actorName?: Nullable<string>, actorType?: Nullable<string>);
+    get actorId(): Nullable<string>;
+    get actorName(): Nullable<string>;
+    get actorType(): Nullable<string>;
+    copy(actorId?: Nullable<string>, actorName?: Nullable<string>, actorType?: Nullable<string>): AltinnCommonActor;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace AltinnCommonActor {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AltinnCommonActor;
+    }
+}
+export declare class AltinnCommonContent {
+    constructor(mediaType?: Nullable<string>, value?: Nullable<KtList<AltinnCommonLocalization>>);
+    get mediaType(): Nullable<string>;
+    get value(): Nullable<KtList<AltinnCommonLocalization>>;
+    copy(mediaType?: Nullable<string>, value?: Nullable<KtList<AltinnCommonLocalization>>): AltinnCommonContent;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace AltinnCommonContent {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AltinnCommonContent;
+    }
+}
+export declare class AltinnCommonLocalization {
+    constructor(languageCode: string, value: string);
+    get languageCode(): string;
+    get value(): string;
+    copy(languageCode?: string, value?: string): AltinnCommonLocalization;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace AltinnCommonLocalization {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AltinnCommonLocalization;
+    }
+}
+export declare class AltinnDialog {
+    constructor(content?: Nullable<DialogSearchContent>, contentUpdatedAt?: Nullable<Instant>, createdAt?: Nullable<Instant>, dueAt?: Nullable<Instant>, endUserContext?: Nullable<DialogEndUserContext>, extendedStatus?: Nullable<string>, externalReference?: Nullable<string>, fromPartyTransmissionsCount?: Nullable<bigint>, fromServiceOwnerTransmissionsCount?: Nullable<bigint>, guiAttachmentCount?: Nullable<bigint>, hasUnopenedContent?: Nullable<boolean>, id?: Nullable<string>, isApiOnly?: Nullable<boolean>, latestActivity?: Nullable<DialogActivity>, org?: Nullable<string>, party?: Nullable<string>, precedingProcess?: Nullable<string>, process?: Nullable<string>, progress?: Nullable<bigint>, seenSinceLastContentUpdate?: Nullable<KtList<DialogSeenLog>>, seenSinceLastUpdate?: Nullable<KtList<DialogSeenLog>>, serviceResource?: Nullable<string>, serviceResourceType?: Nullable<string>, status?: Nullable<DialogStatus>, systemLabel?: Nullable<DialogSystemLabel>, updatedAt?: Nullable<Instant>);
+    get content(): Nullable<DialogSearchContent>;
+    get contentUpdatedAt(): Nullable<Instant>;
+    get createdAt(): Nullable<Instant>;
+    get dueAt(): Nullable<Instant>;
+    get endUserContext(): Nullable<DialogEndUserContext>;
+    get extendedStatus(): Nullable<string>;
+    get externalReference(): Nullable<string>;
+    get fromPartyTransmissionsCount(): Nullable<bigint>;
+    get fromServiceOwnerTransmissionsCount(): Nullable<bigint>;
+    get guiAttachmentCount(): Nullable<bigint>;
+    get hasUnopenedContent(): Nullable<boolean>;
+    get id(): Nullable<string>;
+    get isApiOnly(): Nullable<boolean>;
+    get latestActivity(): Nullable<DialogActivity>;
+    get org(): Nullable<string>;
+    get party(): Nullable<string>;
+    get precedingProcess(): Nullable<string>;
+    get process(): Nullable<string>;
+    get progress(): Nullable<bigint>;
+    get seenSinceLastContentUpdate(): Nullable<KtList<DialogSeenLog>>;
+    get seenSinceLastUpdate(): Nullable<KtList<DialogSeenLog>>;
+    get serviceResource(): Nullable<string>;
+    get serviceResourceType(): Nullable<string>;
+    get status(): Nullable<DialogStatus>;
+    get systemLabel(): Nullable<DialogSystemLabel>;
+    get updatedAt(): Nullable<Instant>;
+    copy(content?: Nullable<DialogSearchContent>, contentUpdatedAt?: Nullable<Instant>, createdAt?: Nullable<Instant>, dueAt?: Nullable<Instant>, endUserContext?: Nullable<DialogEndUserContext>, extendedStatus?: Nullable<string>, externalReference?: Nullable<string>, fromPartyTransmissionsCount?: Nullable<bigint>, fromServiceOwnerTransmissionsCount?: Nullable<bigint>, guiAttachmentCount?: Nullable<bigint>, hasUnopenedContent?: Nullable<boolean>, id?: Nullable<string>, isApiOnly?: Nullable<boolean>, latestActivity?: Nullable<DialogActivity>, org?: Nullable<string>, party?: Nullable<string>, precedingProcess?: Nullable<string>, process?: Nullable<string>, progress?: Nullable<bigint>, seenSinceLastContentUpdate?: Nullable<KtList<DialogSeenLog>>, seenSinceLastUpdate?: Nullable<KtList<DialogSeenLog>>, serviceResource?: Nullable<string>, serviceResourceType?: Nullable<string>, status?: Nullable<DialogStatus>, systemLabel?: Nullable<DialogSystemLabel>, updatedAt?: Nullable<Instant>): AltinnDialog;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace AltinnDialog {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AltinnDialog;
+    }
+}
+export declare class AltinnDialogList {
+    constructor(continuationToken?: Nullable<string>, hasNextPage?: Nullable<boolean>, items?: Nullable<KtList<AltinnDialog>>, orderBy?: Nullable<string>);
+    get continuationToken(): Nullable<string>;
+    get hasNextPage(): Nullable<boolean>;
+    get items(): Nullable<KtList<AltinnDialog>>;
+    get orderBy(): Nullable<string>;
+    copy(continuationToken?: Nullable<string>, hasNextPage?: Nullable<boolean>, items?: Nullable<KtList<AltinnDialog>>, orderBy?: Nullable<string>): AltinnDialogList;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace AltinnDialogList {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AltinnDialogList;
+    }
+}
+export declare class AltinnSystemAccessPackages {
+    constructor(urn: string);
+    get urn(): string;
+    copy(urn?: string): AltinnSystemAccessPackages;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace AltinnSystemAccessPackages {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AltinnSystemAccessPackages;
+    }
+}
+export declare class AltinnSystemDescription {
+    constructor(en?: Nullable<string>, nb?: Nullable<string>, nn?: Nullable<string>);
+    get en(): Nullable<string>;
+    get nb(): Nullable<string>;
+    get nn(): Nullable<string>;
+    copy(en?: Nullable<string>, nb?: Nullable<string>, nn?: Nullable<string>): AltinnSystemDescription;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace AltinnSystemDescription {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AltinnSystemDescription;
+    }
+}
+export declare class AltinnSystemName {
+    constructor(en?: Nullable<string>, nb?: Nullable<string>, nn?: Nullable<string>);
+    get en(): Nullable<string>;
+    get nb(): Nullable<string>;
+    get nn(): Nullable<string>;
+    copy(en?: Nullable<string>, nb?: Nullable<string>, nn?: Nullable<string>): AltinnSystemName;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace AltinnSystemName {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AltinnSystemName;
+    }
+}
+export declare class AltinnSystemRegisterInput {
+    constructor(accessPackages: Nullable<KtList<AltinnSystemAccessPackages>> | undefined, allowedRedirectUrls: Nullable<KtList<string>> | undefined, clientId: KtList<string>, description?: Nullable<AltinnSystemDescription>, id?: Nullable<string>, isDeleted?: Nullable<boolean>, isVisible?: Nullable<boolean>, name?: Nullable<AltinnSystemName>, rights?: Nullable<KtList<AltinnSystemRights>>, vendor?: Nullable<AltinnSystemVendor>);
+    get accessPackages(): Nullable<KtList<AltinnSystemAccessPackages>>;
+    get allowedRedirectUrls(): Nullable<KtList<string>>;
+    get clientId(): KtList<string>;
+    get description(): Nullable<AltinnSystemDescription>;
+    get id(): Nullable<string>;
+    get isDeleted(): Nullable<boolean>;
+    get isVisible(): Nullable<boolean>;
+    get name(): Nullable<AltinnSystemName>;
+    get rights(): Nullable<KtList<AltinnSystemRights>>;
+    get vendor(): Nullable<AltinnSystemVendor>;
+    copy(accessPackages?: Nullable<KtList<AltinnSystemAccessPackages>>, allowedRedirectUrls?: Nullable<KtList<string>>, clientId?: KtList<string>, description?: Nullable<AltinnSystemDescription>, id?: Nullable<string>, isDeleted?: Nullable<boolean>, isVisible?: Nullable<boolean>, name?: Nullable<AltinnSystemName>, rights?: Nullable<KtList<AltinnSystemRights>>, vendor?: Nullable<AltinnSystemVendor>): AltinnSystemRegisterInput;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace AltinnSystemRegisterInput {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AltinnSystemRegisterInput;
+    }
+}
+export declare class AltinnSystemRights {
+    constructor(action: Nullable<string> | undefined, resource: KtList<AltinnSystemRightsResource>);
+    get action(): Nullable<string>;
+    get resource(): KtList<AltinnSystemRightsResource>;
+    copy(action?: Nullable<string>, resource?: KtList<AltinnSystemRightsResource>): AltinnSystemRights;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace AltinnSystemRights {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AltinnSystemRights;
+    }
+}
+export declare class AltinnSystemRightsResource {
+    constructor(id: string, value: string);
+    get id(): string;
+    get value(): string;
+    copy(id?: string, value?: string): AltinnSystemRightsResource;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace AltinnSystemRightsResource {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AltinnSystemRightsResource;
+    }
+}
+export declare class AltinnSystemUserRequestResult {
+    constructor(accessPackages: Nullable<KtList<AltinnSystemAccessPackages>> | undefined, confirmUrl: string, externalRef: string, id: string, partyOrgNo: string, redirectUrl: string, rights: Nullable<KtList<AltinnSystemRights>> | undefined, status: string, systemId: string);
+    get accessPackages(): Nullable<KtList<AltinnSystemAccessPackages>>;
+    get confirmUrl(): string;
+    get externalRef(): string;
+    get id(): string;
+    get partyOrgNo(): string;
+    get redirectUrl(): string;
+    get rights(): Nullable<KtList<AltinnSystemRights>>;
+    get status(): string;
+    get systemId(): string;
+    copy(accessPackages?: Nullable<KtList<AltinnSystemAccessPackages>>, confirmUrl?: string, externalRef?: string, id?: string, partyOrgNo?: string, redirectUrl?: string, rights?: Nullable<KtList<AltinnSystemRights>>, status?: string, systemId?: string): AltinnSystemUserRequestResult;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace AltinnSystemUserRequestResult {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AltinnSystemUserRequestResult;
+    }
+}
+export declare class AltinnSystemVendor {
+    constructor(id?: Nullable<string>);
+    get id(): Nullable<string>;
+    copy(id?: Nullable<string>): AltinnSystemVendor;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace AltinnSystemVendor {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AltinnSystemVendor;
+    }
+}
 export declare class ApproveSupplierInvoiceCommand {
     constructor(reason?: Nullable<string>);
     get reason(): Nullable<string>;
@@ -555,6 +823,36 @@ export declare namespace AttachIssueToMeetingCommand {
         const constructor: abstract new () => AttachIssueToMeetingCommand;
     }
 }
+export declare class AttachPersonPolicyCommand {
+    constructor(companyId: Nullable<bigint> | undefined, policyId: bigint);
+    get companyId(): Nullable<bigint>;
+    get policyId(): bigint;
+    copy(companyId?: Nullable<bigint>, policyId?: bigint): AttachPersonPolicyCommand;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace AttachPersonPolicyCommand {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttachPersonPolicyCommand;
+    }
+}
+export declare class AttachRoleTypePolicyRequest {
+    constructor(policyId: bigint, priority?: Nullable<bigint>);
+    get policyId(): bigint;
+    get priority(): Nullable<bigint>;
+    copy(policyId?: bigint, priority?: Nullable<bigint>): AttachRoleTypePolicyRequest;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace AttachRoleTypePolicyRequest {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttachRoleTypePolicyRequest;
+    }
+}
 export declare class Attendance {
     constructor(companyId: bigint, id: bigint, resident: Resident, sectionId: bigint, validFrom: any/* Instant */, validTo?: Nullable<any>/* Nullable<Instant> */);
     get companyId(): bigint;
@@ -837,6 +1135,21 @@ export declare namespace BatchTrashDocumentsCommand {
         const constructor: abstract new () => BatchTrashDocumentsCommand;
     }
 }
+export declare class Billing {
+    constructor(id: bigint, name: string);
+    get id(): bigint;
+    get name(): string;
+    copy(id?: bigint, name?: string): Billing;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace Billing {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => Billing;
+    }
+}
 export declare class BoardParticipant extends Participant.$metadata$.constructor {
     constructor(active: boolean, id: bigint, name: string, participantId: bigint);
     get active(): boolean;
@@ -2196,6 +2509,112 @@ export declare namespace BulkPublishSMSBroadcastsSummary {
         const constructor: abstract new () => BulkPublishSMSBroadcastsSummary;
     }
 }
+export declare class BulkRetroactiveKartverketCommand {
+    constructor(companyIds?: Nullable<KtList<bigint>>);
+    get companyIds(): Nullable<KtList<bigint>>;
+    copy(companyIds?: Nullable<KtList<bigint>>): BulkRetroactiveKartverketCommand;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkRetroactiveKartverketCommand {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => BulkRetroactiveKartverketCommand;
+    }
+}
+export declare class BulkRetroactiveKartverketItemResult {
+    constructor(companyId: bigint, index: bigint, message: Nullable<string> | undefined, status: BulkRetroactiveKartverketItemStatus);
+    get companyId(): bigint;
+    get index(): bigint;
+    get message(): Nullable<string>;
+    get status(): BulkRetroactiveKartverketItemStatus;
+    copy(companyId?: bigint, index?: bigint, message?: Nullable<string>, status?: BulkRetroactiveKartverketItemStatus): BulkRetroactiveKartverketItemResult;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkRetroactiveKartverketItemResult {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => BulkRetroactiveKartverketItemResult;
+    }
+}
+export declare abstract class BulkRetroactiveKartverketItemStatus {
+    private constructor();
+    static get UPDATED(): BulkRetroactiveKartverketItemStatus & {
+        get name(): "UPDATED";
+        get ordinal(): 0;
+    };
+    static get FAILED(): BulkRetroactiveKartverketItemStatus & {
+        get name(): "FAILED";
+        get ordinal(): 1;
+    };
+    static get Updated(): BulkRetroactiveKartverketItemStatus & {
+        get name(): "UPDATED";
+        get ordinal(): 0;
+    };
+    static get Failed(): BulkRetroactiveKartverketItemStatus & {
+        get name(): "FAILED";
+        get ordinal(): 1;
+    };
+    static values(): [typeof BulkRetroactiveKartverketItemStatus.UPDATED, typeof BulkRetroactiveKartverketItemStatus.FAILED];
+    static valueOf(value: string): BulkRetroactiveKartverketItemStatus;
+    get name(): "UPDATED" | "FAILED";
+    get ordinal(): 0 | 1;
+    get value(): string;
+    toString(): string;
+}
+export declare namespace BulkRetroactiveKartverketItemStatus {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => BulkRetroactiveKartverketItemStatus;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor /* implements SerializerFactory */ {
+                fromValue(value: string): Nullable<BulkRetroactiveKartverketItemStatus>;
+                private constructor();
+            }
+        }
+    }
+}
+export declare class BulkRetroactiveKartverketResult {
+    constructor(items: KtList<BulkRetroactiveKartverketItemResult>, summary?: Nullable<BulkRetroactiveKartverketSummary>);
+    get items(): KtList<BulkRetroactiveKartverketItemResult>;
+    get summary(): Nullable<BulkRetroactiveKartverketSummary>;
+    copy(items?: KtList<BulkRetroactiveKartverketItemResult>, summary?: Nullable<BulkRetroactiveKartverketSummary>): BulkRetroactiveKartverketResult;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkRetroactiveKartverketResult {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => BulkRetroactiveKartverketResult;
+    }
+}
+export declare class BulkRetroactiveKartverketSummary {
+    constructor(failed: bigint, requestedAllCompanies: boolean, total: bigint, updated: bigint);
+    get failed(): bigint;
+    get requestedAllCompanies(): boolean;
+    get total(): bigint;
+    get updated(): bigint;
+    copy(failed?: bigint, requestedAllCompanies?: boolean, total?: bigint, updated?: bigint): BulkRetroactiveKartverketSummary;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkRetroactiveKartverketSummary {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => BulkRetroactiveKartverketSummary;
+    }
+}
 export declare class BulkUpdateCompanyDetailedCommand {
     constructor(dryRun: Nullable<boolean> | undefined, items: KtList<BulkUpdateCompanyDetailedItemCommand>);
     get dryRun(): Nullable<boolean>;
@@ -2555,24 +2974,92 @@ export declare namespace ClientUser {
         const constructor: abstract new () => ClientUser;
     }
 }
-export declare class ClientUserParticipant extends Participant.$metadata$.constructor {
-    constructor(active: boolean, id: bigint, name: string, participantId: bigint, clientId: string);
-    get active(): boolean;
-    get id(): bigint;
-    get name(): string;
-    get participantId(): bigint;
-    get clientId(): string;
-    copy(active?: boolean, id?: bigint, name?: string, participantId?: bigint, clientId?: string): ClientUserParticipant;
+export declare abstract class ClientUserCompanyScope {
+    private constructor();
+    static get READ_ONLY(): ClientUserCompanyScope & {
+        get name(): "READ_ONLY";
+        get ordinal(): 0;
+    };
+    static get BOARD(): ClientUserCompanyScope & {
+        get name(): "BOARD";
+        get ordinal(): 1;
+    };
+    static get ADMIN(): ClientUserCompanyScope & {
+        get name(): "ADMIN";
+        get ordinal(): 2;
+    };
+    static get ReadOnly(): ClientUserCompanyScope & {
+        get name(): "READ_ONLY";
+        get ordinal(): 0;
+    };
+    static get Board(): ClientUserCompanyScope & {
+        get name(): "BOARD";
+        get ordinal(): 1;
+    };
+    static get Admin(): ClientUserCompanyScope & {
+        get name(): "ADMIN";
+        get ordinal(): 2;
+    };
+    static values(): [typeof ClientUserCompanyScope.READ_ONLY, typeof ClientUserCompanyScope.BOARD, typeof ClientUserCompanyScope.ADMIN];
+    static valueOf(value: string): ClientUserCompanyScope;
+    get name(): "READ_ONLY" | "BOARD" | "ADMIN";
+    get ordinal(): 0 | 1 | 2;
+    get value(): string;
     toString(): string;
-    hashCode(): number;
-    equals(other: Nullable<any>): boolean;
 }
-export declare namespace ClientUserParticipant {
+export declare namespace ClientUserCompanyScope {
     /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
     namespace $metadata$ {
-        const constructor: abstract new () => ClientUserParticipant;
+        const constructor: abstract new () => ClientUserCompanyScope;
     }
-}
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor /* implements SerializerFactory */ {
+                fromValue(value: string): Nullable<ClientUserCompanyScope>;
+                private constructor();
+            }
+        }
+    }
+}
+export declare class ClientUserParticipant extends Participant.$metadata$.constructor {
+    constructor(active: boolean, id: bigint, name: string, participantId: bigint, clientId: string);
+    get active(): boolean;
+    get id(): bigint;
+    get name(): string;
+    get participantId(): bigint;
+    get clientId(): string;
+    copy(active?: boolean, id?: bigint, name?: string, participantId?: bigint, clientId?: string): ClientUserParticipant;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace ClientUserParticipant {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => ClientUserParticipant;
+    }
+}
+export declare class ClientUserScope {
+    constructor(action: string, companyId: Nullable<bigint> | undefined, id: bigint, resource: string);
+    get action(): string;
+    get companyId(): Nullable<bigint>;
+    get id(): bigint;
+    get resource(): string;
+    copy(action?: string, companyId?: Nullable<bigint>, id?: bigint, resource?: string): ClientUserScope;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace ClientUserScope {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => ClientUserScope;
+    }
+}
 export declare class CloseInsuranceCommand {
     constructor(endDate: any/* Instant */);
     get endDate(): any/* Instant */;
@@ -3127,6 +3614,65 @@ export declare namespace CommunicationState {
         }
     }
 }
+export declare abstract class CommunicationType {
+    private constructor();
+    static get NEWSLETTER(): CommunicationType & {
+        get name(): "NEWSLETTER";
+        get ordinal(): 0;
+    };
+    static get BROADCAST(): CommunicationType & {
+        get name(): "BROADCAST";
+        get ordinal(): 1;
+    };
+    static get POST(): CommunicationType & {
+        get name(): "POST";
+        get ordinal(): 2;
+    };
+    static get PRACTICAL_INFO(): CommunicationType & {
+        get name(): "PRACTICAL_INFO";
+        get ordinal(): 3;
+    };
+    static get Newsletter(): CommunicationType & {
+        get name(): "NEWSLETTER";
+        get ordinal(): 0;
+    };
+    static get Broadcast(): CommunicationType & {
+        get name(): "BROADCAST";
+        get ordinal(): 1;
+    };
+    static get Post(): CommunicationType & {
+        get name(): "POST";
+        get ordinal(): 2;
+    };
+    static get PracticalInfo(): CommunicationType & {
+        get name(): "PRACTICAL_INFO";
+        get ordinal(): 3;
+    };
+    static values(): [typeof CommunicationType.NEWSLETTER, typeof CommunicationType.BROADCAST, typeof CommunicationType.POST, typeof CommunicationType.PRACTICAL_INFO];
+    static valueOf(value: string): CommunicationType;
+    get name(): "NEWSLETTER" | "BROADCAST" | "POST" | "PRACTICAL_INFO";
+    get ordinal(): 0 | 1 | 2 | 3;
+    get value(): string;
+    toString(): string;
+}
+export declare namespace CommunicationType {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => CommunicationType;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor /* implements SerializerFactory */ {
+                fromValue(value: string): Nullable<CommunicationType>;
+                private constructor();
+            }
+        }
+    }
+}
 export declare class Company {
     constructor(addresses: Nullable<KtList<CompanyAddress>> | undefined, buildings: Nullable<KtList<Building>> | undefined, classification: string, country: string, id: bigint, managed: boolean, name: string, nationality: bigint, operatingAccount: Nullable<string> | undefined, orgNr: Nullable<string> | undefined, organizationId: Nullable<bigint> | undefined, slug: Nullable<string> | undefined, status: Nullable<CompanyStatus> | undefined, subTypes: KtList<CompanySubType>, tenantId: bigint);
     get addresses(): Nullable<KtList<CompanyAddress>>;
@@ -3796,7 +4342,7 @@ export declare namespace ConversationCountConversationCountByCompanyMap {
         const constructor: abstract new () => ConversationCountConversationCountByCompanyMap;
     }
 }
-export declare class ConversationCountConversationCountMap {
+export declare class ConversationCountConversationCountByCompanyMapValue {
     constructor(done: bigint, draft: bigint, folderCounts: Nullable<KtMap<string, Nullable<bigint>>> | undefined, inProgress: bigint, _new: bigint, root?: Nullable<bigint>, total?: Nullable<bigint>);
     get done(): bigint;
     get draft(): bigint;
@@ -3805,15 +4351,15 @@ export declare class ConversationCountConversationCountMap {
     get new(): bigint;
     get root(): Nullable<bigint>;
     get total(): Nullable<bigint>;
-    copy(done?: bigint, draft?: bigint, folderCounts?: Nullable<KtMap<string, Nullable<bigint>>>, inProgress?: bigint, _new?: bigint, root?: Nullable<bigint>, total?: Nullable<bigint>): ConversationCountConversationCountMap;
+    copy(done?: bigint, draft?: bigint, folderCounts?: Nullable<KtMap<string, Nullable<bigint>>>, inProgress?: bigint, _new?: bigint, root?: Nullable<bigint>, total?: Nullable<bigint>): ConversationCountConversationCountByCompanyMapValue;
     toString(): string;
     hashCode(): number;
     equals(other: Nullable<any>): boolean;
 }
-export declare namespace ConversationCountConversationCountMap {
+export declare namespace ConversationCountConversationCountByCompanyMapValue {
     /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
     namespace $metadata$ {
-        const constructor: abstract new () => ConversationCountConversationCountMap;
+        const constructor: abstract new () => ConversationCountConversationCountByCompanyMapValue;
     }
 }
 export declare class ConversationEvent {
@@ -4060,6 +4606,57 @@ export declare namespace ConversationMessagePayload {
         const constructor: abstract new () => ConversationMessagePayload;
     }
 }
+export declare abstract class ConversationMessageSide {
+    private constructor();
+    static get BOARD(): ConversationMessageSide & {
+        get name(): "BOARD";
+        get ordinal(): 0;
+    };
+    static get NON_BOARD(): ConversationMessageSide & {
+        get name(): "NON_BOARD";
+        get ordinal(): 1;
+    };
+    static get NONE(): ConversationMessageSide & {
+        get name(): "NONE";
+        get ordinal(): 2;
+    };
+    static get Board(): ConversationMessageSide & {
+        get name(): "BOARD";
+        get ordinal(): 0;
+    };
+    static get NonBoard(): ConversationMessageSide & {
+        get name(): "NON_BOARD";
+        get ordinal(): 1;
+    };
+    static get None(): ConversationMessageSide & {
+        get name(): "NONE";
+        get ordinal(): 2;
+    };
+    static values(): [typeof ConversationMessageSide.BOARD, typeof ConversationMessageSide.NON_BOARD, typeof ConversationMessageSide.NONE];
+    static valueOf(value: string): ConversationMessageSide;
+    get name(): "BOARD" | "NON_BOARD" | "NONE";
+    get ordinal(): 0 | 1 | 2;
+    get value(): string;
+    toString(): string;
+}
+export declare namespace ConversationMessageSide {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => ConversationMessageSide;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor /* implements SerializerFactory */ {
+                fromValue(value: string): Nullable<ConversationMessageSide>;
+                private constructor();
+            }
+        }
+    }
+}
 export declare abstract class ConversationOrderBy {
     private constructor();
     static get LATEST_ACTIVITY_AT(): ConversationOrderBy & {
@@ -4542,6 +5139,37 @@ export declare namespace CreateChangeRequestCommand {
         const constructor: abstract new () => CreateChangeRequestCommand;
     }
 }
+export declare class CreateClientUserCompanyScopeCommand {
+    constructor(companyId: bigint, scope: ClientUserCompanyScope);
+    get companyId(): bigint;
+    get scope(): ClientUserCompanyScope;
+    copy(companyId?: bigint, scope?: ClientUserCompanyScope): CreateClientUserCompanyScopeCommand;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace CreateClientUserCompanyScopeCommand {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => CreateClientUserCompanyScopeCommand;
+    }
+}
+export declare class CreateClientUserScopeCommand {
+    constructor(action: Nullable<string> | undefined, companyId: Nullable<bigint> | undefined, resource: string);
+    get action(): Nullable<string>;
+    get companyId(): Nullable<bigint>;
+    get resource(): string;
+    copy(action?: Nullable<string>, companyId?: Nullable<bigint>, resource?: string): CreateClientUserScopeCommand;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace CreateClientUserScopeCommand {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => CreateClientUserScopeCommand;
+    }
+}
 export declare class CreateCommunicationCommentCommand {
     constructor(content: string, parentId?: Nullable<bigint>);
     get content(): string;
@@ -5291,6 +5919,21 @@ export declare namespace CreatePersonCommand {
         const constructor: abstract new () => CreatePersonCommand;
     }
 }
+export declare class CreatePersonInlinePolicyCommand {
+    constructor(companyId: Nullable<bigint> | undefined, statements: KtList<Policy>);
+    get companyId(): Nullable<bigint>;
+    get statements(): KtList<Policy>;
+    copy(companyId?: Nullable<bigint>, statements?: KtList<Policy>): CreatePersonInlinePolicyCommand;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace CreatePersonInlinePolicyCommand {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => CreatePersonInlinePolicyCommand;
+    }
+}
 export declare class CreatePersonOwner {
     constructor(email: Nullable<string> | undefined, invoicingEmail: Nullable<string> | undefined, mobile: Nullable<string> | undefined, name: Name, personalIdentityNumber?: Nullable<string>);
     get email(): Nullable<string>;
@@ -5337,6 +5980,22 @@ export declare namespace CreatePersonResidentCommand {
         const constructor: abstract new () => CreatePersonResidentCommand;
     }
 }
+export declare class CreatePolicyDocumentCommand {
+    constructor(description: Nullable<string> | undefined, name: string, statements: KtList<Policy>);
+    get description(): Nullable<string>;
+    get name(): string;
+    get statements(): KtList<Policy>;
+    copy(description?: Nullable<string>, name?: string, statements?: KtList<Policy>): CreatePolicyDocumentCommand;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace CreatePolicyDocumentCommand {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => CreatePolicyDocumentCommand;
+    }
+}
 export declare class CreatePostCommand {
     constructor(commentsEnabled: Nullable<boolean> | undefined, content: string, notificationEmailGroups: Nullable<KtList<NotificationGroup>> | undefined, notificationSMSGroups: Nullable<KtList<NotificationGroup>> | undefined, pinned: Nullable<boolean> | undefined, _private: Nullable<boolean> | undefined, publishedAt: Nullable<any>/* Nullable<Instant> */ | undefined, title: string, weighting?: Nullable<bigint>);
     get commentsEnabled(): Nullable<boolean>;
@@ -5393,6 +6052,20 @@ export declare namespace CreateResidentCommand {
         const constructor: abstract new () => CreateResidentCommand;
     }
 }
+export declare class CreateRoleInlinePolicyRequest {
+    constructor(statements: KtList<Policy>);
+    get statements(): KtList<Policy>;
+    copy(statements?: KtList<Policy>): CreateRoleInlinePolicyRequest;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace CreateRoleInlinePolicyRequest {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => CreateRoleInlinePolicyRequest;
+    }
+}
 export declare class CreateRoutineCommand {
     constructor(description: Nullable<string> | undefined, draftId: Nullable<bigint> | undefined, dueDateOffset: Nullable<bigint> | undefined, recommendedIntervalMethod: Nullable<RoutineMethod> | undefined, recommendedIntervalType: RoutineInterval, recommendedIntervalValue: Nullable<bigint> | undefined, requiresSupplier: boolean, responsibleId: Nullable<bigint> | undefined, startDate: Nullable<any>/* Nullable<Instant> */ | undefined, supplierId: Nullable<bigint> | undefined, svgName: string, title: Nullable<string> | undefined, type: RoutineType);
     get description(): Nullable<string>;
@@ -5986,37 +6659,396 @@ export declare class DeviceSrpCommand {
     get srpA(): string;
     copy(clientId?: string, deviceKey?: Nullable<string>, email?: Nullable<string>, fingerprint?: string, mobile?: Nullable<string>, session?: string, srpA?: string): DeviceSrpCommand;
     toString(): string;
-    hashCode(): number;
-    equals(other: Nullable<any>): boolean;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace DeviceSrpCommand {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => DeviceSrpCommand;
+    }
+}
+export declare class DeviceVerifySrpCommand {
+    constructor(clientId: string, deviceKey: Nullable<string> | undefined, email: Nullable<string> | undefined, fingerprint: string, mcpRedirectUri: Nullable<string> | undefined, mcpState: Nullable<string> | undefined, mobile: Nullable<string> | undefined, passwordSignature: string, secretBlock: string, session: string, timestamp: string);
+    get clientId(): string;
+    get deviceKey(): Nullable<string>;
+    get email(): Nullable<string>;
+    get fingerprint(): string;
+    get mcpRedirectUri(): Nullable<string>;
+    get mcpState(): Nullable<string>;
+    get mobile(): Nullable<string>;
+    get passwordSignature(): string;
+    get secretBlock(): string;
+    get session(): string;
+    get timestamp(): string;
+    copy(clientId?: string, deviceKey?: Nullable<string>, email?: Nullable<string>, fingerprint?: string, mcpRedirectUri?: Nullable<string>, mcpState?: Nullable<string>, mobile?: Nullable<string>, passwordSignature?: string, secretBlock?: string, session?: string, timestamp?: string): DeviceVerifySrpCommand;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace DeviceVerifySrpCommand {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => DeviceVerifySrpCommand;
+    }
+}
+export declare class DialogActivity {
+    constructor(createdAt?: Nullable<Instant>, description?: Nullable<KtList<AltinnCommonLocalization>>, extendedType?: Nullable<string>, id?: Nullable<string>, performedBy?: Nullable<AltinnCommonActor>, transmissionId?: Nullable<string>, type?: Nullable<DialogActivityType>);
+    get createdAt(): Nullable<Instant>;
+    get description(): Nullable<KtList<AltinnCommonLocalization>>;
+    get extendedType(): Nullable<string>;
+    get id(): Nullable<string>;
+    get performedBy(): Nullable<AltinnCommonActor>;
+    get transmissionId(): Nullable<string>;
+    get type(): Nullable<DialogActivityType>;
+    copy(createdAt?: Nullable<Instant>, description?: Nullable<KtList<AltinnCommonLocalization>>, extendedType?: Nullable<string>, id?: Nullable<string>, performedBy?: Nullable<AltinnCommonActor>, transmissionId?: Nullable<string>, type?: Nullable<DialogActivityType>): DialogActivity;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace DialogActivity {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => DialogActivity;
+    }
+}
+export declare abstract class DialogActivityType {
+    private constructor();
+    static get DIALOG_CREATED(): DialogActivityType & {
+        get name(): "DIALOG_CREATED";
+        get ordinal(): 0;
+    };
+    static get DIALOG_CLOSED(): DialogActivityType & {
+        get name(): "DIALOG_CLOSED";
+        get ordinal(): 1;
+    };
+    static get INFORMATION(): DialogActivityType & {
+        get name(): "INFORMATION";
+        get ordinal(): 2;
+    };
+    static get TRANSMISSION_OPENED(): DialogActivityType & {
+        get name(): "TRANSMISSION_OPENED";
+        get ordinal(): 3;
+    };
+    static get PAYMENT_MADE(): DialogActivityType & {
+        get name(): "PAYMENT_MADE";
+        get ordinal(): 4;
+    };
+    static get SIGNATURE_PROVIDED(): DialogActivityType & {
+        get name(): "SIGNATURE_PROVIDED";
+        get ordinal(): 5;
+    };
+    static get DIALOG_OPENED(): DialogActivityType & {
+        get name(): "DIALOG_OPENED";
+        get ordinal(): 6;
+    };
+    static get DIALOG_DELETED(): DialogActivityType & {
+        get name(): "DIALOG_DELETED";
+        get ordinal(): 7;
+    };
+    static get DIALOG_RESTORED(): DialogActivityType & {
+        get name(): "DIALOG_RESTORED";
+        get ordinal(): 8;
+    };
+    static get SENT_TO_SIGNING(): DialogActivityType & {
+        get name(): "SENT_TO_SIGNING";
+        get ordinal(): 9;
+    };
+    static get SENT_TO_FORM_FILL(): DialogActivityType & {
+        get name(): "SENT_TO_FORM_FILL";
+        get ordinal(): 10;
+    };
+    static get SENT_TO_SEND_IN(): DialogActivityType & {
+        get name(): "SENT_TO_SEND_IN";
+        get ordinal(): 11;
+    };
+    static get SENT_TO_PAYMENT(): DialogActivityType & {
+        get name(): "SENT_TO_PAYMENT";
+        get ordinal(): 12;
+    };
+    static get DialogCreated(): DialogActivityType & {
+        get name(): "DIALOG_CREATED";
+        get ordinal(): 0;
+    };
+    static get DialogClosed(): DialogActivityType & {
+        get name(): "DIALOG_CLOSED";
+        get ordinal(): 1;
+    };
+    static get Information(): DialogActivityType & {
+        get name(): "INFORMATION";
+        get ordinal(): 2;
+    };
+    static get TransmissionOpened(): DialogActivityType & {
+        get name(): "TRANSMISSION_OPENED";
+        get ordinal(): 3;
+    };
+    static get PaymentMade(): DialogActivityType & {
+        get name(): "PAYMENT_MADE";
+        get ordinal(): 4;
+    };
+    static get SignatureProvided(): DialogActivityType & {
+        get name(): "SIGNATURE_PROVIDED";
+        get ordinal(): 5;
+    };
+    static get DialogOpened(): DialogActivityType & {
+        get name(): "DIALOG_OPENED";
+        get ordinal(): 6;
+    };
+    static get DialogDeleted(): DialogActivityType & {
+        get name(): "DIALOG_DELETED";
+        get ordinal(): 7;
+    };
+    static get DialogRestored(): DialogActivityType & {
+        get name(): "DIALOG_RESTORED";
+        get ordinal(): 8;
+    };
+    static get SentToSigning(): DialogActivityType & {
+        get name(): "SENT_TO_SIGNING";
+        get ordinal(): 9;
+    };
+    static get SentToFormFill(): DialogActivityType & {
+        get name(): "SENT_TO_FORM_FILL";
+        get ordinal(): 10;
+    };
+    static get SentToSendIn(): DialogActivityType & {
+        get name(): "SENT_TO_SEND_IN";
+        get ordinal(): 11;
+    };
+    static get SentToPayment(): DialogActivityType & {
+        get name(): "SENT_TO_PAYMENT";
+        get ordinal(): 12;
+    };
+    static values(): [typeof DialogActivityType.DIALOG_CREATED, typeof DialogActivityType.DIALOG_CLOSED, typeof DialogActivityType.INFORMATION, typeof DialogActivityType.TRANSMISSION_OPENED, typeof DialogActivityType.PAYMENT_MADE, typeof DialogActivityType.SIGNATURE_PROVIDED, typeof DialogActivityType.DIALOG_OPENED, typeof DialogActivityType.DIALOG_DELETED, typeof DialogActivityType.DIALOG_RESTORED, typeof DialogActivityType.SENT_TO_SIGNING, typeof DialogActivityType.SENT_TO_FORM_FILL, typeof DialogActivityType.SENT_TO_SEND_IN, typeof DialogActivityType.SENT_TO_PAYMENT];
+    static valueOf(value: string): DialogActivityType;
+    get name(): "DIALOG_CREATED" | "DIALOG_CLOSED" | "INFORMATION" | "TRANSMISSION_OPENED" | "PAYMENT_MADE" | "SIGNATURE_PROVIDED" | "DIALOG_OPENED" | "DIALOG_DELETED" | "DIALOG_RESTORED" | "SENT_TO_SIGNING" | "SENT_TO_FORM_FILL" | "SENT_TO_SEND_IN" | "SENT_TO_PAYMENT";
+    get ordinal(): 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+    get value(): string;
+    toString(): string;
+}
+export declare namespace DialogActivityType {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => DialogActivityType;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor /* implements SerializerFactory */ {
+                fromValue(value: string): Nullable<DialogActivityType>;
+                private constructor();
+            }
+        }
+    }
+}
+export declare class DialogEndUserContext {
+    constructor(revision?: Nullable<string>, systemLabels?: Nullable<KtList<DialogSystemLabel>>);
+    get revision(): Nullable<string>;
+    get systemLabels(): Nullable<KtList<DialogSystemLabel>>;
+    copy(revision?: Nullable<string>, systemLabels?: Nullable<KtList<DialogSystemLabel>>): DialogEndUserContext;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace DialogEndUserContext {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => DialogEndUserContext;
+    }
+}
+export declare class DialogSearchContent {
+    constructor(extendedStatus?: Nullable<AltinnCommonContent>, senderName?: Nullable<AltinnCommonContent>, summary?: Nullable<AltinnCommonContent>, title?: Nullable<AltinnCommonContent>);
+    get extendedStatus(): Nullable<AltinnCommonContent>;
+    get senderName(): Nullable<AltinnCommonContent>;
+    get summary(): Nullable<AltinnCommonContent>;
+    get title(): Nullable<AltinnCommonContent>;
+    copy(extendedStatus?: Nullable<AltinnCommonContent>, senderName?: Nullable<AltinnCommonContent>, summary?: Nullable<AltinnCommonContent>, title?: Nullable<AltinnCommonContent>): DialogSearchContent;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace DialogSearchContent {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => DialogSearchContent;
+    }
+}
+export declare class DialogSeenLog {
+    constructor(id?: Nullable<string>, isCurrentEndUser?: Nullable<boolean>, isViaServiceOwner?: Nullable<boolean>, seenAt?: Nullable<Instant>, seenBy?: Nullable<AltinnCommonActor>);
+    get id(): Nullable<string>;
+    get isCurrentEndUser(): Nullable<boolean>;
+    get isViaServiceOwner(): Nullable<boolean>;
+    get seenAt(): Nullable<Instant>;
+    get seenBy(): Nullable<AltinnCommonActor>;
+    copy(id?: Nullable<string>, isCurrentEndUser?: Nullable<boolean>, isViaServiceOwner?: Nullable<boolean>, seenAt?: Nullable<Instant>, seenBy?: Nullable<AltinnCommonActor>): DialogSeenLog;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace DialogSeenLog {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => DialogSeenLog;
+    }
+}
+export declare abstract class DialogStatus {
+    private constructor();
+    static get IN_PROGRESS(): DialogStatus & {
+        get name(): "IN_PROGRESS";
+        get ordinal(): 0;
+    };
+    static get DRAFT(): DialogStatus & {
+        get name(): "DRAFT";
+        get ordinal(): 1;
+    };
+    static get REQUIRES_ATTENTION(): DialogStatus & {
+        get name(): "REQUIRES_ATTENTION";
+        get ordinal(): 2;
+    };
+    static get COMPLETED(): DialogStatus & {
+        get name(): "COMPLETED";
+        get ordinal(): 3;
+    };
+    static get NOT_APPLICABLE(): DialogStatus & {
+        get name(): "NOT_APPLICABLE";
+        get ordinal(): 4;
+    };
+    static get AWAITING(): DialogStatus & {
+        get name(): "AWAITING";
+        get ordinal(): 5;
+    };
+    static get InProgress(): DialogStatus & {
+        get name(): "IN_PROGRESS";
+        get ordinal(): 0;
+    };
+    static get Draft(): DialogStatus & {
+        get name(): "DRAFT";
+        get ordinal(): 1;
+    };
+    static get RequiresAttention(): DialogStatus & {
+        get name(): "REQUIRES_ATTENTION";
+        get ordinal(): 2;
+    };
+    static get Completed(): DialogStatus & {
+        get name(): "COMPLETED";
+        get ordinal(): 3;
+    };
+    static get NotApplicable(): DialogStatus & {
+        get name(): "NOT_APPLICABLE";
+        get ordinal(): 4;
+    };
+    static get Awaiting(): DialogStatus & {
+        get name(): "AWAITING";
+        get ordinal(): 5;
+    };
+    static values(): [typeof DialogStatus.IN_PROGRESS, typeof DialogStatus.DRAFT, typeof DialogStatus.REQUIRES_ATTENTION, typeof DialogStatus.COMPLETED, typeof DialogStatus.NOT_APPLICABLE, typeof DialogStatus.AWAITING];
+    static valueOf(value: string): DialogStatus;
+    get name(): "IN_PROGRESS" | "DRAFT" | "REQUIRES_ATTENTION" | "COMPLETED" | "NOT_APPLICABLE" | "AWAITING";
+    get ordinal(): 0 | 1 | 2 | 3 | 4 | 5;
+    get value(): string;
+    toString(): string;
+}
+export declare namespace DialogStatus {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => DialogStatus;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor /* implements SerializerFactory */ {
+                fromValue(value: string): Nullable<DialogStatus>;
+                private constructor();
+            }
+        }
+    }
+}
+export declare abstract class DialogSystemLabel {
+    private constructor();
+    static get DEFAULT(): DialogSystemLabel & {
+        get name(): "DEFAULT";
+        get ordinal(): 0;
+    };
+    static get INBOX(): DialogSystemLabel & {
+        get name(): "INBOX";
+        get ordinal(): 1;
+    };
+    static get OUTBOX(): DialogSystemLabel & {
+        get name(): "OUTBOX";
+        get ordinal(): 2;
+    };
+    static get DRAFT(): DialogSystemLabel & {
+        get name(): "DRAFT";
+        get ordinal(): 3;
+    };
+    static get SENT(): DialogSystemLabel & {
+        get name(): "SENT";
+        get ordinal(): 4;
+    };
+    static get ARCHIVE(): DialogSystemLabel & {
+        get name(): "ARCHIVE";
+        get ordinal(): 5;
+    };
+    static get BIN(): DialogSystemLabel & {
+        get name(): "BIN";
+        get ordinal(): 6;
+    };
+    static get Default(): DialogSystemLabel & {
+        get name(): "DEFAULT";
+        get ordinal(): 0;
+    };
+    static get Inbox(): DialogSystemLabel & {
+        get name(): "INBOX";
+        get ordinal(): 1;
+    };
+    static get Outbox(): DialogSystemLabel & {
+        get name(): "OUTBOX";
+        get ordinal(): 2;
+    };
+    static get Draft(): DialogSystemLabel & {
+        get name(): "DRAFT";
+        get ordinal(): 3;
+    };
+    static get Sent(): DialogSystemLabel & {
+        get name(): "SENT";
+        get ordinal(): 4;
+    };
+    static get Archive(): DialogSystemLabel & {
+        get name(): "ARCHIVE";
+        get ordinal(): 5;
+    };
+    static get Bin(): DialogSystemLabel & {
+        get name(): "BIN";
+        get ordinal(): 6;
+    };
+    static values(): [typeof DialogSystemLabel.DEFAULT, typeof DialogSystemLabel.INBOX, typeof DialogSystemLabel.OUTBOX, typeof DialogSystemLabel.DRAFT, typeof DialogSystemLabel.SENT, typeof DialogSystemLabel.ARCHIVE, typeof DialogSystemLabel.BIN];
+    static valueOf(value: string): DialogSystemLabel;
+    get name(): "DEFAULT" | "INBOX" | "OUTBOX" | "DRAFT" | "SENT" | "ARCHIVE" | "BIN";
+    get ordinal(): 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    get value(): string;
+    toString(): string;
 }
-export declare namespace DeviceSrpCommand {
+export declare namespace DialogSystemLabel {
     /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
     namespace $metadata$ {
-        const constructor: abstract new () => DeviceSrpCommand;
+        const constructor: abstract new () => DialogSystemLabel;
     }
-}
-export declare class DeviceVerifySrpCommand {
-    constructor(clientId: string, deviceKey: Nullable<string> | undefined, email: Nullable<string> | undefined, fingerprint: string, mcpRedirectUri: Nullable<string> | undefined, mcpState: Nullable<string> | undefined, mobile: Nullable<string> | undefined, passwordSignature: string, secretBlock: string, session: string, timestamp: string);
-    get clientId(): string;
-    get deviceKey(): Nullable<string>;
-    get email(): Nullable<string>;
-    get fingerprint(): string;
-    get mcpRedirectUri(): Nullable<string>;
-    get mcpState(): Nullable<string>;
-    get mobile(): Nullable<string>;
-    get passwordSignature(): string;
-    get secretBlock(): string;
-    get session(): string;
-    get timestamp(): string;
-    copy(clientId?: string, deviceKey?: Nullable<string>, email?: Nullable<string>, fingerprint?: string, mcpRedirectUri?: Nullable<string>, mcpState?: Nullable<string>, mobile?: Nullable<string>, passwordSignature?: string, secretBlock?: string, session?: string, timestamp?: string): DeviceVerifySrpCommand;
-    toString(): string;
-    hashCode(): number;
-    equals(other: Nullable<any>): boolean;
-}
-export declare namespace DeviceVerifySrpCommand {
-    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
-    namespace $metadata$ {
-        const constructor: abstract new () => DeviceVerifySrpCommand;
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor /* implements SerializerFactory */ {
+                fromValue(value: string): Nullable<DialogSystemLabel>;
+                private constructor();
+            }
+        }
     }
 }
 export declare abstract class DirectSendInvoiceChannel {
@@ -6196,6 +7228,141 @@ export declare namespace Document {
         const constructor: abstract new () => Document;
     }
 }
+export declare abstract class DocumentContentSearchBackfillReason {
+    private constructor();
+    static get BACKFILL(): DocumentContentSearchBackfillReason & {
+        get name(): "BACKFILL";
+        get ordinal(): 0;
+    };
+    static get REINDEX(): DocumentContentSearchBackfillReason & {
+        get name(): "REINDEX";
+        get ordinal(): 1;
+    };
+    static get Backfill(): DocumentContentSearchBackfillReason & {
+        get name(): "BACKFILL";
+        get ordinal(): 0;
+    };
+    static get Reindex(): DocumentContentSearchBackfillReason & {
+        get name(): "REINDEX";
+        get ordinal(): 1;
+    };
+    static values(): [typeof DocumentContentSearchBackfillReason.BACKFILL, typeof DocumentContentSearchBackfillReason.REINDEX];
+    static valueOf(value: string): DocumentContentSearchBackfillReason;
+    get name(): "BACKFILL" | "REINDEX";
+    get ordinal(): 0 | 1;
+    get value(): string;
+    toString(): string;
+}
+export declare namespace DocumentContentSearchBackfillReason {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => DocumentContentSearchBackfillReason;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor /* implements SerializerFactory */ {
+                fromValue(value: string): Nullable<DocumentContentSearchBackfillReason>;
+                private constructor();
+            }
+        }
+    }
+}
+export declare abstract class DocumentContentSearchBackfillStatus {
+    private constructor();
+    static get DISABLED(): DocumentContentSearchBackfillStatus & {
+        get name(): "DISABLED";
+        get ordinal(): 0;
+    };
+    static get PENDING(): DocumentContentSearchBackfillStatus & {
+        get name(): "PENDING";
+        get ordinal(): 1;
+    };
+    static get RUNNING(): DocumentContentSearchBackfillStatus & {
+        get name(): "RUNNING";
+        get ordinal(): 2;
+    };
+    static get COMPLETE(): DocumentContentSearchBackfillStatus & {
+        get name(): "COMPLETE";
+        get ordinal(): 3;
+    };
+    static get FAILED(): DocumentContentSearchBackfillStatus & {
+        get name(): "FAILED";
+        get ordinal(): 4;
+    };
+    static get Disabled(): DocumentContentSearchBackfillStatus & {
+        get name(): "DISABLED";
+        get ordinal(): 0;
+    };
+    static get Pending(): DocumentContentSearchBackfillStatus & {
+        get name(): "PENDING";
+        get ordinal(): 1;
+    };
+    static get Running(): DocumentContentSearchBackfillStatus & {
+        get name(): "RUNNING";
+        get ordinal(): 2;
+    };
+    static get Complete(): DocumentContentSearchBackfillStatus & {
+        get name(): "COMPLETE";
+        get ordinal(): 3;
+    };
+    static get Failed(): DocumentContentSearchBackfillStatus & {
+        get name(): "FAILED";
+        get ordinal(): 4;
+    };
+    static values(): [typeof DocumentContentSearchBackfillStatus.DISABLED, typeof DocumentContentSearchBackfillStatus.PENDING, typeof DocumentContentSearchBackfillStatus.RUNNING, typeof DocumentContentSearchBackfillStatus.COMPLETE, typeof DocumentContentSearchBackfillStatus.FAILED];
+    static valueOf(value: string): DocumentContentSearchBackfillStatus;
+    get name(): "DISABLED" | "PENDING" | "RUNNING" | "COMPLETE" | "FAILED";
+    get ordinal(): 0 | 1 | 2 | 3 | 4;
+    get value(): string;
+    toString(): string;
+}
+export declare namespace DocumentContentSearchBackfillStatus {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => DocumentContentSearchBackfillStatus;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor /* implements SerializerFactory */ {
+                fromValue(value: string): Nullable<DocumentContentSearchBackfillStatus>;
+                private constructor();
+            }
+        }
+    }
+}
+export declare class DocumentContentSearchEntitlement {
+    constructor(backfillCompletedAt: Nullable<any>/* Nullable<Instant> */ | undefined, backfillCursor: Nullable<bigint> | undefined, backfillReason: Nullable<DocumentContentSearchBackfillReason> | undefined, backfillRequestedAt: Nullable<any>/* Nullable<Instant> */ | undefined, backfillStartedAt: Nullable<any>/* Nullable<Instant> */ | undefined, backfillStatus: DocumentContentSearchBackfillStatus, companyId: bigint, disabledAt: Nullable<any>/* Nullable<Instant> */ | undefined, enabled: boolean, enabledAt: Nullable<any>/* Nullable<Instant> */ | undefined, lastError: Nullable<string> | undefined, updatedAt: any/* Instant */);
+    get backfillCompletedAt(): Nullable<any>/* Nullable<Instant> */;
+    get backfillCursor(): Nullable<bigint>;
+    get backfillReason(): Nullable<DocumentContentSearchBackfillReason>;
+    get backfillRequestedAt(): Nullable<any>/* Nullable<Instant> */;
+    get backfillStartedAt(): Nullable<any>/* Nullable<Instant> */;
+    get backfillStatus(): DocumentContentSearchBackfillStatus;
+    get companyId(): bigint;
+    get disabledAt(): Nullable<any>/* Nullable<Instant> */;
+    get enabled(): boolean;
+    get enabledAt(): Nullable<any>/* Nullable<Instant> */;
+    get lastError(): Nullable<string>;
+    get updatedAt(): any/* Instant */;
+    copy(backfillCompletedAt?: Nullable<any>/* Nullable<Instant> */, backfillCursor?: Nullable<bigint>, backfillReason?: Nullable<DocumentContentSearchBackfillReason>, backfillRequestedAt?: Nullable<any>/* Nullable<Instant> */, backfillStartedAt?: Nullable<any>/* Nullable<Instant> */, backfillStatus?: DocumentContentSearchBackfillStatus, companyId?: bigint, disabledAt?: Nullable<any>/* Nullable<Instant> */, enabled?: boolean, enabledAt?: Nullable<any>/* Nullable<Instant> */, lastError?: Nullable<string>, updatedAt?: any/* Instant */): DocumentContentSearchEntitlement;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace DocumentContentSearchEntitlement {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => DocumentContentSearchEntitlement;
+    }
+}
 export declare abstract class DocumentType {
     private constructor();
     static get ISSUE(): DocumentType & {
@@ -6532,6 +7699,26 @@ export declare namespace DraftOverview {
         const constructor: abstract new () => DraftOverview;
     }
 }
+export declare class EcoguardSectionData {
+    constructor(billing: Billing, end: bigint, id: bigint, nodeId: bigint, objectNumber: string, parts: Nullable<KtList<Part>> | undefined, start: bigint);
+    get billing(): Billing;
+    get end(): bigint;
+    get id(): bigint;
+    get nodeId(): bigint;
+    get objectNumber(): string;
+    get parts(): Nullable<KtList<Part>>;
+    get start(): bigint;
+    copy(billing?: Billing, end?: bigint, id?: bigint, nodeId?: bigint, objectNumber?: string, parts?: Nullable<KtList<Part>>, start?: bigint): EcoguardSectionData;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace EcoguardSectionData {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => EcoguardSectionData;
+    }
+}
 export declare class EconomicReport {
     constructor(companyId: bigint, departmentDocumentEnabled: boolean, departmentDocumentId: Nullable<bigint> | undefined, forPeriod: Nullable<bigint> | undefined, id: bigint, orderedAt: any/* Instant */, orderedByClientUserId: Nullable<bigint> | undefined, orderedById: Nullable<bigint> | undefined, projectDocumentEnabled: boolean, projectDocumentId: Nullable<bigint> | undefined, reportDocumentId: Nullable<bigint> | undefined, status: EconomicReportStatus);
     get companyId(): bigint;
@@ -6615,6 +7802,57 @@ export declare namespace EconomicReportStatus {
         }
     }
 }
+export declare abstract class EconomicReportType {
+    private constructor();
+    static get REPORT(): EconomicReportType & {
+        get name(): "REPORT";
+        get ordinal(): 0;
+    };
+    static get DEPARTMENT(): EconomicReportType & {
+        get name(): "DEPARTMENT";
+        get ordinal(): 1;
+    };
+    static get PROJECT(): EconomicReportType & {
+        get name(): "PROJECT";
+        get ordinal(): 2;
+    };
+    static get Report(): EconomicReportType & {
+        get name(): "REPORT";
+        get ordinal(): 0;
+    };
+    static get Department(): EconomicReportType & {
+        get name(): "DEPARTMENT";
+        get ordinal(): 1;
+    };
+    static get Project(): EconomicReportType & {
+        get name(): "PROJECT";
+        get ordinal(): 2;
+    };
+    static values(): [typeof EconomicReportType.REPORT, typeof EconomicReportType.DEPARTMENT, typeof EconomicReportType.PROJECT];
+    static valueOf(value: string): EconomicReportType;
+    get name(): "REPORT" | "DEPARTMENT" | "PROJECT";
+    get ordinal(): 0 | 1 | 2;
+    get value(): string;
+    toString(): string;
+}
+export declare namespace EconomicReportType {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => EconomicReportType;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor /* implements SerializerFactory */ {
+                fromValue(value: string): Nullable<EconomicReportType>;
+                private constructor();
+            }
+        }
+    }
+}
 export declare abstract class EconomyStatusAvailability {
     private constructor();
     static get AVAILABLE(): EconomyStatusAvailability & {
@@ -7035,6 +8273,38 @@ export declare namespace ExpiredType {
         }
     }
 }
+export declare class ExplicitOffice365EmployeeIdentityMappingCommand {
+    constructor(approvalReference: string, entraObjectId: string, expectedVersion: Nullable<bigint> | undefined, idempotencyKey: string);
+    get approvalReference(): string;
+    get entraObjectId(): string;
+    get expectedVersion(): Nullable<bigint>;
+    get idempotencyKey(): string;
+    copy(approvalReference?: string, entraObjectId?: string, expectedVersion?: Nullable<bigint>, idempotencyKey?: string): ExplicitOffice365EmployeeIdentityMappingCommand;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace ExplicitOffice365EmployeeIdentityMappingCommand {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => ExplicitOffice365EmployeeIdentityMappingCommand;
+    }
+}
+export declare class ExplicitOffice365EmployeeIdentityMappingResponse {
+    constructor(idempotentReplay: boolean, identity: Office365EmployeeIdentity);
+    get idempotentReplay(): boolean;
+    get identity(): Office365EmployeeIdentity;
+    copy(idempotentReplay?: boolean, identity?: Office365EmployeeIdentity): ExplicitOffice365EmployeeIdentityMappingResponse;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace ExplicitOffice365EmployeeIdentityMappingResponse {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => ExplicitOffice365EmployeeIdentityMappingResponse;
+    }
+}
 export declare class ExportResidentsCommand {
     constructor(filter?: Nullable<ResidentExportFilter>, includePnr?: Nullable<boolean>, selection?: Nullable<KtList<ResidentIdentity>>);
     get filter(): Nullable<ResidentExportFilter>;
@@ -7965,6 +9235,34 @@ export declare namespace Homepage {
         const constructor: abstract new () => Homepage;
     }
 }
+export declare class IncominMail {
+    constructor(attachments: Nullable<KtList<IncomingMailAttachment>> | undefined, bcc: KtList<string>, cc: KtList<string>, commonId: Nullable<string> | undefined, from: string, htmlContent: Nullable<string> | undefined, id: Nullable<bigint> | undefined, inReplyTo: Nullable<string> | undefined, messageId: Nullable<string> | undefined, plainContent: Nullable<string> | undefined, references: Nullable<KtList<string>> | undefined, replyTo: Nullable<string> | undefined, subject: Nullable<string> | undefined, to: KtList<string>, verdicts?: Nullable<SesVerdicts>);
+    get attachments(): Nullable<KtList<IncomingMailAttachment>>;
+    get bcc(): KtList<string>;
+    get cc(): KtList<string>;
+    get commonId(): Nullable<string>;
+    get from(): string;
+    get htmlContent(): Nullable<string>;
+    get id(): Nullable<bigint>;
+    get inReplyTo(): Nullable<string>;
+    get messageId(): Nullable<string>;
+    get plainContent(): Nullable<string>;
+    get references(): Nullable<KtList<string>>;
+    get replyTo(): Nullable<string>;
+    get subject(): Nullable<string>;
+    get to(): KtList<string>;
+    get verdicts(): Nullable<SesVerdicts>;
+    copy(attachments?: Nullable<KtList<IncomingMailAttachment>>, bcc?: KtList<string>, cc?: KtList<string>, commonId?: Nullable<string>, from?: string, htmlContent?: Nullable<string>, id?: Nullable<bigint>, inReplyTo?: Nullable<string>, messageId?: Nullable<string>, plainContent?: Nullable<string>, references?: Nullable<KtList<string>>, replyTo?: Nullable<string>, subject?: Nullable<string>, to?: KtList<string>, verdicts?: Nullable<SesVerdicts>): IncominMail;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace IncominMail {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => IncominMail;
+    }
+}
 export declare abstract class IncomingEventBusMessage {
     private constructor();
 }
@@ -7974,6 +9272,23 @@ export declare namespace IncomingEventBusMessage {
         const constructor: abstract new () => IncomingEventBusMessage;
     }
 }
+export declare class IncomingMailAttachment {
+    constructor(content: string, contentId: Nullable<string> | undefined, name: string, type: string);
+    get content(): string;
+    get contentId(): Nullable<string>;
+    get name(): string;
+    get type(): string;
+    copy(content?: string, contentId?: Nullable<string>, name?: string, type?: string): IncomingMailAttachment;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace IncomingMailAttachment {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => IncomingMailAttachment;
+    }
+}
 export declare abstract class InlineDistributionType {
     private constructor();
     static get FLAT(): InlineDistributionType & {
@@ -8068,6 +9383,21 @@ export declare namespace InquiryParticipant {
         const constructor: abstract new () => InquiryParticipant;
     }
 }
+export declare class Instant {
+    constructor(epochSeconds: bigint, nanosecondsOfSecond: bigint);
+    get epochSeconds(): bigint;
+    get nanosecondsOfSecond(): bigint;
+    copy(epochSeconds?: bigint, nanosecondsOfSecond?: bigint): Instant;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace Instant {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => Instant;
+    }
+}
 export declare class Insurance {
     constructor(agreementDocumentId: Nullable<bigint> | undefined, companyId: bigint, endDate: Nullable<any>/* Nullable<Instant> */ | undefined, id: bigint, policyNumber: string, premium: bigint, startDate: any/* Instant */, supplierId: bigint, supplierName: string);
     get agreementDocumentId(): Nullable<bigint>;
@@ -10147,6 +11477,30 @@ export declare namespace IssueStatus {
         }
     }
 }
+export declare class Item {
+    constructor(end: bigint, measuringDevice: Nullable<MeasuringDevice> | undefined, priceComponent: PriceComponent, quantity: number, quantityUnit: string, rate: number, rateUnit: string, start: bigint, status: string, total: number, totalVat: number);
+    get end(): bigint;
+    get measuringDevice(): Nullable<MeasuringDevice>;
+    get priceComponent(): PriceComponent;
+    get quantity(): number;
+    get quantityUnit(): string;
+    get rate(): number;
+    get rateUnit(): string;
+    get start(): bigint;
+    get status(): string;
+    get total(): number;
+    get totalVat(): number;
+    copy(end?: bigint, measuringDevice?: Nullable<MeasuringDevice>, priceComponent?: PriceComponent, quantity?: number, quantityUnit?: string, rate?: number, rateUnit?: string, start?: bigint, status?: string, total?: number, totalVat?: number): Item;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace Item {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => Item;
+    }
+}
 export declare abstract class JobState {
     private constructor();
     static get CREATED(): JobState & {
@@ -10792,6 +12146,22 @@ export declare namespace McpTokenResponse {
         const constructor: abstract new () => McpTokenResponse;
     }
 }
+export declare class MeasuringDevice {
+    constructor(readingEnd?: Nullable<number>, readingStart?: Nullable<number>, serialNumber?: Nullable<string>);
+    get readingEnd(): Nullable<number>;
+    get readingStart(): Nullable<number>;
+    get serialNumber(): Nullable<string>;
+    copy(readingEnd?: Nullable<number>, readingStart?: Nullable<number>, serialNumber?: Nullable<string>): MeasuringDevice;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace MeasuringDevice {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => MeasuringDevice;
+    }
+}
 export declare class Meeting {
     constructor(actualEndAt: Nullable<any>/* Nullable<Instant> */ | undefined, actualStartAt: Nullable<any>/* Nullable<Instant> */ | undefined, companyId: bigint, externalParticipants: Nullable<KtList<ExternalMeetingParticipant>> | undefined, id: bigint, issueCount: Nullable<bigint> | undefined, location: Nullable<string> | undefined, participants: Nullable<KtList<MeetingParticipant>> | undefined, plannedEndAt: any/* Instant */, plannedStartAt: any/* Instant */, report: Nullable<Document> | undefined, status: MeetingStatus, title: string);
     get actualEndAt(): Nullable<any>/* Nullable<Instant> */;
@@ -11069,7 +12439,7 @@ export declare namespace MessageGroup {
     }
 }
 export declare class MessageInConversation {
-    constructor(content: string, deletedAt: Nullable<any>/* Nullable<Instant> */ | undefined, deliverability: Nullable<KtList<MessageDeliverability>> | undefined, documents: Nullable<KtList<Document>> | undefined, editedAt: Nullable<any>/* Nullable<Instant> */ | undefined, emailContent: Nullable<MessageEmailContent> | undefined, emailRecipients: Nullable<MessageEmailRecipients> | undefined, id: bigint, renderedContent: Nullable<string> | undefined, sentAt: any/* Instant */, sentBy: Nullable<Participant> | undefined, sentByCurrentUser: Nullable<boolean> | undefined, sentById: bigint, type?: Nullable<MessageType>);
+    constructor(content: string, deletedAt: Nullable<any>/* Nullable<Instant> */ | undefined, deliverability: Nullable<KtList<MessageDeliverability>> | undefined, documents: Nullable<KtList<Document>> | undefined, editedAt: Nullable<any>/* Nullable<Instant> */ | undefined, emailContent: Nullable<MessageEmailContent> | undefined, emailRecipients: Nullable<MessageEmailRecipients> | undefined, id: bigint, origin: Nullable<MessageOrigin> | undefined, renderedContent: Nullable<string> | undefined, sentAt: any/* Instant */, sentBy: Nullable<Participant> | undefined, sentByCurrentUser: Nullable<boolean> | undefined, sentById: bigint, type?: Nullable<MessageType>);
     get content(): string;
     get deletedAt(): Nullable<any>/* Nullable<Instant> */;
     get deliverability(): Nullable<KtList<MessageDeliverability>>;
@@ -11078,21 +12448,65 @@ export declare class MessageInConversation {
     get emailContent(): Nullable<MessageEmailContent>;
     get emailRecipients(): Nullable<MessageEmailRecipients>;
     get id(): bigint;
+    get origin(): Nullable<MessageOrigin>;
     get renderedContent(): Nullable<string>;
     get sentAt(): any/* Instant */;
     get sentBy(): Nullable<Participant>;
     get sentByCurrentUser(): Nullable<boolean>;
     get sentById(): bigint;
     get type(): Nullable<MessageType>;
-    copy(content?: string, deletedAt?: Nullable<any>/* Nullable<Instant> */, deliverability?: Nullable<KtList<MessageDeliverability>>, documents?: Nullable<KtList<Document>>, editedAt?: Nullable<any>/* Nullable<Instant> */, emailContent?: Nullable<MessageEmailContent>, emailRecipients?: Nullable<MessageEmailRecipients>, id?: bigint, renderedContent?: Nullable<string>, sentAt?: any/* Instant */, sentBy?: Nullable<Participant>, sentByCurrentUser?: Nullable<boolean>, sentById?: bigint, type?: Nullable<MessageType>): MessageInConversation;
+    copy(content?: string, deletedAt?: Nullable<any>/* Nullable<Instant> */, deliverability?: Nullable<KtList<MessageDeliverability>>, documents?: Nullable<KtList<Document>>, editedAt?: Nullable<any>/* Nullable<Instant> */, emailContent?: Nullable<MessageEmailContent>, emailRecipients?: Nullable<MessageEmailRecipients>, id?: bigint, origin?: Nullable<MessageOrigin>, renderedContent?: Nullable<string>, sentAt?: any/* Instant */, sentBy?: Nullable<Participant>, sentByCurrentUser?: Nullable<boolean>, sentById?: bigint, type?: Nullable<MessageType>): MessageInConversation;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace MessageInConversation {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => MessageInConversation;
+    }
+}
+export declare abstract class MessageOrigin {
+    private constructor();
+    static get EMAIL(): MessageOrigin & {
+        get name(): "EMAIL";
+        get ordinal(): 0;
+    };
+    static get API(): MessageOrigin & {
+        get name(): "API";
+        get ordinal(): 1;
+    };
+    static get Email(): MessageOrigin & {
+        get name(): "EMAIL";
+        get ordinal(): 0;
+    };
+    static get Api(): MessageOrigin & {
+        get name(): "API";
+        get ordinal(): 1;
+    };
+    static values(): [typeof MessageOrigin.EMAIL, typeof MessageOrigin.API];
+    static valueOf(value: string): MessageOrigin;
+    get name(): "EMAIL" | "API";
+    get ordinal(): 0 | 1;
+    get value(): string;
     toString(): string;
-    hashCode(): number;
-    equals(other: Nullable<any>): boolean;
 }
-export declare namespace MessageInConversation {
+export declare namespace MessageOrigin {
     /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
     namespace $metadata$ {
-        const constructor: abstract new () => MessageInConversation;
+        const constructor: abstract new () => MessageOrigin;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor /* implements SerializerFactory */ {
+                fromValue(value: string): Nullable<MessageOrigin>;
+                private constructor();
+            }
+        }
     }
 }
 export declare abstract class MessageType {
@@ -11705,6 +13119,34 @@ export declare namespace Office365EditSessionActorKind {
         }
     }
 }
+export declare class Office365EmployeeIdentity {
+    constructor(bindingMethod: string, cognitoUserId: string, createdAt: any/* Instant */, disabledAt: Nullable<any>/* Nullable<Instant> */ | undefined, entraObjectId: Nullable<string> | undefined, entraTenantId: string, explicitMappingRequired: boolean, lastErrorCode: Nullable<string> | undefined, membershipValidUntil: Nullable<any>/* Nullable<Instant> */ | undefined, personId: bigint, revokedAt: Nullable<any>/* Nullable<Instant> */ | undefined, state: string, updatedAt: any/* Instant */, verifiedAt: Nullable<any>/* Nullable<Instant> */ | undefined, version: bigint);
+    get bindingMethod(): string;
+    get cognitoUserId(): string;
+    get createdAt(): any/* Instant */;
+    get disabledAt(): Nullable<any>/* Nullable<Instant> */;
+    get entraObjectId(): Nullable<string>;
+    get entraTenantId(): string;
+    get explicitMappingRequired(): boolean;
+    get lastErrorCode(): Nullable<string>;
+    get membershipValidUntil(): Nullable<any>/* Nullable<Instant> */;
+    get personId(): bigint;
+    get revokedAt(): Nullable<any>/* Nullable<Instant> */;
+    get state(): string;
+    get updatedAt(): any/* Instant */;
+    get verifiedAt(): Nullable<any>/* Nullable<Instant> */;
+    get version(): bigint;
+    copy(bindingMethod?: string, cognitoUserId?: string, createdAt?: any/* Instant */, disabledAt?: Nullable<any>/* Nullable<Instant> */, entraObjectId?: Nullable<string>, entraTenantId?: string, explicitMappingRequired?: boolean, lastErrorCode?: Nullable<string>, membershipValidUntil?: Nullable<any>/* Nullable<Instant> */, personId?: bigint, revokedAt?: Nullable<any>/* Nullable<Instant> */, state?: string, updatedAt?: any/* Instant */, verifiedAt?: Nullable<any>/* Nullable<Instant> */, version?: bigint): Office365EmployeeIdentity;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace Office365EmployeeIdentity {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => Office365EmployeeIdentity;
+    }
+}
 export declare class Office365InternalDocumentPublishRequest {
     constructor(requestId: bigint, state: string);
     get requestId(): bigint;
@@ -13290,6 +14732,22 @@ export declare namespace PagedListPublicConversationCategory {
         const constructor: abstract new () => PagedListPublicConversationCategory;
     }
 }
+export declare class PagedListPushNotificationDispatchEvidence {
+    constructor(items: KtList<PushNotificationDispatchEvidence>, meta: Meta, paging: Paging);
+    get items(): KtList<PushNotificationDispatchEvidence>;
+    get meta(): Meta;
+    get paging(): Paging;
+    copy(items?: KtList<PushNotificationDispatchEvidence>, meta?: Meta, paging?: Paging): PagedListPushNotificationDispatchEvidence;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace PagedListPushNotificationDispatchEvidence {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => PagedListPushNotificationDispatchEvidence;
+    }
+}
 export declare class PagedListPushNotificationInboxItem {
     constructor(items: KtList<PushNotificationInboxItem>, meta: Meta, paging: Paging);
     get items(): KtList<PushNotificationInboxItem>;
@@ -14067,6 +15525,23 @@ export declare namespace ParkingSpaceVacant {
         const constructor: abstract new () => ParkingSpaceVacant;
     }
 }
+export declare class Part {
+    constructor(code: Nullable<string> | undefined, items: KtList<Item>, name: string, vat: bigint);
+    get code(): Nullable<string>;
+    get items(): KtList<Item>;
+    get name(): string;
+    get vat(): bigint;
+    copy(code?: Nullable<string>, items?: KtList<Item>, name?: string, vat?: bigint): Part;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace Part {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => Part;
+    }
+}
 export declare abstract class Participant {
     private constructor();
     abstract get active(): boolean;
@@ -14646,6 +16121,24 @@ export declare namespace PersonInformation {
         const constructor: abstract new () => PersonInformation;
     }
 }
+export declare class PersonInlinePolicy {
+    constructor(companyId: Nullable<bigint> | undefined, createdAt: any/* Instant */, id: bigint, personId: bigint, statements: KtList<Policy>);
+    get companyId(): Nullable<bigint>;
+    get createdAt(): any/* Instant */;
+    get id(): bigint;
+    get personId(): bigint;
+    get statements(): KtList<Policy>;
+    copy(companyId?: Nullable<bigint>, createdAt?: any/* Instant */, id?: bigint, personId?: bigint, statements?: KtList<Policy>): PersonInlinePolicy;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace PersonInlinePolicy {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => PersonInlinePolicy;
+    }
+}
 export declare class PersonName {
     constructor(family: string, given: string, middle?: Nullable<string>);
     get family(): string;
@@ -14681,6 +16174,25 @@ export declare namespace PersonParticipant {
         const constructor: abstract new () => PersonParticipant;
     }
 }
+export declare class PersonPolicy {
+    constructor(companyId: Nullable<bigint> | undefined, createdAt: any/* Instant */, id: bigint, personId: bigint, policyId: bigint, policyName: string);
+    get companyId(): Nullable<bigint>;
+    get createdAt(): any/* Instant */;
+    get id(): bigint;
+    get personId(): bigint;
+    get policyId(): bigint;
+    get policyName(): string;
+    copy(companyId?: Nullable<bigint>, createdAt?: any/* Instant */, id?: bigint, personId?: bigint, policyId?: bigint, policyName?: string): PersonPolicy;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace PersonPolicy {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => PersonPolicy;
+    }
+}
 export declare class PersonPostalArea {
     constructor(name: string, number: string);
     get name(): string;
@@ -15010,6 +16522,85 @@ export declare namespace Ping {
         const constructor: abstract new () => Ping;
     }
 }
+export declare class Policy {
+    constructor(actions: KtList<string>, effect: Nullable<PolicyEffect> | undefined, resources: KtList<string>);
+    get actions(): KtList<string>;
+    get effect(): Nullable<PolicyEffect>;
+    get resources(): KtList<string>;
+    copy(actions?: KtList<string>, effect?: Nullable<PolicyEffect>, resources?: KtList<string>): Policy;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace Policy {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => Policy;
+    }
+}
+export declare class PolicyDocument {
+    constructor(createdAt: any/* Instant */, description: Nullable<string> | undefined, id: bigint, isSystem: boolean, name: string, statements: KtList<Policy>, updatedAt: any/* Instant */);
+    get createdAt(): any/* Instant */;
+    get description(): Nullable<string>;
+    get id(): bigint;
+    get isSystem(): boolean;
+    get name(): string;
+    get statements(): KtList<Policy>;
+    get updatedAt(): any/* Instant */;
+    copy(createdAt?: any/* Instant */, description?: Nullable<string>, id?: bigint, isSystem?: boolean, name?: string, statements?: KtList<Policy>, updatedAt?: any/* Instant */): PolicyDocument;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace PolicyDocument {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => PolicyDocument;
+    }
+}
+export declare abstract class PolicyEffect {
+    private constructor();
+    static get ALLOW(): PolicyEffect & {
+        get name(): "ALLOW";
+        get ordinal(): 0;
+    };
+    static get DENY(): PolicyEffect & {
+        get name(): "DENY";
+        get ordinal(): 1;
+    };
+    static get Allow(): PolicyEffect & {
+        get name(): "ALLOW";
+        get ordinal(): 0;
+    };
+    static get Deny(): PolicyEffect & {
+        get name(): "DENY";
+        get ordinal(): 1;
+    };
+    static values(): [typeof PolicyEffect.ALLOW, typeof PolicyEffect.DENY];
+    static valueOf(value: string): PolicyEffect;
+    get name(): "ALLOW" | "DENY";
+    get ordinal(): 0 | 1;
+    get value(): string;
+    toString(): string;
+}
+export declare namespace PolicyEffect {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => PolicyEffect;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor /* implements SerializerFactory */ {
+                fromValue(value: string): Nullable<PolicyEffect>;
+                private constructor();
+            }
+        }
+    }
+}
 export declare class Pong extends WebSocketPayload.$metadata$.constructor {
     constructor();
 }
@@ -15184,6 +16775,21 @@ export declare namespace PreferredAdvertisement {
         }
     }
 }
+export declare class PriceComponent {
+    constructor(name: string, type: string);
+    get name(): string;
+    get type(): string;
+    copy(name?: string, type?: string): PriceComponent;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace PriceComponent {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => PriceComponent;
+    }
+}
 export declare class PublicConversation {
     constructor(companyName: Nullable<string> | undefined, documents: Nullable<KtList<Document>> | undefined, events: Nullable<KtList<PublicConversationEvent>> | undefined, id: bigint, messages?: Nullable<KtList<PublicMessage>>, participants?: Nullable<KtList<Participant>>, representAsBoard?: Nullable<boolean>, title?: Nullable<string>, type?: Nullable<MessageType>, userPersonId?: Nullable<bigint>);
     get companyName(): Nullable<string>;
@@ -15244,50 +16850,307 @@ export declare namespace PublicConversationEvent {
     }
 }
 export declare class PublicMessage {
-    constructor(content: string, documents: Nullable<KtList<Document>> | undefined, emailContent: Nullable<MessageEmailContent> | undefined, renderedContent: Nullable<string> | undefined, sentAt: any/* Instant */, sentBy?: Nullable<Participant>, sentByCurrentUser?: Nullable<boolean>, type?: Nullable<MessageType>);
+    constructor(content: string, documents: Nullable<KtList<Document>> | undefined, emailContent: Nullable<MessageEmailContent> | undefined, origin: Nullable<MessageOrigin> | undefined, renderedContent: Nullable<string> | undefined, sentAt: any/* Instant */, sentBy?: Nullable<Participant>, sentByCurrentUser?: Nullable<boolean>, type?: Nullable<MessageType>);
     get content(): string;
     get documents(): Nullable<KtList<Document>>;
     get emailContent(): Nullable<MessageEmailContent>;
+    get origin(): Nullable<MessageOrigin>;
     get renderedContent(): Nullable<string>;
     get sentAt(): any/* Instant */;
     get sentBy(): Nullable<Participant>;
     get sentByCurrentUser(): Nullable<boolean>;
     get type(): Nullable<MessageType>;
-    copy(content?: string, documents?: Nullable<KtList<Document>>, emailContent?: Nullable<MessageEmailContent>, renderedContent?: Nullable<string>, sentAt?: any/* Instant */, sentBy?: Nullable<Participant>, sentByCurrentUser?: Nullable<boolean>, type?: Nullable<MessageType>): PublicMessage;
+    copy(content?: string, documents?: Nullable<KtList<Document>>, emailContent?: Nullable<MessageEmailContent>, origin?: Nullable<MessageOrigin>, renderedContent?: Nullable<string>, sentAt?: any/* Instant */, sentBy?: Nullable<Participant>, sentByCurrentUser?: Nullable<boolean>, type?: Nullable<MessageType>): PublicMessage;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace PublicMessage {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => PublicMessage;
+    }
+}
+export declare class PushNotificationDispatchEvidence {
+    constructor(clientOpenedAt: Nullable<any>/* Nullable<Instant> */ | undefined, clientReceivedAt: Nullable<any>/* Nullable<Instant> */ | undefined, companyId: bigint, correlation: Nullable<string> | undefined, createdAt: any/* Instant */, failureCode: Nullable<string> | undefined, failureDescription: Nullable<string> | undefined, id: string, jobExecutionId: Nullable<bigint> | undefined, jobId: Nullable<bigint> | undefined, notificationTrackingId: string, personId: Nullable<bigint> | undefined, providerMessageId: Nullable<string> | undefined, providerRespondedAt: Nullable<any>/* Nullable<Instant> */ | undefined, providerStatus: PushNotificationProviderStatus, recipientKind: PushNotificationRecipientKind, resolutionSource: Nullable<PushNotificationResolutionSource> | undefined, resolutionStatus: PushNotificationResolutionStatus, resolvedAt: Nullable<any>/* Nullable<Instant> */ | undefined, resolvedDeviceCount: Nullable<bigint> | undefined, resolvedDeviceTypes: Nullable<KtList<string>> | undefined, updatedAt: any/* Instant */, validationOnly: boolean);
+    get clientOpenedAt(): Nullable<any>/* Nullable<Instant> */;
+    get clientReceivedAt(): Nullable<any>/* Nullable<Instant> */;
+    get companyId(): bigint;
+    get correlation(): Nullable<string>;
+    get createdAt(): any/* Instant */;
+    get failureCode(): Nullable<string>;
+    get failureDescription(): Nullable<string>;
+    get id(): string;
+    get jobExecutionId(): Nullable<bigint>;
+    get jobId(): Nullable<bigint>;
+    get notificationTrackingId(): string;
+    get personId(): Nullable<bigint>;
+    get providerMessageId(): Nullable<string>;
+    get providerRespondedAt(): Nullable<any>/* Nullable<Instant> */;
+    get providerStatus(): PushNotificationProviderStatus;
+    get recipientKind(): PushNotificationRecipientKind;
+    get resolutionSource(): Nullable<PushNotificationResolutionSource>;
+    get resolutionStatus(): PushNotificationResolutionStatus;
+    get resolvedAt(): Nullable<any>/* Nullable<Instant> */;
+    get resolvedDeviceCount(): Nullable<bigint>;
+    get resolvedDeviceTypes(): Nullable<KtList<string>>;
+    get updatedAt(): any/* Instant */;
+    get validationOnly(): boolean;
+    copy(clientOpenedAt?: Nullable<any>/* Nullable<Instant> */, clientReceivedAt?: Nullable<any>/* Nullable<Instant> */, companyId?: bigint, correlation?: Nullable<string>, createdAt?: any/* Instant */, failureCode?: Nullable<string>, failureDescription?: Nullable<string>, id?: string, jobExecutionId?: Nullable<bigint>, jobId?: Nullable<bigint>, notificationTrackingId?: string, personId?: Nullable<bigint>, providerMessageId?: Nullable<string>, providerRespondedAt?: Nullable<any>/* Nullable<Instant> */, providerStatus?: PushNotificationProviderStatus, recipientKind?: PushNotificationRecipientKind, resolutionSource?: Nullable<PushNotificationResolutionSource>, resolutionStatus?: PushNotificationResolutionStatus, resolvedAt?: Nullable<any>/* Nullable<Instant> */, resolvedDeviceCount?: Nullable<bigint>, resolvedDeviceTypes?: Nullable<KtList<string>>, updatedAt?: any/* Instant */, validationOnly?: boolean): PushNotificationDispatchEvidence;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace PushNotificationDispatchEvidence {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => PushNotificationDispatchEvidence;
+    }
+}
+export declare class PushNotificationInboxItem {
+    constructor(body: Nullable<string> | undefined, companyId: bigint, data: Nullable<KtMap<string, Nullable<string>>> | undefined, notificationType: Nullable<string> | undefined, openedAt: Nullable<any>/* Nullable<Instant> */ | undefined, read: Nullable<boolean> | undefined, readAt: Nullable<any>/* Nullable<Instant> */ | undefined, receivedAt: Nullable<any>/* Nullable<Instant> */ | undefined, sentAt: any/* Instant */, state: Nullable<CommunicationState> | undefined, title: Nullable<string> | undefined, trackingId: string, updatedAt: any/* Instant */);
+    get body(): Nullable<string>;
+    get companyId(): bigint;
+    get data(): Nullable<KtMap<string, Nullable<string>>>;
+    get notificationType(): Nullable<string>;
+    get openedAt(): Nullable<any>/* Nullable<Instant> */;
+    get read(): Nullable<boolean>;
+    get readAt(): Nullable<any>/* Nullable<Instant> */;
+    get receivedAt(): Nullable<any>/* Nullable<Instant> */;
+    get sentAt(): any/* Instant */;
+    get state(): Nullable<CommunicationState>;
+    get title(): Nullable<string>;
+    get trackingId(): string;
+    get updatedAt(): any/* Instant */;
+    copy(body?: Nullable<string>, companyId?: bigint, data?: Nullable<KtMap<string, Nullable<string>>>, notificationType?: Nullable<string>, openedAt?: Nullable<any>/* Nullable<Instant> */, read?: Nullable<boolean>, readAt?: Nullable<any>/* Nullable<Instant> */, receivedAt?: Nullable<any>/* Nullable<Instant> */, sentAt?: any/* Instant */, state?: Nullable<CommunicationState>, title?: Nullable<string>, trackingId?: string, updatedAt?: any/* Instant */): PushNotificationInboxItem;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace PushNotificationInboxItem {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => PushNotificationInboxItem;
+    }
+}
+export declare abstract class PushNotificationProviderStatus {
+    private constructor();
+    static get NOT_ATTEMPTED(): PushNotificationProviderStatus & {
+        get name(): "NOT_ATTEMPTED";
+        get ordinal(): 0;
+    };
+    static get VALIDATED(): PushNotificationProviderStatus & {
+        get name(): "VALIDATED";
+        get ordinal(): 1;
+    };
+    static get ACCEPTED(): PushNotificationProviderStatus & {
+        get name(): "ACCEPTED";
+        get ordinal(): 2;
+    };
+    static get REJECTED(): PushNotificationProviderStatus & {
+        get name(): "REJECTED";
+        get ordinal(): 3;
+    };
+    static get UNKNOWN(): PushNotificationProviderStatus & {
+        get name(): "UNKNOWN";
+        get ordinal(): 4;
+    };
+    static get NotAttempted(): PushNotificationProviderStatus & {
+        get name(): "NOT_ATTEMPTED";
+        get ordinal(): 0;
+    };
+    static get Validated(): PushNotificationProviderStatus & {
+        get name(): "VALIDATED";
+        get ordinal(): 1;
+    };
+    static get Accepted(): PushNotificationProviderStatus & {
+        get name(): "ACCEPTED";
+        get ordinal(): 2;
+    };
+    static get Rejected(): PushNotificationProviderStatus & {
+        get name(): "REJECTED";
+        get ordinal(): 3;
+    };
+    static get Unknown(): PushNotificationProviderStatus & {
+        get name(): "UNKNOWN";
+        get ordinal(): 4;
+    };
+    static values(): [typeof PushNotificationProviderStatus.NOT_ATTEMPTED, typeof PushNotificationProviderStatus.VALIDATED, typeof PushNotificationProviderStatus.ACCEPTED, typeof PushNotificationProviderStatus.REJECTED, typeof PushNotificationProviderStatus.UNKNOWN];
+    static valueOf(value: string): PushNotificationProviderStatus;
+    get name(): "NOT_ATTEMPTED" | "VALIDATED" | "ACCEPTED" | "REJECTED" | "UNKNOWN";
+    get ordinal(): 0 | 1 | 2 | 3 | 4;
+    get value(): string;
+    toString(): string;
+}
+export declare namespace PushNotificationProviderStatus {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => PushNotificationProviderStatus;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor /* implements SerializerFactory */ {
+                fromValue(value: string): Nullable<PushNotificationProviderStatus>;
+                private constructor();
+            }
+        }
+    }
+}
+export declare abstract class PushNotificationRecipientKind {
+    private constructor();
+    static get PERSON(): PushNotificationRecipientKind & {
+        get name(): "PERSON";
+        get ordinal(): 0;
+    };
+    static get DIRECT_TARGET(): PushNotificationRecipientKind & {
+        get name(): "DIRECT_TARGET";
+        get ordinal(): 1;
+    };
+    static get Person(): PushNotificationRecipientKind & {
+        get name(): "PERSON";
+        get ordinal(): 0;
+    };
+    static get DirectTarget(): PushNotificationRecipientKind & {
+        get name(): "DIRECT_TARGET";
+        get ordinal(): 1;
+    };
+    static values(): [typeof PushNotificationRecipientKind.PERSON, typeof PushNotificationRecipientKind.DIRECT_TARGET];
+    static valueOf(value: string): PushNotificationRecipientKind;
+    get name(): "PERSON" | "DIRECT_TARGET";
+    get ordinal(): 0 | 1;
+    get value(): string;
+    toString(): string;
+}
+export declare namespace PushNotificationRecipientKind {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => PushNotificationRecipientKind;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor /* implements SerializerFactory */ {
+                fromValue(value: string): Nullable<PushNotificationRecipientKind>;
+                private constructor();
+            }
+        }
+    }
+}
+export declare abstract class PushNotificationResolutionSource {
+    private constructor();
+    static get EXPLICIT_TARGET(): PushNotificationResolutionSource & {
+        get name(): "EXPLICIT_TARGET";
+        get ordinal(): 0;
+    };
+    static get FCM_NOTIFICATION_GROUP(): PushNotificationResolutionSource & {
+        get name(): "FCM_NOTIFICATION_GROUP";
+        get ordinal(): 1;
+    };
+    static get STORED_DEVICE_TOKENS(): PushNotificationResolutionSource & {
+        get name(): "STORED_DEVICE_TOKENS";
+        get ordinal(): 2;
+    };
+    static get ExplicitTarget(): PushNotificationResolutionSource & {
+        get name(): "EXPLICIT_TARGET";
+        get ordinal(): 0;
+    };
+    static get FcmNotificationGroup(): PushNotificationResolutionSource & {
+        get name(): "FCM_NOTIFICATION_GROUP";
+        get ordinal(): 1;
+    };
+    static get StoredDeviceTokens(): PushNotificationResolutionSource & {
+        get name(): "STORED_DEVICE_TOKENS";
+        get ordinal(): 2;
+    };
+    static values(): [typeof PushNotificationResolutionSource.EXPLICIT_TARGET, typeof PushNotificationResolutionSource.FCM_NOTIFICATION_GROUP, typeof PushNotificationResolutionSource.STORED_DEVICE_TOKENS];
+    static valueOf(value: string): PushNotificationResolutionSource;
+    get name(): "EXPLICIT_TARGET" | "FCM_NOTIFICATION_GROUP" | "STORED_DEVICE_TOKENS";
+    get ordinal(): 0 | 1 | 2;
+    get value(): string;
     toString(): string;
-    hashCode(): number;
-    equals(other: Nullable<any>): boolean;
 }
-export declare namespace PublicMessage {
+export declare namespace PushNotificationResolutionSource {
     /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
     namespace $metadata$ {
-        const constructor: abstract new () => PublicMessage;
+        const constructor: abstract new () => PushNotificationResolutionSource;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor /* implements SerializerFactory */ {
+                fromValue(value: string): Nullable<PushNotificationResolutionSource>;
+                private constructor();
+            }
+        }
     }
 }
-export declare class PushNotificationInboxItem {
-    constructor(body: Nullable<string> | undefined, companyId: bigint, data: Nullable<KtMap<string, Nullable<string>>> | undefined, notificationType: Nullable<string> | undefined, openedAt: Nullable<any>/* Nullable<Instant> */ | undefined, read: Nullable<boolean> | undefined, readAt: Nullable<any>/* Nullable<Instant> */ | undefined, receivedAt: Nullable<any>/* Nullable<Instant> */ | undefined, sentAt: any/* Instant */, state: Nullable<CommunicationState> | undefined, title: Nullable<string> | undefined, trackingId: string, updatedAt: any/* Instant */);
-    get body(): Nullable<string>;
-    get companyId(): bigint;
-    get data(): Nullable<KtMap<string, Nullable<string>>>;
-    get notificationType(): Nullable<string>;
-    get openedAt(): Nullable<any>/* Nullable<Instant> */;
-    get read(): Nullable<boolean>;
-    get readAt(): Nullable<any>/* Nullable<Instant> */;
-    get receivedAt(): Nullable<any>/* Nullable<Instant> */;
-    get sentAt(): any/* Instant */;
-    get state(): Nullable<CommunicationState>;
-    get title(): Nullable<string>;
-    get trackingId(): string;
-    get updatedAt(): any/* Instant */;
-    copy(body?: Nullable<string>, companyId?: bigint, data?: Nullable<KtMap<string, Nullable<string>>>, notificationType?: Nullable<string>, openedAt?: Nullable<any>/* Nullable<Instant> */, read?: Nullable<boolean>, readAt?: Nullable<any>/* Nullable<Instant> */, receivedAt?: Nullable<any>/* Nullable<Instant> */, sentAt?: any/* Instant */, state?: Nullable<CommunicationState>, title?: Nullable<string>, trackingId?: string, updatedAt?: any/* Instant */): PushNotificationInboxItem;
+export declare abstract class PushNotificationResolutionStatus {
+    private constructor();
+    static get PENDING(): PushNotificationResolutionStatus & {
+        get name(): "PENDING";
+        get ordinal(): 0;
+    };
+    static get NO_DEVICE(): PushNotificationResolutionStatus & {
+        get name(): "NO_DEVICE";
+        get ordinal(): 1;
+    };
+    static get RESOLVED(): PushNotificationResolutionStatus & {
+        get name(): "RESOLVED";
+        get ordinal(): 2;
+    };
+    static get RESOLUTION_FAILED(): PushNotificationResolutionStatus & {
+        get name(): "RESOLUTION_FAILED";
+        get ordinal(): 3;
+    };
+    static get Pending(): PushNotificationResolutionStatus & {
+        get name(): "PENDING";
+        get ordinal(): 0;
+    };
+    static get NoDevice(): PushNotificationResolutionStatus & {
+        get name(): "NO_DEVICE";
+        get ordinal(): 1;
+    };
+    static get Resolved(): PushNotificationResolutionStatus & {
+        get name(): "RESOLVED";
+        get ordinal(): 2;
+    };
+    static get ResolutionFailed(): PushNotificationResolutionStatus & {
+        get name(): "RESOLUTION_FAILED";
+        get ordinal(): 3;
+    };
+    static values(): [typeof PushNotificationResolutionStatus.PENDING, typeof PushNotificationResolutionStatus.NO_DEVICE, typeof PushNotificationResolutionStatus.RESOLVED, typeof PushNotificationResolutionStatus.RESOLUTION_FAILED];
+    static valueOf(value: string): PushNotificationResolutionStatus;
+    get name(): "PENDING" | "NO_DEVICE" | "RESOLVED" | "RESOLUTION_FAILED";
+    get ordinal(): 0 | 1 | 2 | 3;
+    get value(): string;
     toString(): string;
-    hashCode(): number;
-    equals(other: Nullable<any>): boolean;
 }
-export declare namespace PushNotificationInboxItem {
+export declare namespace PushNotificationResolutionStatus {
     /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
     namespace $metadata$ {
-        const constructor: abstract new () => PushNotificationInboxItem;
+        const constructor: abstract new () => PushNotificationResolutionStatus;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor /* implements SerializerFactory */ {
+                fromValue(value: string): Nullable<PushNotificationResolutionStatus>;
+                private constructor();
+            }
+        }
     }
 }
 export declare class PutCommunicationReactionCommand {
@@ -15491,6 +17354,25 @@ export declare namespace ReorderIssueInMeetingCommand {
         const constructor: abstract new () => ReorderIssueInMeetingCommand;
     }
 }
+export declare class RepairOwnerRolesResult {
+    constructor(ambiguousOrgsSkipped: bigint, ambiguousPersonsSkipped: bigint, duplicateRolesDeleted: bigint, kartverketScanSkipped: Nullable<boolean> | undefined, orphanOrgOwnerRolesLinked: bigint, orphanPersonOwnerRolesLinked: bigint);
+    get ambiguousOrgsSkipped(): bigint;
+    get ambiguousPersonsSkipped(): bigint;
+    get duplicateRolesDeleted(): bigint;
+    get kartverketScanSkipped(): Nullable<boolean>;
+    get orphanOrgOwnerRolesLinked(): bigint;
+    get orphanPersonOwnerRolesLinked(): bigint;
+    copy(ambiguousOrgsSkipped?: bigint, ambiguousPersonsSkipped?: bigint, duplicateRolesDeleted?: bigint, kartverketScanSkipped?: Nullable<boolean>, orphanOrgOwnerRolesLinked?: bigint, orphanPersonOwnerRolesLinked?: bigint): RepairOwnerRolesResult;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace RepairOwnerRolesResult {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => RepairOwnerRolesResult;
+    }
+}
 export declare abstract class Resident {
     private constructor();
     abstract get accountNumber(): Nullable<string>;
@@ -15737,6 +17619,23 @@ export declare namespace Role {
         const constructor: abstract new () => Role;
     }
 }
+export declare class RoleInlinePolicy {
+    constructor(createdAt: any/* Instant */, id: bigint, roleId: bigint, statements: KtList<Policy>);
+    get createdAt(): any/* Instant */;
+    get id(): bigint;
+    get roleId(): bigint;
+    get statements(): KtList<Policy>;
+    copy(createdAt?: any/* Instant */, id?: bigint, roleId?: bigint, statements?: KtList<Policy>): RoleInlinePolicy;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace RoleInlinePolicy {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => RoleInlinePolicy;
+    }
+}
 export declare class RoleInput {
     constructor(companyId: Nullable<bigint> | undefined, id: Nullable<bigint> | undefined, organizationId: Nullable<bigint> | undefined, personId: Nullable<bigint> | undefined, sectionId: Nullable<bigint> | undefined, supplierId: Nullable<bigint> | undefined, type: RoleType, validFrom?: Nullable<any>/* Nullable<Instant> */, validTo?: Nullable<any>/* Nullable<Instant> */);
     get companyId(): Nullable<bigint>;
@@ -16010,6 +17909,25 @@ export declare namespace RoleType {
         }
     }
 }
+export declare class RoleTypePolicy {
+    constructor(createdAt: any/* Instant */, id: bigint, policyId: bigint, policyName: string, priority: bigint, roleType: string);
+    get createdAt(): any/* Instant */;
+    get id(): bigint;
+    get policyId(): bigint;
+    get policyName(): string;
+    get priority(): bigint;
+    get roleType(): string;
+    copy(createdAt?: any/* Instant */, id?: bigint, policyId?: bigint, policyName?: string, priority?: bigint, roleType?: string): RoleTypePolicy;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace RoleTypePolicy {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => RoleTypePolicy;
+    }
+}
 export declare class Routine {
     constructor(completedAt: Nullable<any>/* Nullable<Instant> */ | undefined, completedBy: Nullable<bigint> | undefined, completedName: Nullable<string> | undefined, createdAt: any/* Instant */, createdBy: Nullable<bigint> | undefined, createdByClientUserId: Nullable<bigint> | undefined, createdByClientUserName: Nullable<string> | undefined, createdByName: Nullable<string> | undefined, deletedAt: Nullable<any>/* Nullable<Instant> */ | undefined, deletedBy: Nullable<bigint> | undefined, deletedName: Nullable<string> | undefined, description: Nullable<string> | undefined, documents: Nullable<KtList<Document>> | undefined, draft: Nullable<RoutineDraft> | undefined, dueDate: Nullable<any>/* Nullable<Instant> */ | undefined, dueDateOffset: Nullable<bigint> | undefined, id: bigint, log: Nullable<KtList<TaskEvent>> | undefined, recommendedIntervalMethod: RoutineMethod, recommendedIntervalType: RoutineInterval, recommendedIntervalValue: bigint, responsibleId: Nullable<bigint> | undefined, responsibleName: Nullable<string> | undefined, supplier: Nullable<Supplier> | undefined, svgName: string, taskId: Nullable<bigint> | undefined, title: Nullable<string> | undefined, type: RoutineType);
     get completedAt(): Nullable<any>/* Nullable<Instant> */;
@@ -17475,6 +19393,25 @@ export declare namespace SentLetter {
         const constructor: abstract new () => SentLetter;
     }
 }
+export declare class SesVerdicts {
+    constructor(dkim?: Nullable<string>, dmarc?: Nullable<string>, messageId?: Nullable<string>, spam?: Nullable<string>, spf?: Nullable<string>, virus?: Nullable<string>);
+    get dkim(): Nullable<string>;
+    get dmarc(): Nullable<string>;
+    get messageId(): Nullable<string>;
+    get spam(): Nullable<string>;
+    get spf(): Nullable<string>;
+    get virus(): Nullable<string>;
+    copy(dkim?: Nullable<string>, dmarc?: Nullable<string>, messageId?: Nullable<string>, spam?: Nullable<string>, spf?: Nullable<string>, virus?: Nullable<string>): SesVerdicts;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace SesVerdicts {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => SesVerdicts;
+    }
+}
 export declare class SetSupplierCommentEmoticonCommand {
     constructor(emoticon?: Nullable<string>);
     get emoticon(): Nullable<string>;
@@ -18180,6 +20117,31 @@ export declare namespace StorageRoomVacant {
         const constructor: abstract new () => StorageRoomVacant;
     }
 }
+export declare class StrexMessageStatus {
+    constructor(billed?: Nullable<boolean>, correlationId?: Nullable<string>, delivered?: Nullable<boolean>, detailedStatusCode?: Nullable<string>, operatorId?: Nullable<string>, price?: Nullable<number>, recipient?: Nullable<string>, sender?: Nullable<string>, smscMessageParts?: Nullable<bigint>, smscTransactionId?: Nullable<string>, statusCode?: Nullable<string>, transactionId?: Nullable<string>);
+    get billed(): Nullable<boolean>;
+    get correlationId(): Nullable<string>;
+    get delivered(): Nullable<boolean>;
+    get detailedStatusCode(): Nullable<string>;
+    get operatorId(): Nullable<string>;
+    get price(): Nullable<number>;
+    get recipient(): Nullable<string>;
+    get sender(): Nullable<string>;
+    get smscMessageParts(): Nullable<bigint>;
+    get smscTransactionId(): Nullable<string>;
+    get statusCode(): Nullable<string>;
+    get transactionId(): Nullable<string>;
+    copy(billed?: Nullable<boolean>, correlationId?: Nullable<string>, delivered?: Nullable<boolean>, detailedStatusCode?: Nullable<string>, operatorId?: Nullable<string>, price?: Nullable<number>, recipient?: Nullable<string>, sender?: Nullable<string>, smscMessageParts?: Nullable<bigint>, smscTransactionId?: Nullable<string>, statusCode?: Nullable<string>, transactionId?: Nullable<string>): StrexMessageStatus;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace StrexMessageStatus {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => StrexMessageStatus;
+    }
+}
 export declare class Supplier {
     constructor(companyCount: Nullable<bigint> | undefined, domain: Nullable<string> | undefined, id: bigint, logoUrl: Nullable<string> | undefined, name: string, orgNr: string, serviceCategories: KtList<string>);
     get companyCount(): Nullable<bigint>;
@@ -19760,6 +21722,20 @@ export declare namespace UpdateConversationSettingsCommand {
         const constructor: abstract new () => UpdateConversationSettingsCommand;
     }
 }
+export declare class UpdateDocumentContentSearchEntitlementCommand {
+    constructor(enabled: boolean);
+    get enabled(): boolean;
+    copy(enabled?: boolean): UpdateDocumentContentSearchEntitlementCommand;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace UpdateDocumentContentSearchEntitlementCommand {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => UpdateDocumentContentSearchEntitlementCommand;
+    }
+}
 export declare class UpdateEmployeeCommand {
     constructor(email: Nullable<string> | undefined, mobile: Nullable<string> | undefined, name: Name, nationality?: Nullable<bigint>, preferredLanguage?: Nullable<bigint>);
     get email(): Nullable<string>;
@@ -20376,6 +22352,22 @@ export declare namespace UpdatePersonResidentCommand {
         const constructor: abstract new () => UpdatePersonResidentCommand;
     }
 }
+export declare class UpdatePolicyDocumentCommand {
+    constructor(description?: Nullable<string>, name?: Nullable<string>, statements?: Nullable<KtList<Policy>>);
+    get description(): Nullable<string>;
+    get name(): Nullable<string>;
+    get statements(): Nullable<KtList<Policy>>;
+    copy(description?: Nullable<string>, name?: Nullable<string>, statements?: Nullable<KtList<Policy>>): UpdatePolicyDocumentCommand;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace UpdatePolicyDocumentCommand {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => UpdatePolicyDocumentCommand;
+    }
+}
 export declare class UpdatePostCommand {
     constructor(commentsEnabled: Nullable<boolean> | undefined, content: string, notificationEmailGroups: Nullable<KtList<NotificationGroup>> | undefined, notificationSMSGroups: Nullable<KtList<NotificationGroup>> | undefined, pictureDocumentId: Nullable<bigint> | undefined, pinned: Nullable<boolean> | undefined, _private: Nullable<boolean> | undefined, publishedAt: Nullable<any>/* Nullable<Instant> */ | undefined, title: string, weighting?: Nullable<bigint>);
     get commentsEnabled(): Nullable<boolean>;
@@ -20468,6 +22460,20 @@ export declare namespace UpdateResolutionCommand {
         const constructor: abstract new () => UpdateResolutionCommand;
     }
 }
+export declare class UpdateRolesCommand {
+    constructor(roles: KtList<RoleInput>);
+    get roles(): KtList<RoleInput>;
+    copy(roles?: KtList<RoleInput>): UpdateRolesCommand;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace UpdateRolesCommand {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => UpdateRolesCommand;
+    }
+}
 export declare class UpdateRoutineCommand {
     constructor(description: Nullable<string> | undefined, dueDateOffset: Nullable<bigint> | undefined, recommendedIntervalMethod: Nullable<RoutineMethod> | undefined, recommendedIntervalType: RoutineInterval, recommendedIntervalValue: Nullable<bigint> | undefined, requiresSupplier: boolean, responsibleId: Nullable<bigint> | undefined, startDate: Nullable<any>/* Nullable<Instant> */ | undefined, supplierId: Nullable<bigint> | undefined, svgName: string, title?: Nullable<string>);
     get description(): Nullable<string>;
@@ -21015,6 +23021,88 @@ export declare namespace AccountingApi {
         const constructor: abstract new () => AccountingApi;
     }
 }
+export declare class AdministrationApi extends ApiClient.$metadata$.constructor {
+    private constructor();
+    static create(baseUrl?: string, httpClientEngine?: Nullable<any>/* Nullable<HttpClientEngine> */, httpClientConfig?: Nullable<(p0: any/* HttpClientConfig<UnknownType *> */) => void>, jsonSerializer?: any/* Json */): AdministrationApi;
+    static createWithClient(baseUrl: string, httpClient: any/* HttpClient */): AdministrationApi;
+    altinnSystembrukerKvitteringGet(): Promise<HttpResponse<void>>;
+    createAdminCompanyFromSales(createCompany: CreateCompany): Promise<HttpResponse<Company>>;
+    listAdminTripletexAccounts(fields?: Nullable<string>): Promise<HttpResponse<KtMap<string, AccountList>>>;
+    loadAdminGeneratedSalesData(company: string): Promise<HttpResponse<void>>;
+    mgmtAdminAltinnSystemGet(fields?: Nullable<string>): Promise<HttpResponse<AltinnSystemRegisterInput>>;
+    mgmtAdminAltinnSystemPost(): Promise<HttpResponse<boolean>>;
+    mgmtAdminAltinnSystemPut(): Promise<HttpResponse<boolean>>;
+    mgmtAdminAltinnSystemUserAgentGet(orgNr?: Nullable<string>, fields?: Nullable<string>): Promise<HttpResponse<AltinnSystemUserRequestResult>>;
+    mgmtAdminAltinnSystemUserAgentPost(orgNr?: Nullable<string>): Promise<HttpResponse<AltinnSystemUserRequestResult>>;
+    mgmtAdminAltinnSystemUserGet(fields?: Nullable<string>): Promise<HttpResponse<AltinnSystemUserRequestResult>>;
+    mgmtAdminAltinnSystemUserPost(): Promise<HttpResponse<AltinnSystemUserRequestResult>>;
+    mgmtAdminBoligselskapCompanyIdDocumentContentSearchGet(companyId: bigint, fields?: Nullable<string>): Promise<HttpResponse<DocumentContentSearchEntitlement>>;
+    mgmtAdminBoligselskapCompanyIdDocumentContentSearchPut(companyId: bigint, updateDocumentContentSearchEntitlementCommand: UpdateDocumentContentSearchEntitlementCommand): Promise<HttpResponse<DocumentContentSearchEntitlement>>;
+    mgmtAdminBoligselskapCompanyIdDocumentContentSearchReindexPost(companyId: bigint): Promise<HttpResponse<DocumentContentSearchEntitlement>>;
+    mgmtAdminBoligselskapCompanyIdRePopulateKartverketPost(companyId: bigint): Promise<HttpResponse<void>>;
+    mgmtAdminBoligselskapCompanyIdRepairOwnerRolesPost(companyId: bigint): Promise<HttpResponse<RepairOwnerRolesResult>>;
+    mgmtAdminBoligselskapCreateAuxiliaryDataForCompanyCompanyIdPost(companyId: bigint, company: string): Promise<HttpResponse<void>>;
+    mgmtAdminBoligselskapGenghisExportPost(): Promise<HttpResponse<void>>;
+    mgmtAdminBoligselskapRePopulateKartverketPost(company: string, bulkRetroactiveKartverketCommand: BulkRetroactiveKartverketCommand): Promise<HttpResponse<BulkRetroactiveKartverketResult>>;
+    mgmtAdminBroadcastPost(genericPayload: GenericPayload): Promise<HttpResponse<void>>;
+    mgmtAdminClientUsersClientUserIdCompanyScopesCompanyScopeIdDelete(clientUserId: bigint, companyScopeId: bigint, companyScopes: string): Promise<HttpResponse<void>>;
+    mgmtAdminClientUsersClientUserIdCompanyScopesGet(clientUserId: bigint, fields?: Nullable<string>): Promise<HttpResponse<KtList<ClientUserCompanyScope>>>;
+    mgmtAdminClientUsersClientUserIdCompanyScopesPost(clientUserId: bigint, createClientUserCompanyScopeCommand: CreateClientUserCompanyScopeCommand): Promise<HttpResponse<ClientUserCompanyScope>>;
+    mgmtAdminClientUsersClientUserIdScopesGet(clientUserId: bigint, fields?: Nullable<string>): Promise<HttpResponse<KtList<ClientUserScope>>>;
+    mgmtAdminClientUsersClientUserIdScopesPost(clientUserId: bigint, createClientUserScopeCommand: CreateClientUserScopeCommand): Promise<HttpResponse<ClientUserScope>>;
+    mgmtAdminClientUsersClientUserIdScopesScopeIdDelete(clientUserId: bigint, scopeId: bigint): Promise<HttpResponse<void>>;
+    mgmtAdminConversationEventDocumentsBackfillPost(batchSize?: Nullable<number>, maxBatches?: Nullable<number>, dryRun?: Nullable<boolean>): Promise<HttpResponse<bigint>>;
+    mgmtAdminDialogportenDialogsDialogIdGet(dialogId: string, systemAgentOrgnr?: Nullable<string>, fields?: Nullable<string>): Promise<HttpResponse<AltinnDialogList>>;
+    mgmtAdminDialogportenDialogsDialogIdTransmissionsGet(dialogId: bigint, systemAgentOrgnr?: Nullable<string>, fields?: Nullable<string>): Promise<HttpResponse<AltinnDialogList>>;
+    mgmtAdminDialogportenDialogsDialogIdTransmissionsTransmissionIdGet(dialogId: bigint, transmissionId: string, systemAgentOrgnr?: Nullable<string>, fields?: Nullable<string>): Promise<HttpResponse<AltinnDialogList>>;
+    mgmtAdminDialogportenDialogsGet(orgNr?: Nullable<string>, systemAgentOrgnr?: Nullable<string>, serviceResource?: Nullable<string>, org?: Nullable<string>, fields?: Nullable<string>): Promise<HttpResponse<AltinnDialogList>>;
+    mgmtAdminEcoguardCustomerCustomerIdGet(customerId: string, from: bigint, fields?: Nullable<string>): Promise<HttpResponse<KtList<EcoguardSectionData>>>;
+    mgmtAdminHungJobsPost(): Promise<HttpResponse<KtList<bigint>>>;
+    mgmtAdminIncomingMailTypePost(type: string): Promise<HttpResponse<void>>;
+    mgmtAdminMigrateHomepageContentPost(): Promise<HttpResponse<void>>;
+    mgmtAdminOrganizationEnrichPost(organizations: string): Promise<HttpResponse<void>>;
+    mgmtAdminOrganizationGenghisExportPost(): Promise<HttpResponse<void>>;
+    mgmtAdminOrganizationRefreshPost(organizations: string): Promise<HttpResponse<void>>;
+    mgmtAdminPeriodicJobsPeriodicJobIdRunPost(periodicJobId: bigint): Promise<HttpResponse<void>>;
+    mgmtAdminPersonGenghisExportMissingPost(): Promise<HttpResponse<void>>;
+    mgmtAdminPersonGenghisExportPost(dryRun?: Nullable<boolean>): Promise<HttpResponse<void>>;
+    mgmtAdminPersonGenghisMissingGet(fields?: Nullable<string>): Promise<HttpResponse<KtList<Person>>>;
+    mgmtAdminPersonGenghisOrphansDelete(): Promise<HttpResponse<void>>;
+    mgmtAdminPersonGenghisOrphansGet(fields?: Nullable<string>): Promise<HttpResponse<KtList<bigint>>>;
+    mgmtAdminPersonPersonIdRollerPut(personId: bigint, updateRolesCommand: UpdateRolesCommand): Promise<HttpResponse<Person>>;
+    mgmtAdminPersonsPersonIdInlinePoliciesGet(personId: bigint, fields?: Nullable<string>): Promise<HttpResponse<KtList<PersonInlinePolicy>>>;
+    mgmtAdminPersonsPersonIdInlinePoliciesInlinePolicyIdDelete(personId: bigint, inlinePolicyId: bigint, personInlinePolicies: string): Promise<HttpResponse<void>>;
+    mgmtAdminPersonsPersonIdInlinePoliciesPost(personId: bigint, createPersonInlinePolicyCommand: CreatePersonInlinePolicyCommand): Promise<HttpResponse<PersonInlinePolicy>>;
+    mgmtAdminPersonsPersonIdPoliciesGet(personId: bigint, fields?: Nullable<string>): Promise<HttpResponse<KtList<PersonPolicy>>>;
+    mgmtAdminPersonsPersonIdPoliciesPolicyIdDelete(personId: bigint, policyId: bigint, personPolicies: string, companyId?: Nullable<bigint>): Promise<HttpResponse<void>>;
+    mgmtAdminPersonsPersonIdPoliciesPost(personId: bigint, attachPersonPolicyCommand: AttachPersonPolicyCommand): Promise<HttpResponse<PersonPolicy>>;
+    mgmtAdminPoliciesGet(fields?: Nullable<string>): Promise<HttpResponse<KtList<PolicyDocument>>>;
+    mgmtAdminPoliciesPolicyIdDelete(policyId: bigint): Promise<HttpResponse<void>>;
+    mgmtAdminPoliciesPolicyIdGet(policyId: bigint, fields?: Nullable<string>): Promise<HttpResponse<PolicyDocument>>;
+    mgmtAdminPoliciesPolicyIdPut(policyId: bigint, updatePolicyDocumentCommand: UpdatePolicyDocumentCommand): Promise<HttpResponse<PolicyDocument>>;
+    mgmtAdminPoliciesPost(createPolicyDocumentCommand: CreatePolicyDocumentCommand): Promise<HttpResponse<PolicyDocument>>;
+    mgmtAdminRoleTypesRoleTypePoliciesGet(roleType: string, fields?: Nullable<string>): Promise<HttpResponse<KtList<RoleTypePolicy>>>;
+    mgmtAdminRoleTypesRoleTypePoliciesPolicyIdDelete(roleType: string, policyId: bigint, roleTypePolicies: string): Promise<HttpResponse<void>>;
+    mgmtAdminRoleTypesRoleTypePoliciesPost(roleType: string, attachRoleTypePolicyRequest: AttachRoleTypePolicyRequest): Promise<HttpResponse<RoleTypePolicy>>;
+    mgmtAdminRolesRoleIdInlinePoliciesGet(roleId: bigint, fields?: Nullable<string>): Promise<HttpResponse<KtList<RoleInlinePolicy>>>;
+    mgmtAdminRolesRoleIdInlinePoliciesInlinePolicyIdDelete(roleId: bigint, inlinePolicyId: bigint, roleInlinePolicies: string): Promise<HttpResponse<void>>;
+    mgmtAdminRolesRoleIdInlinePoliciesPost(roleId: bigint, createRoleInlinePolicyRequest: CreateRoleInlinePolicyRequest): Promise<HttpResponse<RoleInlinePolicy>>;
+    mgmtAdminRollerGet(fields?: Nullable<string>): Promise<HttpResponse<KtList<RoleType>>>;
+    mgmtAdminSesEventsPost(): Promise<HttpResponse<void>>;
+    mgmtAdminSettlementsInvoicePost(adHocSettlementInvoiceListCommand: AdHocSettlementInvoiceListCommand, dryRun?: Nullable<boolean>): Promise<HttpResponse<KtMap<string, number>>>;
+    mgmtAdminSmsReceiptUniqueIdPost(uniqueId: string, strexMessageStatus: StrexMessageStatus): Promise<HttpResponse<void>>;
+    mgmtAdminThirdpartyinformationStatusPost(): Promise<HttpResponse<KtMap<string, string>>>;
+    mgmtAdminTripletexAccountantsGet(fields?: Nullable<string>): Promise<HttpResponse<string>>;
+    mgmtAdminTripletexAccountsReportGet(numbers: string, year: string, fields?: Nullable<string>): Promise<HttpResponse<string>>;
+    mgmtAdminTripletexCompaniesGet(fields?: Nullable<string>): Promise<HttpResponse<KtList<Company>>>;
+    mgmtAdminTripletexCompaniesOrgsGet(fields?: Nullable<string>): Promise<HttpResponse<KtList<string>>>;
+}
+export declare namespace AdministrationApi {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AdministrationApi;
+    }
+}
 export declare class AppStoresApi extends ApiClient.$metadata$.constructor {
     private constructor();
     static create(baseUrl?: string, httpClientEngine?: Nullable<any>/* Nullable<HttpClientEngine> */, httpClientConfig?: Nullable<(p0: any/* HttpClientConfig<UnknownType *> */) => void>, jsonSerializer?: any/* Json */): AppStoresApi;
@@ -21088,6 +23176,7 @@ export declare class CommunicationApi extends ApiClient.$metadata$.constructor {
     private constructor();
     static create(baseUrl?: string, httpClientEngine?: Nullable<any>/* Nullable<HttpClientEngine> */, httpClientConfig?: Nullable<(p0: any/* HttpClientConfig<UnknownType *> */) => void>, jsonSerializer?: any/* Json */): CommunicationApi;
     static createWithClient(baseUrl: string, httpClient: any/* HttpClient */): CommunicationApi;
+    companiesCompanyIdCommunicationReportPushDispatchesGet(companyId: bigint, correlation?: Nullable<string>, personId?: Nullable<bigint>, resolutionStatus?: Nullable<PushNotificationResolutionStatus>, providerStatus?: Nullable<PushNotificationProviderStatus>, createdAtFrom?: Nullable<bigint>, createdAtTo?: Nullable<bigint>, fields?: Nullable<string>, pageToken?: Nullable<string>, autoPaginate?: Nullable<boolean>, count?: Nullable<number>): Promise<HttpResponse<PagedListPushNotificationDispatchEvidence>>;
     createEmailNewsletter(companyId: bigint, createNewsletterCommand: CreateNewsletterCommand): Promise<HttpResponse<Newsletter>>;
     createLetter(sendLetterCommand: SendLetterCommand): Promise<HttpResponse<SentLetter>>;
     createLetterInCompany(companyId: bigint, sendLetterCommand: SendLetterCommand): Promise<HttpResponse<SentLetter>>;
@@ -21129,6 +23218,19 @@ export declare namespace CommunicationApi {
         const constructor: abstract new () => CommunicationApi;
     }
 }
+export declare class CompaniesApi extends ApiClient.$metadata$.constructor {
+    private constructor();
+    static create(baseUrl?: string, httpClientEngine?: Nullable<any>/* Nullable<HttpClientEngine> */, httpClientConfig?: Nullable<(p0: any/* HttpClientConfig<UnknownType *> */) => void>, jsonSerializer?: any/* Json */): CompaniesApi;
+    static createWithClient(baseUrl: string, httpClient: any/* HttpClient */): CompaniesApi;
+    companiesCompanyIdDelete(companyId: bigint): Promise<HttpResponse<void>>;
+    companiesCompanyIdIncomingEmailGet(companyId: bigint, fields?: Nullable<string>): Promise<HttpResponse<KtList<IncominMail>>>;
+}
+export declare namespace CompaniesApi {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => CompaniesApi;
+    }
+}
 export declare class CompanyApi extends ApiClient.$metadata$.constructor {
     private constructor();
     static create(baseUrl?: string, httpClientEngine?: Nullable<any>/* Nullable<HttpClientEngine> */, httpClientConfig?: Nullable<(p0: any/* HttpClientConfig<UnknownType *> */) => void>, jsonSerializer?: any/* Json */): CompanyApi;
@@ -21179,6 +23281,7 @@ export declare class ConversationApi extends ApiClient.$metadata$.constructor {
     authorizePublicConversation(companySlug: string, conversationId: bigint): Promise<HttpResponse<void>>;
     authorizePublicConversationByToken(companySlug: string, conversationId: bigint, token: string): Promise<HttpResponse<void>>;
     completeMultipleConversations(companyId: bigint, batchConversationStateCommand: BatchConversationStateCommand): Promise<HttpResponse<void>>;
+    countConversationsInCompany(companyId: bigint, search?: Nullable<string>, status?: Nullable<KtList<ConversationApi.StatusCountConversationsInCompany>>, category?: Nullable<KtList<bigint>>, assignedToUserId?: Nullable<KtList<bigint>>, latestPublicMessageSide?: Nullable<KtList<ConversationApi.LatestPublicMessageSideCountConversationsInCompany>>, hasAttachments?: Nullable<boolean>, folderIds?: Nullable<KtList<bigint>>, onlyRoot?: Nullable<boolean>, byParticipant?: Nullable<KtList<bigint>>, byParticipantType?: Nullable<KtList<ConversationApi.ByParticipantTypeCountConversationsInCompany>>, createdSince?: Nullable<bigint>, updatedSince?: Nullable<bigint>, flaggedByCurrentUser?: Nullable<boolean>, readByCurrentUser?: Nullable<boolean>, fields?: Nullable<string>): Promise<HttpResponse<ConversationCount>>;
     createConversation(companyId: bigint, createConversationCommand: CreateConversationCommand): Promise<HttpResponse<Conversation>>;
     createConversationCategory(companyId: bigint, createConversationCategoryCommand: CreateConversationCategoryCommand): Promise<HttpResponse<SecureConversationCategory>>;
     createConversationExternalParticipant(companyId: bigint, conversationId: bigint, addExternalConversationParticipantCommand: AddExternalConversationParticipantCommand): Promise<HttpResponse<void>>;
@@ -21211,17 +23314,19 @@ export declare class ConversationApi extends ApiClient.$metadata$.constructor {
     getMessageFullEmailContent(companyId: bigint, conversationId: bigint, messageId: bigint, fields?: Nullable<string>): Promise<HttpResponse<FullEmailContent>>;
     indexCompanyConversationCategories(companyId: bigint, fields?: Nullable<string>, pageToken?: Nullable<string>, autoPaginate?: Nullable<boolean>, count?: Nullable<number>): Promise<HttpResponse<PagedListSecureConversationCategory>>;
     indexCompanyConversationCategoriesForRequests(companyId: bigint, fields?: Nullable<string>, pageToken?: Nullable<string>, autoPaginate?: Nullable<boolean>, count?: Nullable<number>): Promise<HttpResponse<PagedListPublicConversationCategory>>;
-    indexConversation(companyId: bigint, search?: Nullable<string>, category?: Nullable<bigint>, folder?: Nullable<bigint>, onlyRoot?: Nullable<boolean>, status?: Nullable<ConversationStatus>, byParticipant?: Nullable<bigint>, byParticipantType?: Nullable<ParticipantType>, assignedToUserId?: Nullable<bigint>, createdSince?: Nullable<bigint>, updatedSince?: Nullable<bigint>, flaggedByCurrentUser?: Nullable<boolean>, readByCurrentUser?: Nullable<boolean>, orderBy?: Nullable<ConversationOrderBy>, orderDirection?: Nullable<ConversationOrderDirection>, fields?: Nullable<string>, pageToken?: Nullable<string>, autoPaginate?: Nullable<boolean>, count?: Nullable<number>): Promise<HttpResponse<PagedListConversation>>;
+    indexConversation(companyId: bigint, search?: Nullable<string>, status?: Nullable<KtList<ConversationApi.StatusIndexConversation>>, category?: Nullable<KtList<bigint>>, assignedToUserId?: Nullable<KtList<bigint>>, latestPublicMessageSide?: Nullable<KtList<ConversationApi.LatestPublicMessageSideIndexConversation>>, hasAttachments?: Nullable<boolean>, folderIds?: Nullable<KtList<bigint>>, onlyRoot?: Nullable<boolean>, byParticipant?: Nullable<KtList<bigint>>, byParticipantType?: Nullable<KtList<ConversationApi.ByParticipantTypeIndexConversation>>, createdSince?: Nullable<bigint>, updatedSince?: Nullable<bigint>, flaggedByCurrentUser?: Nullable<boolean>, readByCurrentUser?: Nullable<boolean>, orderBy?: Nullable<ConversationApi.OrderByIndexConversation>, orderDirection?: Nullable<ConversationApi.OrderDirectionIndexConversation>, pageToken?: Nullable<string>, count?: Nullable<number>, autoPaginate?: Nullable<boolean>, fields?: Nullable<string>): Promise<HttpResponse<PagedListConversation>>;
     indexConversationByParticipant(companyId: bigint, participantId: bigint, participantType: ParticipantType, fields?: Nullable<string>, pageToken?: Nullable<string>, autoPaginate?: Nullable<boolean>, count?: Nullable<number>): Promise<HttpResponse<PagedListConversation>>;
     indexConversationCategoriesOpen(companySlug: string, fields?: Nullable<string>, pageToken?: Nullable<string>, autoPaginate?: Nullable<boolean>, count?: Nullable<number>): Promise<HttpResponse<PagedListPublicConversationCategory>>;
-    indexConversationCount(fields?: Nullable<string>): Promise<HttpResponse<KtMap<string, ConversationCountConversationCountMap>>>;
-    indexConversationCountByCompany(companyIds?: Nullable<KtList<bigint>>, categoryIds?: Nullable<KtList<bigint>>, status?: Nullable<ConversationStatus>, draft?: Nullable<boolean>, requiresFollowUp?: Nullable<boolean>, folderId?: Nullable<bigint>, assignedToUserId?: Nullable<bigint>, createdSince?: Nullable<bigint>, updatedSince?: Nullable<bigint>, flaggedByCurrentUser?: Nullable<boolean>, readByCurrentUser?: Nullable<boolean>, fields?: Nullable<string>): Promise<HttpResponse<KtMap<string, ConversationCountConversationCountByCompanyMap>>>;
-    indexConversationCountInCompany(companyId: bigint, fields?: Nullable<string>): Promise<HttpResponse<ConversationCount>>;
+    indexConversationCountByCompany(search?: Nullable<string>, status?: Nullable<KtList<ConversationApi.StatusIndexConversationCountByCompany>>, category?: Nullable<KtList<bigint>>, assignedToUserId?: Nullable<KtList<bigint>>, latestPublicMessageSide?: Nullable<KtList<ConversationApi.LatestPublicMessageSideIndexConversationCountByCompany>>, hasAttachments?: Nullable<boolean>, folderIds?: Nullable<KtList<bigint>>, onlyRoot?: Nullable<boolean>, byParticipant?: Nullable<KtList<bigint>>, byParticipantType?: Nullable<KtList<ConversationApi.ByParticipantTypeIndexConversationCountByCompany>>, createdSince?: Nullable<bigint>, updatedSince?: Nullable<bigint>, flaggedByCurrentUser?: Nullable<boolean>, readByCurrentUser?: Nullable<boolean>, companyId?: Nullable<KtList<bigint>>, fields?: Nullable<string>): Promise<HttpResponse<KtMap<string, ConversationCountConversationCountByCompanyMap>>>;
     indexConversationFolders(companyId: bigint, parentId?: Nullable<bigint>, fields?: Nullable<string>, pageToken?: Nullable<string>, autoPaginate?: Nullable<boolean>, count?: Nullable<number>): Promise<HttpResponse<PagedListConversationFolder>>;
     indexConversationMessageHistory(companyId: bigint, conversationId: bigint, messageId: bigint, fields?: Nullable<string>): Promise<HttpResponse<KtList<MessageEditHistory>>>;
-    indexConversations(search?: Nullable<string>, companyIds?: Nullable<KtList<bigint>>, categoryIds?: Nullable<KtList<bigint>>, status?: Nullable<ConversationStatus>, draft?: Nullable<boolean>, requiresFollowUp?: Nullable<boolean>, byParticipants?: Nullable<KtList<bigint>>, byParticipantTypes?: Nullable<KtList<ParticipantType>>, folderId?: Nullable<bigint>, assignedToUserId?: Nullable<bigint>, createdSince?: Nullable<bigint>, updatedSince?: Nullable<bigint>, flaggedByCurrentUser?: Nullable<boolean>, readByCurrentUser?: Nullable<boolean>, orderBy?: Nullable<ConversationOrderBy>, orderDirection?: Nullable<ConversationOrderDirection>, fields?: Nullable<string>, pageToken?: Nullable<string>, autoPaginate?: Nullable<boolean>, count?: Nullable<number>): Promise<HttpResponse<PagedListConversation>>;
+    indexConversations(search?: Nullable<string>, status?: Nullable<KtList<ConversationApi.StatusIndexConversations>>, category?: Nullable<KtList<bigint>>, assignedToUserId?: Nullable<KtList<bigint>>, latestPublicMessageSide?: Nullable<KtList<ConversationApi.LatestPublicMessageSideIndexConversations>>, hasAttachments?: Nullable<boolean>, folderIds?: Nullable<KtList<bigint>>, onlyRoot?: Nullable<boolean>, byParticipant?: Nullable<KtList<bigint>>, byParticipantType?: Nullable<KtList<ConversationApi.ByParticipantTypeIndexConversations>>, createdSince?: Nullable<bigint>, updatedSince?: Nullable<bigint>, flaggedByCurrentUser?: Nullable<boolean>, readByCurrentUser?: Nullable<boolean>, companyId?: Nullable<KtList<bigint>>, orderBy?: Nullable<ConversationApi.OrderByIndexConversations>, orderDirection?: Nullable<ConversationApi.OrderDirectionIndexConversations>, pageToken?: Nullable<string>, count?: Nullable<number>, autoPaginate?: Nullable<boolean>, fields?: Nullable<string>): Promise<HttpResponse<PagedListConversation>>;
     moveConversation(companyId: bigint, conversationId: bigint, moveConversationToFolderCommand: MoveConversationToFolderCommand): Promise<HttpResponse<void>>;
     moveMultipleConversations(companyId: bigint, batchMoveConversationsToFolderCommand: BatchMoveConversationsToFolderCommand): Promise<HttpResponse<void>>;
+    openBoligselskapCompanySlugSamtaleConversationIdAuthorizeByTokenTokenGet(companySlug: string, conversationId: bigint, token: string): Promise<HttpResponse<void>>;
+    openBoligselskapCompanySlugSamtaleConversationIdAuthorizeGet(companySlug: string, conversationId: bigint): Promise<HttpResponse<void>>;
+    openBoligselskaperCompanySlugSamtalerConversationIdAuthorizeByTokenTokenGet(companySlug: string, conversationId: bigint, token: string): Promise<HttpResponse<void>>;
+    openBoligselskaperCompanySlugSamtalerConversationIdAuthorizeGet(companySlug: string, conversationId: bigint): Promise<HttpResponse<void>>;
     previewConversationCategoryParticipants(companyId: bigint, categoryId: bigint, fields?: Nullable<string>): Promise<HttpResponse<KtList<ConversationCategoryParticipantPreview>>>;
     publishConversation(companyId: bigint, conversationId: bigint): Promise<HttpResponse<Conversation>>;
     reOpenConversation(companyId: bigint, conversationId: bigint): Promise<HttpResponse<Conversation>>;
@@ -21250,6 +23355,502 @@ export declare namespace ConversationApi {
     namespace $metadata$ {
         const constructor: abstract new () => ConversationApi;
     }
+    abstract class StatusCountConversationsInCompany {
+        private constructor();
+        static get DRAFT(): ConversationApi.StatusCountConversationsInCompany & {
+            get name(): "DRAFT";
+            get ordinal(): 0;
+        };
+        static get NEW(): ConversationApi.StatusCountConversationsInCompany & {
+            get name(): "NEW";
+            get ordinal(): 1;
+        };
+        static get IN_PROGRESS(): ConversationApi.StatusCountConversationsInCompany & {
+            get name(): "IN_PROGRESS";
+            get ordinal(): 2;
+        };
+        static get COMPLETE(): ConversationApi.StatusCountConversationsInCompany & {
+            get name(): "COMPLETE";
+            get ordinal(): 3;
+        };
+        static get TRASHED(): ConversationApi.StatusCountConversationsInCompany & {
+            get name(): "TRASHED";
+            get ordinal(): 4;
+        };
+        static values(): [typeof ConversationApi.StatusCountConversationsInCompany.DRAFT, typeof ConversationApi.StatusCountConversationsInCompany.NEW, typeof ConversationApi.StatusCountConversationsInCompany.IN_PROGRESS, typeof ConversationApi.StatusCountConversationsInCompany.COMPLETE, typeof ConversationApi.StatusCountConversationsInCompany.TRASHED];
+        static valueOf(value: string): ConversationApi.StatusCountConversationsInCompany;
+        get name(): "DRAFT" | "NEW" | "IN_PROGRESS" | "COMPLETE" | "TRASHED";
+        get ordinal(): 0 | 1 | 2 | 3 | 4;
+        get value(): string;
+    }
+    namespace StatusCountConversationsInCompany {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => StatusCountConversationsInCompany;
+        }
+    }
+    abstract class LatestPublicMessageSideCountConversationsInCompany {
+        private constructor();
+        static get BOARD(): ConversationApi.LatestPublicMessageSideCountConversationsInCompany & {
+            get name(): "BOARD";
+            get ordinal(): 0;
+        };
+        static get NON_BOARD(): ConversationApi.LatestPublicMessageSideCountConversationsInCompany & {
+            get name(): "NON_BOARD";
+            get ordinal(): 1;
+        };
+        static get NONE(): ConversationApi.LatestPublicMessageSideCountConversationsInCompany & {
+            get name(): "NONE";
+            get ordinal(): 2;
+        };
+        static values(): [typeof ConversationApi.LatestPublicMessageSideCountConversationsInCompany.BOARD, typeof ConversationApi.LatestPublicMessageSideCountConversationsInCompany.NON_BOARD, typeof ConversationApi.LatestPublicMessageSideCountConversationsInCompany.NONE];
+        static valueOf(value: string): ConversationApi.LatestPublicMessageSideCountConversationsInCompany;
+        get name(): "BOARD" | "NON_BOARD" | "NONE";
+        get ordinal(): 0 | 1 | 2;
+        get value(): string;
+    }
+    namespace LatestPublicMessageSideCountConversationsInCompany {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => LatestPublicMessageSideCountConversationsInCompany;
+        }
+    }
+    abstract class ByParticipantTypeCountConversationsInCompany {
+        private constructor();
+        static get PERSON(): ConversationApi.ByParticipantTypeCountConversationsInCompany & {
+            get name(): "PERSON";
+            get ordinal(): 0;
+        };
+        static get ORGANIZATION(): ConversationApi.ByParticipantTypeCountConversationsInCompany & {
+            get name(): "ORGANIZATION";
+            get ordinal(): 1;
+        };
+        static get EMPLOYEE(): ConversationApi.ByParticipantTypeCountConversationsInCompany & {
+            get name(): "EMPLOYEE";
+            get ordinal(): 2;
+        };
+        static get INQUIRY(): ConversationApi.ByParticipantTypeCountConversationsInCompany & {
+            get name(): "INQUIRY";
+            get ordinal(): 3;
+        };
+        static get SUPPLIER_CONTACT(): ConversationApi.ByParticipantTypeCountConversationsInCompany & {
+            get name(): "SUPPLIER_CONTACT";
+            get ordinal(): 4;
+        };
+        static get CLIENT_USER(): ConversationApi.ByParticipantTypeCountConversationsInCompany & {
+            get name(): "CLIENT_USER";
+            get ordinal(): 5;
+        };
+        static values(): [typeof ConversationApi.ByParticipantTypeCountConversationsInCompany.PERSON, typeof ConversationApi.ByParticipantTypeCountConversationsInCompany.ORGANIZATION, typeof ConversationApi.ByParticipantTypeCountConversationsInCompany.EMPLOYEE, typeof ConversationApi.ByParticipantTypeCountConversationsInCompany.INQUIRY, typeof ConversationApi.ByParticipantTypeCountConversationsInCompany.SUPPLIER_CONTACT, typeof ConversationApi.ByParticipantTypeCountConversationsInCompany.CLIENT_USER];
+        static valueOf(value: string): ConversationApi.ByParticipantTypeCountConversationsInCompany;
+        get name(): "PERSON" | "ORGANIZATION" | "EMPLOYEE" | "INQUIRY" | "SUPPLIER_CONTACT" | "CLIENT_USER";
+        get ordinal(): 0 | 1 | 2 | 3 | 4 | 5;
+        get value(): string;
+    }
+    namespace ByParticipantTypeCountConversationsInCompany {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => ByParticipantTypeCountConversationsInCompany;
+        }
+    }
+    abstract class StatusIndexConversation {
+        private constructor();
+        static get DRAFT(): ConversationApi.StatusIndexConversation & {
+            get name(): "DRAFT";
+            get ordinal(): 0;
+        };
+        static get NEW(): ConversationApi.StatusIndexConversation & {
+            get name(): "NEW";
+            get ordinal(): 1;
+        };
+        static get IN_PROGRESS(): ConversationApi.StatusIndexConversation & {
+            get name(): "IN_PROGRESS";
+            get ordinal(): 2;
+        };
+        static get COMPLETE(): ConversationApi.StatusIndexConversation & {
+            get name(): "COMPLETE";
+            get ordinal(): 3;
+        };
+        static get TRASHED(): ConversationApi.StatusIndexConversation & {
+            get name(): "TRASHED";
+            get ordinal(): 4;
+        };
+        static values(): [typeof ConversationApi.StatusIndexConversation.DRAFT, typeof ConversationApi.StatusIndexConversation.NEW, typeof ConversationApi.StatusIndexConversation.IN_PROGRESS, typeof ConversationApi.StatusIndexConversation.COMPLETE, typeof ConversationApi.StatusIndexConversation.TRASHED];
+        static valueOf(value: string): ConversationApi.StatusIndexConversation;
+        get name(): "DRAFT" | "NEW" | "IN_PROGRESS" | "COMPLETE" | "TRASHED";
+        get ordinal(): 0 | 1 | 2 | 3 | 4;
+        get value(): string;
+    }
+    namespace StatusIndexConversation {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => StatusIndexConversation;
+        }
+    }
+    abstract class LatestPublicMessageSideIndexConversation {
+        private constructor();
+        static get BOARD(): ConversationApi.LatestPublicMessageSideIndexConversation & {
+            get name(): "BOARD";
+            get ordinal(): 0;
+        };
+        static get NON_BOARD(): ConversationApi.LatestPublicMessageSideIndexConversation & {
+            get name(): "NON_BOARD";
+            get ordinal(): 1;
+        };
+        static get NONE(): ConversationApi.LatestPublicMessageSideIndexConversation & {
+            get name(): "NONE";
+            get ordinal(): 2;
+        };
+        static values(): [typeof ConversationApi.LatestPublicMessageSideIndexConversation.BOARD, typeof ConversationApi.LatestPublicMessageSideIndexConversation.NON_BOARD, typeof ConversationApi.LatestPublicMessageSideIndexConversation.NONE];
+        static valueOf(value: string): ConversationApi.LatestPublicMessageSideIndexConversation;
+        get name(): "BOARD" | "NON_BOARD" | "NONE";
+        get ordinal(): 0 | 1 | 2;
+        get value(): string;
+    }
+    namespace LatestPublicMessageSideIndexConversation {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => LatestPublicMessageSideIndexConversation;
+        }
+    }
+    abstract class ByParticipantTypeIndexConversation {
+        private constructor();
+        static get PERSON(): ConversationApi.ByParticipantTypeIndexConversation & {
+            get name(): "PERSON";
+            get ordinal(): 0;
+        };
+        static get ORGANIZATION(): ConversationApi.ByParticipantTypeIndexConversation & {
+            get name(): "ORGANIZATION";
+            get ordinal(): 1;
+        };
+        static get EMPLOYEE(): ConversationApi.ByParticipantTypeIndexConversation & {
+            get name(): "EMPLOYEE";
+            get ordinal(): 2;
+        };
+        static get INQUIRY(): ConversationApi.ByParticipantTypeIndexConversation & {
+            get name(): "INQUIRY";
+            get ordinal(): 3;
+        };
+        static get SUPPLIER_CONTACT(): ConversationApi.ByParticipantTypeIndexConversation & {
+            get name(): "SUPPLIER_CONTACT";
+            get ordinal(): 4;
+        };
+        static get CLIENT_USER(): ConversationApi.ByParticipantTypeIndexConversation & {
+            get name(): "CLIENT_USER";
+            get ordinal(): 5;
+        };
+        static values(): [typeof ConversationApi.ByParticipantTypeIndexConversation.PERSON, typeof ConversationApi.ByParticipantTypeIndexConversation.ORGANIZATION, typeof ConversationApi.ByParticipantTypeIndexConversation.EMPLOYEE, typeof ConversationApi.ByParticipantTypeIndexConversation.INQUIRY, typeof ConversationApi.ByParticipantTypeIndexConversation.SUPPLIER_CONTACT, typeof ConversationApi.ByParticipantTypeIndexConversation.CLIENT_USER];
+        static valueOf(value: string): ConversationApi.ByParticipantTypeIndexConversation;
+        get name(): "PERSON" | "ORGANIZATION" | "EMPLOYEE" | "INQUIRY" | "SUPPLIER_CONTACT" | "CLIENT_USER";
+        get ordinal(): 0 | 1 | 2 | 3 | 4 | 5;
+        get value(): string;
+    }
+    namespace ByParticipantTypeIndexConversation {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => ByParticipantTypeIndexConversation;
+        }
+    }
+    abstract class OrderByIndexConversation {
+        private constructor();
+        static get LATEST_ACTIVITY_AT(): ConversationApi.OrderByIndexConversation & {
+            get name(): "LATEST_ACTIVITY_AT";
+            get ordinal(): 0;
+        };
+        static get CONVERSATION_STARTED_AT(): ConversationApi.OrderByIndexConversation & {
+            get name(): "CONVERSATION_STARTED_AT";
+            get ordinal(): 1;
+        };
+        static get LATEST_MESSAGE_AT(): ConversationApi.OrderByIndexConversation & {
+            get name(): "LATEST_MESSAGE_AT";
+            get ordinal(): 2;
+        };
+        static get LATEST_EVENT_AT(): ConversationApi.OrderByIndexConversation & {
+            get name(): "LATEST_EVENT_AT";
+            get ordinal(): 3;
+        };
+        static values(): [typeof ConversationApi.OrderByIndexConversation.LATEST_ACTIVITY_AT, typeof ConversationApi.OrderByIndexConversation.CONVERSATION_STARTED_AT, typeof ConversationApi.OrderByIndexConversation.LATEST_MESSAGE_AT, typeof ConversationApi.OrderByIndexConversation.LATEST_EVENT_AT];
+        static valueOf(value: string): ConversationApi.OrderByIndexConversation;
+        get name(): "LATEST_ACTIVITY_AT" | "CONVERSATION_STARTED_AT" | "LATEST_MESSAGE_AT" | "LATEST_EVENT_AT";
+        get ordinal(): 0 | 1 | 2 | 3;
+        get value(): string;
+    }
+    namespace OrderByIndexConversation {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => OrderByIndexConversation;
+        }
+    }
+    abstract class OrderDirectionIndexConversation {
+        private constructor();
+        static get ASC(): ConversationApi.OrderDirectionIndexConversation & {
+            get name(): "ASC";
+            get ordinal(): 0;
+        };
+        static get DESC(): ConversationApi.OrderDirectionIndexConversation & {
+            get name(): "DESC";
+            get ordinal(): 1;
+        };
+        static values(): [typeof ConversationApi.OrderDirectionIndexConversation.ASC, typeof ConversationApi.OrderDirectionIndexConversation.DESC];
+        static valueOf(value: string): ConversationApi.OrderDirectionIndexConversation;
+        get name(): "ASC" | "DESC";
+        get ordinal(): 0 | 1;
+        get value(): string;
+    }
+    namespace OrderDirectionIndexConversation {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => OrderDirectionIndexConversation;
+        }
+    }
+    abstract class StatusIndexConversationCountByCompany {
+        private constructor();
+        static get DRAFT(): ConversationApi.StatusIndexConversationCountByCompany & {
+            get name(): "DRAFT";
+            get ordinal(): 0;
+        };
+        static get NEW(): ConversationApi.StatusIndexConversationCountByCompany & {
+            get name(): "NEW";
+            get ordinal(): 1;
+        };
+        static get IN_PROGRESS(): ConversationApi.StatusIndexConversationCountByCompany & {
+            get name(): "IN_PROGRESS";
+            get ordinal(): 2;
+        };
+        static get COMPLETE(): ConversationApi.StatusIndexConversationCountByCompany & {
+            get name(): "COMPLETE";
+            get ordinal(): 3;
+        };
+        static get TRASHED(): ConversationApi.StatusIndexConversationCountByCompany & {
+            get name(): "TRASHED";
+            get ordinal(): 4;
+        };
+        static values(): [typeof ConversationApi.StatusIndexConversationCountByCompany.DRAFT, typeof ConversationApi.StatusIndexConversationCountByCompany.NEW, typeof ConversationApi.StatusIndexConversationCountByCompany.IN_PROGRESS, typeof ConversationApi.StatusIndexConversationCountByCompany.COMPLETE, typeof ConversationApi.StatusIndexConversationCountByCompany.TRASHED];
+        static valueOf(value: string): ConversationApi.StatusIndexConversationCountByCompany;
+        get name(): "DRAFT" | "NEW" | "IN_PROGRESS" | "COMPLETE" | "TRASHED";
+        get ordinal(): 0 | 1 | 2 | 3 | 4;
+        get value(): string;
+    }
+    namespace StatusIndexConversationCountByCompany {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => StatusIndexConversationCountByCompany;
+        }
+    }
+    abstract class LatestPublicMessageSideIndexConversationCountByCompany {
+        private constructor();
+        static get BOARD(): ConversationApi.LatestPublicMessageSideIndexConversationCountByCompany & {
+            get name(): "BOARD";
+            get ordinal(): 0;
+        };
+        static get NON_BOARD(): ConversationApi.LatestPublicMessageSideIndexConversationCountByCompany & {
+            get name(): "NON_BOARD";
+            get ordinal(): 1;
+        };
+        static get NONE(): ConversationApi.LatestPublicMessageSideIndexConversationCountByCompany & {
+            get name(): "NONE";
+            get ordinal(): 2;
+        };
+        static values(): [typeof ConversationApi.LatestPublicMessageSideIndexConversationCountByCompany.BOARD, typeof ConversationApi.LatestPublicMessageSideIndexConversationCountByCompany.NON_BOARD, typeof ConversationApi.LatestPublicMessageSideIndexConversationCountByCompany.NONE];
+        static valueOf(value: string): ConversationApi.LatestPublicMessageSideIndexConversationCountByCompany;
+        get name(): "BOARD" | "NON_BOARD" | "NONE";
+        get ordinal(): 0 | 1 | 2;
+        get value(): string;
+    }
+    namespace LatestPublicMessageSideIndexConversationCountByCompany {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => LatestPublicMessageSideIndexConversationCountByCompany;
+        }
+    }
+    abstract class ByParticipantTypeIndexConversationCountByCompany {
+        private constructor();
+        static get PERSON(): ConversationApi.ByParticipantTypeIndexConversationCountByCompany & {
+            get name(): "PERSON";
+            get ordinal(): 0;
+        };
+        static get ORGANIZATION(): ConversationApi.ByParticipantTypeIndexConversationCountByCompany & {
+            get name(): "ORGANIZATION";
+            get ordinal(): 1;
+        };
+        static get EMPLOYEE(): ConversationApi.ByParticipantTypeIndexConversationCountByCompany & {
+            get name(): "EMPLOYEE";
+            get ordinal(): 2;
+        };
+        static get INQUIRY(): ConversationApi.ByParticipantTypeIndexConversationCountByCompany & {
+            get name(): "INQUIRY";
+            get ordinal(): 3;
+        };
+        static get SUPPLIER_CONTACT(): ConversationApi.ByParticipantTypeIndexConversationCountByCompany & {
+            get name(): "SUPPLIER_CONTACT";
+            get ordinal(): 4;
+        };
+        static get CLIENT_USER(): ConversationApi.ByParticipantTypeIndexConversationCountByCompany & {
+            get name(): "CLIENT_USER";
+            get ordinal(): 5;
+        };
+        static values(): [typeof ConversationApi.ByParticipantTypeIndexConversationCountByCompany.PERSON, typeof ConversationApi.ByParticipantTypeIndexConversationCountByCompany.ORGANIZATION, typeof ConversationApi.ByParticipantTypeIndexConversationCountByCompany.EMPLOYEE, typeof ConversationApi.ByParticipantTypeIndexConversationCountByCompany.INQUIRY, typeof ConversationApi.ByParticipantTypeIndexConversationCountByCompany.SUPPLIER_CONTACT, typeof ConversationApi.ByParticipantTypeIndexConversationCountByCompany.CLIENT_USER];
+        static valueOf(value: string): ConversationApi.ByParticipantTypeIndexConversationCountByCompany;
+        get name(): "PERSON" | "ORGANIZATION" | "EMPLOYEE" | "INQUIRY" | "SUPPLIER_CONTACT" | "CLIENT_USER";
+        get ordinal(): 0 | 1 | 2 | 3 | 4 | 5;
+        get value(): string;
+    }
+    namespace ByParticipantTypeIndexConversationCountByCompany {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => ByParticipantTypeIndexConversationCountByCompany;
+        }
+    }
+    abstract class StatusIndexConversations {
+        private constructor();
+        static get DRAFT(): ConversationApi.StatusIndexConversations & {
+            get name(): "DRAFT";
+            get ordinal(): 0;
+        };
+        static get NEW(): ConversationApi.StatusIndexConversations & {
+            get name(): "NEW";
+            get ordinal(): 1;
+        };
+        static get IN_PROGRESS(): ConversationApi.StatusIndexConversations & {
+            get name(): "IN_PROGRESS";
+            get ordinal(): 2;
+        };
+        static get COMPLETE(): ConversationApi.StatusIndexConversations & {
+            get name(): "COMPLETE";
+            get ordinal(): 3;
+        };
+        static get TRASHED(): ConversationApi.StatusIndexConversations & {
+            get name(): "TRASHED";
+            get ordinal(): 4;
+        };
+        static values(): [typeof ConversationApi.StatusIndexConversations.DRAFT, typeof ConversationApi.StatusIndexConversations.NEW, typeof ConversationApi.StatusIndexConversations.IN_PROGRESS, typeof ConversationApi.StatusIndexConversations.COMPLETE, typeof ConversationApi.StatusIndexConversations.TRASHED];
+        static valueOf(value: string): ConversationApi.StatusIndexConversations;
+        get name(): "DRAFT" | "NEW" | "IN_PROGRESS" | "COMPLETE" | "TRASHED";
+        get ordinal(): 0 | 1 | 2 | 3 | 4;
+        get value(): string;
+    }
+    namespace StatusIndexConversations {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => StatusIndexConversations;
+        }
+    }
+    abstract class LatestPublicMessageSideIndexConversations {
+        private constructor();
+        static get BOARD(): ConversationApi.LatestPublicMessageSideIndexConversations & {
+            get name(): "BOARD";
+            get ordinal(): 0;
+        };
+        static get NON_BOARD(): ConversationApi.LatestPublicMessageSideIndexConversations & {
+            get name(): "NON_BOARD";
+            get ordinal(): 1;
+        };
+        static get NONE(): ConversationApi.LatestPublicMessageSideIndexConversations & {
+            get name(): "NONE";
+            get ordinal(): 2;
+        };
+        static values(): [typeof ConversationApi.LatestPublicMessageSideIndexConversations.BOARD, typeof ConversationApi.LatestPublicMessageSideIndexConversations.NON_BOARD, typeof ConversationApi.LatestPublicMessageSideIndexConversations.NONE];
+        static valueOf(value: string): ConversationApi.LatestPublicMessageSideIndexConversations;
+        get name(): "BOARD" | "NON_BOARD" | "NONE";
+        get ordinal(): 0 | 1 | 2;
+        get value(): string;
+    }
+    namespace LatestPublicMessageSideIndexConversations {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => LatestPublicMessageSideIndexConversations;
+        }
+    }
+    abstract class ByParticipantTypeIndexConversations {
+        private constructor();
+        static get PERSON(): ConversationApi.ByParticipantTypeIndexConversations & {
+            get name(): "PERSON";
+            get ordinal(): 0;
+        };
+        static get ORGANIZATION(): ConversationApi.ByParticipantTypeIndexConversations & {
+            get name(): "ORGANIZATION";
+            get ordinal(): 1;
+        };
+        static get EMPLOYEE(): ConversationApi.ByParticipantTypeIndexConversations & {
+            get name(): "EMPLOYEE";
+            get ordinal(): 2;
+        };
+        static get INQUIRY(): ConversationApi.ByParticipantTypeIndexConversations & {
+            get name(): "INQUIRY";
+            get ordinal(): 3;
+        };
+        static get SUPPLIER_CONTACT(): ConversationApi.ByParticipantTypeIndexConversations & {
+            get name(): "SUPPLIER_CONTACT";
+            get ordinal(): 4;
+        };
+        static get CLIENT_USER(): ConversationApi.ByParticipantTypeIndexConversations & {
+            get name(): "CLIENT_USER";
+            get ordinal(): 5;
+        };
+        static values(): [typeof ConversationApi.ByParticipantTypeIndexConversations.PERSON, typeof ConversationApi.ByParticipantTypeIndexConversations.ORGANIZATION, typeof ConversationApi.ByParticipantTypeIndexConversations.EMPLOYEE, typeof ConversationApi.ByParticipantTypeIndexConversations.INQUIRY, typeof ConversationApi.ByParticipantTypeIndexConversations.SUPPLIER_CONTACT, typeof ConversationApi.ByParticipantTypeIndexConversations.CLIENT_USER];
+        static valueOf(value: string): ConversationApi.ByParticipantTypeIndexConversations;
+        get name(): "PERSON" | "ORGANIZATION" | "EMPLOYEE" | "INQUIRY" | "SUPPLIER_CONTACT" | "CLIENT_USER";
+        get ordinal(): 0 | 1 | 2 | 3 | 4 | 5;
+        get value(): string;
+    }
+    namespace ByParticipantTypeIndexConversations {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => ByParticipantTypeIndexConversations;
+        }
+    }
+    abstract class OrderByIndexConversations {
+        private constructor();
+        static get LATEST_ACTIVITY_AT(): ConversationApi.OrderByIndexConversations & {
+            get name(): "LATEST_ACTIVITY_AT";
+            get ordinal(): 0;
+        };
+        static get CONVERSATION_STARTED_AT(): ConversationApi.OrderByIndexConversations & {
+            get name(): "CONVERSATION_STARTED_AT";
+            get ordinal(): 1;
+        };
+        static get LATEST_MESSAGE_AT(): ConversationApi.OrderByIndexConversations & {
+            get name(): "LATEST_MESSAGE_AT";
+            get ordinal(): 2;
+        };
+        static get LATEST_EVENT_AT(): ConversationApi.OrderByIndexConversations & {
+            get name(): "LATEST_EVENT_AT";
+            get ordinal(): 3;
+        };
+        static values(): [typeof ConversationApi.OrderByIndexConversations.LATEST_ACTIVITY_AT, typeof ConversationApi.OrderByIndexConversations.CONVERSATION_STARTED_AT, typeof ConversationApi.OrderByIndexConversations.LATEST_MESSAGE_AT, typeof ConversationApi.OrderByIndexConversations.LATEST_EVENT_AT];
+        static valueOf(value: string): ConversationApi.OrderByIndexConversations;
+        get name(): "LATEST_ACTIVITY_AT" | "CONVERSATION_STARTED_AT" | "LATEST_MESSAGE_AT" | "LATEST_EVENT_AT";
+        get ordinal(): 0 | 1 | 2 | 3;
+        get value(): string;
+    }
+    namespace OrderByIndexConversations {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => OrderByIndexConversations;
+        }
+    }
+    abstract class OrderDirectionIndexConversations {
+        private constructor();
+        static get ASC(): ConversationApi.OrderDirectionIndexConversations & {
+            get name(): "ASC";
+            get ordinal(): 0;
+        };
+        static get DESC(): ConversationApi.OrderDirectionIndexConversations & {
+            get name(): "DESC";
+            get ordinal(): 1;
+        };
+        static values(): [typeof ConversationApi.OrderDirectionIndexConversations.ASC, typeof ConversationApi.OrderDirectionIndexConversations.DESC];
+        static valueOf(value: string): ConversationApi.OrderDirectionIndexConversations;
+        get name(): "ASC" | "DESC";
+        get ordinal(): 0 | 1;
+        get value(): string;
+    }
+    namespace OrderDirectionIndexConversations {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            const constructor: abstract new () => OrderDirectionIndexConversations;
+        }
+    }
 }
 export declare class DocumentApi extends ApiClient.$metadata$.constructor {
     private constructor();
@@ -21657,6 +24258,19 @@ export declare namespace MeetingApi {
         const constructor: abstract new () => MeetingApi;
     }
 }
+export declare class Office365Api extends ApiClient.$metadata$.constructor {
+    private constructor();
+    static create(baseUrl?: string, httpClientEngine?: Nullable<any>/* Nullable<HttpClientEngine> */, httpClientConfig?: Nullable<(p0: any/* HttpClientConfig<UnknownType *> */) => void>, jsonSerializer?: any/* Json */): Office365Api;
+    static createWithClient(baseUrl: string, httpClient: any/* HttpClient */): Office365Api;
+    mgmtAdminOffice365EmployeeIdentitiesPersonIdGet(personId: bigint, employeeIdentities: string, fields?: Nullable<string>): Promise<HttpResponse<Office365EmployeeIdentity>>;
+    mgmtAdminOffice365EmployeeIdentitiesPersonIdPut(personId: bigint, employeeIdentities: string, explicitOffice365EmployeeIdentityMappingCommand: ExplicitOffice365EmployeeIdentityMappingCommand): Promise<HttpResponse<ExplicitOffice365EmployeeIdentityMappingResponse>>;
+}
+export declare namespace Office365Api {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => Office365Api;
+    }
+}
 export declare class OrganizationApi extends ApiClient.$metadata$.constructor {
     private constructor();
     static create(baseUrl?: string, httpClientEngine?: Nullable<any>/* Nullable<HttpClientEngine> */, httpClientConfig?: Nullable<(p0: any/* HttpClientConfig<UnknownType *> */) => void>, jsonSerializer?: any/* Json */): OrganizationApi;
@@ -22080,6 +24694,19 @@ export declare namespace UserApi {
         const constructor: abstract new () => UserApi;
     }
 }
+export declare class WebhooksApi extends ApiClient.$metadata$.constructor {
+    private constructor();
+    static create(baseUrl?: string, httpClientEngine?: Nullable<any>/* Nullable<HttpClientEngine> */, httpClientConfig?: Nullable<(p0: any/* HttpClientConfig<UnknownType *> */) => void>, jsonSerializer?: any/* Json */): WebhooksApi;
+    static createWithClient(baseUrl: string, httpClient: any/* HttpClient */): WebhooksApi;
+    boligselskaperCompanySlugIncomingMailPost(companySlug: string, commonId?: Nullable<string>): Promise<HttpResponse<void>>;
+    boligselskaperCompanySlugIncomingMailSamtaleHashPost(companySlug: string, hash: string, commonId?: Nullable<string>): Promise<HttpResponse<void>>;
+}
+export declare namespace WebhooksApi {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => WebhooksApi;
+    }
+}
 export declare function collectionDelimiter(collectionFormat: string): string;
 export declare class ApiClient {
     constructor(baseUrl: string);