@solibo/home-api 1.7.19 → 1.7.20

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

@@ -645,6 +645,874 @@ export declare namespace BuildingFloor {
         const constructor: abstract new () => BuildingFloor;
     }
 }
+export declare class BulkCreateConversationCommand {
+    constructor(clientReference: Nullable<string> | undefined, command: CreateConversationCommand, companyId: bigint);
+    get clientReference(): Nullable<string>;
+    get command(): CreateConversationCommand;
+    get companyId(): bigint;
+    copy(clientReference?: Nullable<string>, command?: CreateConversationCommand, companyId?: bigint): BulkCreateConversationCommand;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateConversationCommand {
+    /** @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 () => BulkCreateConversationCommand;
+    }
+}
+export declare class BulkCreateConversationItemResult {
+    constructor(clientReference: Nullable<string> | undefined, companyId: bigint, conversationId: Nullable<bigint> | undefined, index: bigint, status: BulkCreateConversationItemStatus);
+    get clientReference(): Nullable<string>;
+    get companyId(): bigint;
+    get conversationId(): Nullable<bigint>;
+    get index(): bigint;
+    get status(): BulkCreateConversationItemStatus;
+    copy(clientReference?: Nullable<string>, companyId?: bigint, conversationId?: Nullable<bigint>, index?: bigint, status?: BulkCreateConversationItemStatus): BulkCreateConversationItemResult;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateConversationItemResult {
+    /** @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 () => BulkCreateConversationItemResult;
+    }
+}
+export declare abstract class BulkCreateConversationItemStatus {
+    private constructor();
+    static get CREATED(): BulkCreateConversationItemStatus & {
+        get name(): "CREATED";
+        get ordinal(): 0;
+    };
+    static get VALIDATED(): BulkCreateConversationItemStatus & {
+        get name(): "VALIDATED";
+        get ordinal(): 1;
+    };
+    static get Created(): BulkCreateConversationItemStatus & {
+        get name(): "CREATED";
+        get ordinal(): 0;
+    };
+    static get Validated(): BulkCreateConversationItemStatus & {
+        get name(): "VALIDATED";
+        get ordinal(): 1;
+    };
+    static values(): [typeof BulkCreateConversationItemStatus.CREATED, typeof BulkCreateConversationItemStatus.VALIDATED];
+    static valueOf(value: string): BulkCreateConversationItemStatus;
+    get name(): "CREATED" | "VALIDATED";
+    get ordinal(): 0 | 1;
+    get value(): string;
+    toString(): string;
+}
+export declare namespace BulkCreateConversationItemStatus {
+    /** @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 () => BulkCreateConversationItemStatus;
+    }
+    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<BulkCreateConversationItemStatus>;
+                private constructor();
+            }
+        }
+    }
+}
+export declare class BulkCreateConversationsCommand {
+    constructor(dryRun: Nullable<boolean> | undefined, items: KtList<BulkCreateConversationCommand>);
+    get dryRun(): Nullable<boolean>;
+    get items(): KtList<BulkCreateConversationCommand>;
+    copy(dryRun?: Nullable<boolean>, items?: KtList<BulkCreateConversationCommand>): BulkCreateConversationsCommand;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateConversationsCommand {
+    /** @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 () => BulkCreateConversationsCommand;
+    }
+}
+export declare class BulkCreateConversationsResult {
+    constructor(items: KtList<BulkCreateConversationItemResult>, summary?: Nullable<BulkCreateConversationsSummary>);
+    get items(): KtList<BulkCreateConversationItemResult>;
+    get summary(): Nullable<BulkCreateConversationsSummary>;
+    copy(items?: KtList<BulkCreateConversationItemResult>, summary?: Nullable<BulkCreateConversationsSummary>): BulkCreateConversationsResult;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateConversationsResult {
+    /** @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 () => BulkCreateConversationsResult;
+    }
+}
+export declare class BulkCreateConversationsSummary {
+    constructor(created: bigint, dryRun: boolean, total: bigint, validated: bigint);
+    get created(): bigint;
+    get dryRun(): boolean;
+    get total(): bigint;
+    get validated(): bigint;
+    copy(created?: bigint, dryRun?: boolean, total?: bigint, validated?: bigint): BulkCreateConversationsSummary;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateConversationsSummary {
+    /** @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 () => BulkCreateConversationsSummary;
+    }
+}
+export declare class BulkCreateHomepagePostCommand {
+    constructor(clientReference: Nullable<string> | undefined, command: CreatePostCommand, companyId: bigint);
+    get clientReference(): Nullable<string>;
+    get command(): CreatePostCommand;
+    get companyId(): bigint;
+    copy(clientReference?: Nullable<string>, command?: CreatePostCommand, companyId?: bigint): BulkCreateHomepagePostCommand;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateHomepagePostCommand {
+    /** @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 () => BulkCreateHomepagePostCommand;
+    }
+}
+export declare class BulkCreateHomepagePostItemResult {
+    constructor(clientReference: Nullable<string> | undefined, companyId: bigint, index: bigint, postId: Nullable<bigint> | undefined, status: BulkCreateHomepagePostItemStatus);
+    get clientReference(): Nullable<string>;
+    get companyId(): bigint;
+    get index(): bigint;
+    get postId(): Nullable<bigint>;
+    get status(): BulkCreateHomepagePostItemStatus;
+    copy(clientReference?: Nullable<string>, companyId?: bigint, index?: bigint, postId?: Nullable<bigint>, status?: BulkCreateHomepagePostItemStatus): BulkCreateHomepagePostItemResult;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateHomepagePostItemResult {
+    /** @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 () => BulkCreateHomepagePostItemResult;
+    }
+}
+export declare abstract class BulkCreateHomepagePostItemStatus {
+    private constructor();
+    static get CREATED(): BulkCreateHomepagePostItemStatus & {
+        get name(): "CREATED";
+        get ordinal(): 0;
+    };
+    static get VALIDATED(): BulkCreateHomepagePostItemStatus & {
+        get name(): "VALIDATED";
+        get ordinal(): 1;
+    };
+    static get Created(): BulkCreateHomepagePostItemStatus & {
+        get name(): "CREATED";
+        get ordinal(): 0;
+    };
+    static get Validated(): BulkCreateHomepagePostItemStatus & {
+        get name(): "VALIDATED";
+        get ordinal(): 1;
+    };
+    static values(): [typeof BulkCreateHomepagePostItemStatus.CREATED, typeof BulkCreateHomepagePostItemStatus.VALIDATED];
+    static valueOf(value: string): BulkCreateHomepagePostItemStatus;
+    get name(): "CREATED" | "VALIDATED";
+    get ordinal(): 0 | 1;
+    get value(): string;
+    toString(): string;
+}
+export declare namespace BulkCreateHomepagePostItemStatus {
+    /** @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 () => BulkCreateHomepagePostItemStatus;
+    }
+    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<BulkCreateHomepagePostItemStatus>;
+                private constructor();
+            }
+        }
+    }
+}
+export declare class BulkCreateHomepagePostsCommand {
+    constructor(dryRun: Nullable<boolean> | undefined, items: KtList<BulkCreateHomepagePostCommand>);
+    get dryRun(): Nullable<boolean>;
+    get items(): KtList<BulkCreateHomepagePostCommand>;
+    copy(dryRun?: Nullable<boolean>, items?: KtList<BulkCreateHomepagePostCommand>): BulkCreateHomepagePostsCommand;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateHomepagePostsCommand {
+    /** @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 () => BulkCreateHomepagePostsCommand;
+    }
+}
+export declare class BulkCreateHomepagePostsResult {
+    constructor(items: KtList<BulkCreateHomepagePostItemResult>, summary?: Nullable<BulkCreateHomepagePostsSummary>);
+    get items(): KtList<BulkCreateHomepagePostItemResult>;
+    get summary(): Nullable<BulkCreateHomepagePostsSummary>;
+    copy(items?: KtList<BulkCreateHomepagePostItemResult>, summary?: Nullable<BulkCreateHomepagePostsSummary>): BulkCreateHomepagePostsResult;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateHomepagePostsResult {
+    /** @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 () => BulkCreateHomepagePostsResult;
+    }
+}
+export declare class BulkCreateHomepagePostsSummary {
+    constructor(created: bigint, dryRun: boolean, total: bigint, validated: bigint);
+    get created(): bigint;
+    get dryRun(): boolean;
+    get total(): bigint;
+    get validated(): bigint;
+    copy(created?: bigint, dryRun?: boolean, total?: bigint, validated?: bigint): BulkCreateHomepagePostsSummary;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateHomepagePostsSummary {
+    /** @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 () => BulkCreateHomepagePostsSummary;
+    }
+}
+export declare class BulkCreateHomepagePracticalInfoCommand {
+    constructor(dryRun: Nullable<boolean> | undefined, items: KtList<BulkCreateHomepagePracticalInfoItemCommand>);
+    get dryRun(): Nullable<boolean>;
+    get items(): KtList<BulkCreateHomepagePracticalInfoItemCommand>;
+    copy(dryRun?: Nullable<boolean>, items?: KtList<BulkCreateHomepagePracticalInfoItemCommand>): BulkCreateHomepagePracticalInfoCommand;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateHomepagePracticalInfoCommand {
+    /** @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 () => BulkCreateHomepagePracticalInfoCommand;
+    }
+}
+export declare class BulkCreateHomepagePracticalInfoItemCommand {
+    constructor(clientReference: Nullable<string> | undefined, command: CreatePostCommand, companyId: bigint);
+    get clientReference(): Nullable<string>;
+    get command(): CreatePostCommand;
+    get companyId(): bigint;
+    copy(clientReference?: Nullable<string>, command?: CreatePostCommand, companyId?: bigint): BulkCreateHomepagePracticalInfoItemCommand;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateHomepagePracticalInfoItemCommand {
+    /** @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 () => BulkCreateHomepagePracticalInfoItemCommand;
+    }
+}
+export declare class BulkCreateHomepagePracticalInfoItemResult {
+    constructor(clientReference: Nullable<string> | undefined, companyId: bigint, index: bigint, practicalInfoId: Nullable<bigint> | undefined, status: BulkCreateHomepagePracticalInfoItemStatus);
+    get clientReference(): Nullable<string>;
+    get companyId(): bigint;
+    get index(): bigint;
+    get practicalInfoId(): Nullable<bigint>;
+    get status(): BulkCreateHomepagePracticalInfoItemStatus;
+    copy(clientReference?: Nullable<string>, companyId?: bigint, index?: bigint, practicalInfoId?: Nullable<bigint>, status?: BulkCreateHomepagePracticalInfoItemStatus): BulkCreateHomepagePracticalInfoItemResult;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateHomepagePracticalInfoItemResult {
+    /** @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 () => BulkCreateHomepagePracticalInfoItemResult;
+    }
+}
+export declare abstract class BulkCreateHomepagePracticalInfoItemStatus {
+    private constructor();
+    static get CREATED(): BulkCreateHomepagePracticalInfoItemStatus & {
+        get name(): "CREATED";
+        get ordinal(): 0;
+    };
+    static get VALIDATED(): BulkCreateHomepagePracticalInfoItemStatus & {
+        get name(): "VALIDATED";
+        get ordinal(): 1;
+    };
+    static get Created(): BulkCreateHomepagePracticalInfoItemStatus & {
+        get name(): "CREATED";
+        get ordinal(): 0;
+    };
+    static get Validated(): BulkCreateHomepagePracticalInfoItemStatus & {
+        get name(): "VALIDATED";
+        get ordinal(): 1;
+    };
+    static values(): [typeof BulkCreateHomepagePracticalInfoItemStatus.CREATED, typeof BulkCreateHomepagePracticalInfoItemStatus.VALIDATED];
+    static valueOf(value: string): BulkCreateHomepagePracticalInfoItemStatus;
+    get name(): "CREATED" | "VALIDATED";
+    get ordinal(): 0 | 1;
+    get value(): string;
+    toString(): string;
+}
+export declare namespace BulkCreateHomepagePracticalInfoItemStatus {
+    /** @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 () => BulkCreateHomepagePracticalInfoItemStatus;
+    }
+    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<BulkCreateHomepagePracticalInfoItemStatus>;
+                private constructor();
+            }
+        }
+    }
+}
+export declare class BulkCreateHomepagePracticalInfoResult {
+    constructor(items: KtList<BulkCreateHomepagePracticalInfoItemResult>, summary?: Nullable<BulkCreateHomepagePracticalInfoSummary>);
+    get items(): KtList<BulkCreateHomepagePracticalInfoItemResult>;
+    get summary(): Nullable<BulkCreateHomepagePracticalInfoSummary>;
+    copy(items?: KtList<BulkCreateHomepagePracticalInfoItemResult>, summary?: Nullable<BulkCreateHomepagePracticalInfoSummary>): BulkCreateHomepagePracticalInfoResult;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateHomepagePracticalInfoResult {
+    /** @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 () => BulkCreateHomepagePracticalInfoResult;
+    }
+}
+export declare class BulkCreateHomepagePracticalInfoSummary {
+    constructor(created: bigint, dryRun: boolean, total: bigint, validated: bigint);
+    get created(): bigint;
+    get dryRun(): boolean;
+    get total(): bigint;
+    get validated(): bigint;
+    copy(created?: bigint, dryRun?: boolean, total?: bigint, validated?: bigint): BulkCreateHomepagePracticalInfoSummary;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateHomepagePracticalInfoSummary {
+    /** @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 () => BulkCreateHomepagePracticalInfoSummary;
+    }
+}
+export declare class BulkCreateIssueCommand {
+    constructor(clientReference: Nullable<string> | undefined, command: CreateIssueCommand, companyId: bigint);
+    get clientReference(): Nullable<string>;
+    get command(): CreateIssueCommand;
+    get companyId(): bigint;
+    copy(clientReference?: Nullable<string>, command?: CreateIssueCommand, companyId?: bigint): BulkCreateIssueCommand;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateIssueCommand {
+    /** @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 () => BulkCreateIssueCommand;
+    }
+}
+export declare class BulkCreateIssueItemResult {
+    constructor(clientReference: Nullable<string> | undefined, companyId: bigint, index: bigint, issueId: Nullable<bigint> | undefined, status: BulkCreateIssueItemStatus);
+    get clientReference(): Nullable<string>;
+    get companyId(): bigint;
+    get index(): bigint;
+    get issueId(): Nullable<bigint>;
+    get status(): BulkCreateIssueItemStatus;
+    copy(clientReference?: Nullable<string>, companyId?: bigint, index?: bigint, issueId?: Nullable<bigint>, status?: BulkCreateIssueItemStatus): BulkCreateIssueItemResult;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateIssueItemResult {
+    /** @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 () => BulkCreateIssueItemResult;
+    }
+}
+export declare abstract class BulkCreateIssueItemStatus {
+    private constructor();
+    static get CREATED(): BulkCreateIssueItemStatus & {
+        get name(): "CREATED";
+        get ordinal(): 0;
+    };
+    static get VALIDATED(): BulkCreateIssueItemStatus & {
+        get name(): "VALIDATED";
+        get ordinal(): 1;
+    };
+    static get Created(): BulkCreateIssueItemStatus & {
+        get name(): "CREATED";
+        get ordinal(): 0;
+    };
+    static get Validated(): BulkCreateIssueItemStatus & {
+        get name(): "VALIDATED";
+        get ordinal(): 1;
+    };
+    static values(): [typeof BulkCreateIssueItemStatus.CREATED, typeof BulkCreateIssueItemStatus.VALIDATED];
+    static valueOf(value: string): BulkCreateIssueItemStatus;
+    get name(): "CREATED" | "VALIDATED";
+    get ordinal(): 0 | 1;
+    get value(): string;
+    toString(): string;
+}
+export declare namespace BulkCreateIssueItemStatus {
+    /** @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 () => BulkCreateIssueItemStatus;
+    }
+    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<BulkCreateIssueItemStatus>;
+                private constructor();
+            }
+        }
+    }
+}
+export declare class BulkCreateIssuesCommand {
+    constructor(dryRun: Nullable<boolean> | undefined, items: KtList<BulkCreateIssueCommand>);
+    get dryRun(): Nullable<boolean>;
+    get items(): KtList<BulkCreateIssueCommand>;
+    copy(dryRun?: Nullable<boolean>, items?: KtList<BulkCreateIssueCommand>): BulkCreateIssuesCommand;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateIssuesCommand {
+    /** @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 () => BulkCreateIssuesCommand;
+    }
+}
+export declare class BulkCreateIssuesResult {
+    constructor(items: KtList<BulkCreateIssueItemResult>, summary?: Nullable<BulkCreateIssuesSummary>);
+    get items(): KtList<BulkCreateIssueItemResult>;
+    get summary(): Nullable<BulkCreateIssuesSummary>;
+    copy(items?: KtList<BulkCreateIssueItemResult>, summary?: Nullable<BulkCreateIssuesSummary>): BulkCreateIssuesResult;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateIssuesResult {
+    /** @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 () => BulkCreateIssuesResult;
+    }
+}
+export declare class BulkCreateIssuesSummary {
+    constructor(created: bigint, dryRun: boolean, total: bigint, validated: bigint);
+    get created(): bigint;
+    get dryRun(): boolean;
+    get total(): bigint;
+    get validated(): bigint;
+    copy(created?: bigint, dryRun?: boolean, total?: bigint, validated?: bigint): BulkCreateIssuesSummary;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateIssuesSummary {
+    /** @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 () => BulkCreateIssuesSummary;
+    }
+}
+export declare class BulkCreateMeetingCommand {
+    constructor(clientReference: Nullable<string> | undefined, command: CreateMeetingCommand, companyId: bigint);
+    get clientReference(): Nullable<string>;
+    get command(): CreateMeetingCommand;
+    get companyId(): bigint;
+    copy(clientReference?: Nullable<string>, command?: CreateMeetingCommand, companyId?: bigint): BulkCreateMeetingCommand;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateMeetingCommand {
+    /** @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 () => BulkCreateMeetingCommand;
+    }
+}
+export declare class BulkCreateMeetingItemResult {
+    constructor(clientReference: Nullable<string> | undefined, companyId: bigint, index: bigint, meetingId: Nullable<bigint> | undefined, status: BulkCreateMeetingItemStatus);
+    get clientReference(): Nullable<string>;
+    get companyId(): bigint;
+    get index(): bigint;
+    get meetingId(): Nullable<bigint>;
+    get status(): BulkCreateMeetingItemStatus;
+    copy(clientReference?: Nullable<string>, companyId?: bigint, index?: bigint, meetingId?: Nullable<bigint>, status?: BulkCreateMeetingItemStatus): BulkCreateMeetingItemResult;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateMeetingItemResult {
+    /** @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 () => BulkCreateMeetingItemResult;
+    }
+}
+export declare abstract class BulkCreateMeetingItemStatus {
+    private constructor();
+    static get CREATED(): BulkCreateMeetingItemStatus & {
+        get name(): "CREATED";
+        get ordinal(): 0;
+    };
+    static get VALIDATED(): BulkCreateMeetingItemStatus & {
+        get name(): "VALIDATED";
+        get ordinal(): 1;
+    };
+    static get Created(): BulkCreateMeetingItemStatus & {
+        get name(): "CREATED";
+        get ordinal(): 0;
+    };
+    static get Validated(): BulkCreateMeetingItemStatus & {
+        get name(): "VALIDATED";
+        get ordinal(): 1;
+    };
+    static values(): [typeof BulkCreateMeetingItemStatus.CREATED, typeof BulkCreateMeetingItemStatus.VALIDATED];
+    static valueOf(value: string): BulkCreateMeetingItemStatus;
+    get name(): "CREATED" | "VALIDATED";
+    get ordinal(): 0 | 1;
+    get value(): string;
+    toString(): string;
+}
+export declare namespace BulkCreateMeetingItemStatus {
+    /** @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 () => BulkCreateMeetingItemStatus;
+    }
+    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<BulkCreateMeetingItemStatus>;
+                private constructor();
+            }
+        }
+    }
+}
+export declare class BulkCreateMeetingsCommand {
+    constructor(dryRun: Nullable<boolean> | undefined, items: KtList<BulkCreateMeetingCommand>);
+    get dryRun(): Nullable<boolean>;
+    get items(): KtList<BulkCreateMeetingCommand>;
+    copy(dryRun?: Nullable<boolean>, items?: KtList<BulkCreateMeetingCommand>): BulkCreateMeetingsCommand;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateMeetingsCommand {
+    /** @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 () => BulkCreateMeetingsCommand;
+    }
+}
+export declare class BulkCreateMeetingsResult {
+    constructor(items: KtList<BulkCreateMeetingItemResult>, summary?: Nullable<BulkCreateMeetingsSummary>);
+    get items(): KtList<BulkCreateMeetingItemResult>;
+    get summary(): Nullable<BulkCreateMeetingsSummary>;
+    copy(items?: KtList<BulkCreateMeetingItemResult>, summary?: Nullable<BulkCreateMeetingsSummary>): BulkCreateMeetingsResult;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateMeetingsResult {
+    /** @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 () => BulkCreateMeetingsResult;
+    }
+}
+export declare class BulkCreateMeetingsSummary {
+    constructor(created: bigint, dryRun: boolean, total: bigint, validated: bigint);
+    get created(): bigint;
+    get dryRun(): boolean;
+    get total(): bigint;
+    get validated(): bigint;
+    copy(created?: bigint, dryRun?: boolean, total?: bigint, validated?: bigint): BulkCreateMeetingsSummary;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateMeetingsSummary {
+    /** @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 () => BulkCreateMeetingsSummary;
+    }
+}
+export declare class BulkCreateNewsletterCommand {
+    constructor(clientReference: Nullable<string> | undefined, command: CreateNewsletterCommand, companyId: bigint);
+    get clientReference(): Nullable<string>;
+    get command(): CreateNewsletterCommand;
+    get companyId(): bigint;
+    copy(clientReference?: Nullable<string>, command?: CreateNewsletterCommand, companyId?: bigint): BulkCreateNewsletterCommand;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateNewsletterCommand {
+    /** @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 () => BulkCreateNewsletterCommand;
+    }
+}
+export declare class BulkCreateNewsletterItemResult {
+    constructor(clientReference: Nullable<string> | undefined, companyId: bigint, index: bigint, newsletterId: Nullable<bigint> | undefined, status: BulkCreateNewsletterItemStatus);
+    get clientReference(): Nullable<string>;
+    get companyId(): bigint;
+    get index(): bigint;
+    get newsletterId(): Nullable<bigint>;
+    get status(): BulkCreateNewsletterItemStatus;
+    copy(clientReference?: Nullable<string>, companyId?: bigint, index?: bigint, newsletterId?: Nullable<bigint>, status?: BulkCreateNewsletterItemStatus): BulkCreateNewsletterItemResult;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateNewsletterItemResult {
+    /** @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 () => BulkCreateNewsletterItemResult;
+    }
+}
+export declare abstract class BulkCreateNewsletterItemStatus {
+    private constructor();
+    static get CREATED(): BulkCreateNewsletterItemStatus & {
+        get name(): "CREATED";
+        get ordinal(): 0;
+    };
+    static get VALIDATED(): BulkCreateNewsletterItemStatus & {
+        get name(): "VALIDATED";
+        get ordinal(): 1;
+    };
+    static get Created(): BulkCreateNewsletterItemStatus & {
+        get name(): "CREATED";
+        get ordinal(): 0;
+    };
+    static get Validated(): BulkCreateNewsletterItemStatus & {
+        get name(): "VALIDATED";
+        get ordinal(): 1;
+    };
+    static values(): [typeof BulkCreateNewsletterItemStatus.CREATED, typeof BulkCreateNewsletterItemStatus.VALIDATED];
+    static valueOf(value: string): BulkCreateNewsletterItemStatus;
+    get name(): "CREATED" | "VALIDATED";
+    get ordinal(): 0 | 1;
+    get value(): string;
+    toString(): string;
+}
+export declare namespace BulkCreateNewsletterItemStatus {
+    /** @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 () => BulkCreateNewsletterItemStatus;
+    }
+    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<BulkCreateNewsletterItemStatus>;
+                private constructor();
+            }
+        }
+    }
+}
+export declare class BulkCreateNewslettersCommand {
+    constructor(dryRun: Nullable<boolean> | undefined, items: KtList<BulkCreateNewsletterCommand>);
+    get dryRun(): Nullable<boolean>;
+    get items(): KtList<BulkCreateNewsletterCommand>;
+    copy(dryRun?: Nullable<boolean>, items?: KtList<BulkCreateNewsletterCommand>): BulkCreateNewslettersCommand;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateNewslettersCommand {
+    /** @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 () => BulkCreateNewslettersCommand;
+    }
+}
+export declare class BulkCreateNewslettersResult {
+    constructor(items: KtList<BulkCreateNewsletterItemResult>, summary?: Nullable<BulkCreateNewslettersSummary>);
+    get items(): KtList<BulkCreateNewsletterItemResult>;
+    get summary(): Nullable<BulkCreateNewslettersSummary>;
+    copy(items?: KtList<BulkCreateNewsletterItemResult>, summary?: Nullable<BulkCreateNewslettersSummary>): BulkCreateNewslettersResult;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateNewslettersResult {
+    /** @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 () => BulkCreateNewslettersResult;
+    }
+}
+export declare class BulkCreateNewslettersSummary {
+    constructor(created: bigint, dryRun: boolean, total: bigint, validated: bigint);
+    get created(): bigint;
+    get dryRun(): boolean;
+    get total(): bigint;
+    get validated(): bigint;
+    copy(created?: bigint, dryRun?: boolean, total?: bigint, validated?: bigint): BulkCreateNewslettersSummary;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateNewslettersSummary {
+    /** @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 () => BulkCreateNewslettersSummary;
+    }
+}
+export declare class BulkCreateSMSBroadcastCommand {
+    constructor(clientReference: Nullable<string> | undefined, command: CreateSMSBroadcastCommand, companyId: bigint);
+    get clientReference(): Nullable<string>;
+    get command(): CreateSMSBroadcastCommand;
+    get companyId(): bigint;
+    copy(clientReference?: Nullable<string>, command?: CreateSMSBroadcastCommand, companyId?: bigint): BulkCreateSMSBroadcastCommand;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateSMSBroadcastCommand {
+    /** @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 () => BulkCreateSMSBroadcastCommand;
+    }
+}
+export declare class BulkCreateSMSBroadcastItemResult {
+    constructor(broadcastId: Nullable<bigint> | undefined, clientReference: Nullable<string> | undefined, companyId: bigint, index: bigint, status: BulkCreateSMSBroadcastItemStatus);
+    get broadcastId(): Nullable<bigint>;
+    get clientReference(): Nullable<string>;
+    get companyId(): bigint;
+    get index(): bigint;
+    get status(): BulkCreateSMSBroadcastItemStatus;
+    copy(broadcastId?: Nullable<bigint>, clientReference?: Nullable<string>, companyId?: bigint, index?: bigint, status?: BulkCreateSMSBroadcastItemStatus): BulkCreateSMSBroadcastItemResult;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateSMSBroadcastItemResult {
+    /** @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 () => BulkCreateSMSBroadcastItemResult;
+    }
+}
+export declare abstract class BulkCreateSMSBroadcastItemStatus {
+    private constructor();
+    static get CREATED(): BulkCreateSMSBroadcastItemStatus & {
+        get name(): "CREATED";
+        get ordinal(): 0;
+    };
+    static get VALIDATED(): BulkCreateSMSBroadcastItemStatus & {
+        get name(): "VALIDATED";
+        get ordinal(): 1;
+    };
+    static get Created(): BulkCreateSMSBroadcastItemStatus & {
+        get name(): "CREATED";
+        get ordinal(): 0;
+    };
+    static get Validated(): BulkCreateSMSBroadcastItemStatus & {
+        get name(): "VALIDATED";
+        get ordinal(): 1;
+    };
+    static values(): [typeof BulkCreateSMSBroadcastItemStatus.CREATED, typeof BulkCreateSMSBroadcastItemStatus.VALIDATED];
+    static valueOf(value: string): BulkCreateSMSBroadcastItemStatus;
+    get name(): "CREATED" | "VALIDATED";
+    get ordinal(): 0 | 1;
+    get value(): string;
+    toString(): string;
+}
+export declare namespace BulkCreateSMSBroadcastItemStatus {
+    /** @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 () => BulkCreateSMSBroadcastItemStatus;
+    }
+    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<BulkCreateSMSBroadcastItemStatus>;
+                private constructor();
+            }
+        }
+    }
+}
+export declare class BulkCreateSMSBroadcastsCommand {
+    constructor(dryRun: Nullable<boolean> | undefined, items: KtList<BulkCreateSMSBroadcastCommand>);
+    get dryRun(): Nullable<boolean>;
+    get items(): KtList<BulkCreateSMSBroadcastCommand>;
+    copy(dryRun?: Nullable<boolean>, items?: KtList<BulkCreateSMSBroadcastCommand>): BulkCreateSMSBroadcastsCommand;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateSMSBroadcastsCommand {
+    /** @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 () => BulkCreateSMSBroadcastsCommand;
+    }
+}
+export declare class BulkCreateSMSBroadcastsResult {
+    constructor(items: KtList<BulkCreateSMSBroadcastItemResult>, summary?: Nullable<BulkCreateSMSBroadcastsSummary>);
+    get items(): KtList<BulkCreateSMSBroadcastItemResult>;
+    get summary(): Nullable<BulkCreateSMSBroadcastsSummary>;
+    copy(items?: KtList<BulkCreateSMSBroadcastItemResult>, summary?: Nullable<BulkCreateSMSBroadcastsSummary>): BulkCreateSMSBroadcastsResult;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateSMSBroadcastsResult {
+    /** @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 () => BulkCreateSMSBroadcastsResult;
+    }
+}
+export declare class BulkCreateSMSBroadcastsSummary {
+    constructor(created: bigint, dryRun: boolean, total: bigint, validated: bigint);
+    get created(): bigint;
+    get dryRun(): boolean;
+    get total(): bigint;
+    get validated(): bigint;
+    copy(created?: bigint, dryRun?: boolean, total?: bigint, validated?: bigint): BulkCreateSMSBroadcastsSummary;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkCreateSMSBroadcastsSummary {
+    /** @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 () => BulkCreateSMSBroadcastsSummary;
+    }
+}
 export declare class BulkImportTaskCommand {
     constructor(clientReference: Nullable<string> | undefined, command: CreateTaskCommand, companyId: bigint);
     get clientReference(): Nullable<string>;
@@ -769,6 +1637,268 @@ export declare namespace BulkImportTasksSummary {
         const constructor: abstract new () => BulkImportTasksSummary;
     }
 }
+export declare class BulkPublishNewsletterCommand {
+    constructor(clientReference: Nullable<string> | undefined, companyId: bigint, newsletterId: bigint);
+    get clientReference(): Nullable<string>;
+    get companyId(): bigint;
+    get newsletterId(): bigint;
+    copy(clientReference?: Nullable<string>, companyId?: bigint, newsletterId?: bigint): BulkPublishNewsletterCommand;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkPublishNewsletterCommand {
+    /** @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 () => BulkPublishNewsletterCommand;
+    }
+}
+export declare class BulkPublishNewsletterItemResult {
+    constructor(clientReference: Nullable<string> | undefined, companyId: bigint, index: bigint, newsletterId: bigint, status: BulkPublishNewsletterItemStatus);
+    get clientReference(): Nullable<string>;
+    get companyId(): bigint;
+    get index(): bigint;
+    get newsletterId(): bigint;
+    get status(): BulkPublishNewsletterItemStatus;
+    copy(clientReference?: Nullable<string>, companyId?: bigint, index?: bigint, newsletterId?: bigint, status?: BulkPublishNewsletterItemStatus): BulkPublishNewsletterItemResult;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkPublishNewsletterItemResult {
+    /** @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 () => BulkPublishNewsletterItemResult;
+    }
+}
+export declare abstract class BulkPublishNewsletterItemStatus {
+    private constructor();
+    static get PUBLISHED(): BulkPublishNewsletterItemStatus & {
+        get name(): "PUBLISHED";
+        get ordinal(): 0;
+    };
+    static get VALIDATED(): BulkPublishNewsletterItemStatus & {
+        get name(): "VALIDATED";
+        get ordinal(): 1;
+    };
+    static get Published(): BulkPublishNewsletterItemStatus & {
+        get name(): "PUBLISHED";
+        get ordinal(): 0;
+    };
+    static get Validated(): BulkPublishNewsletterItemStatus & {
+        get name(): "VALIDATED";
+        get ordinal(): 1;
+    };
+    static values(): [typeof BulkPublishNewsletterItemStatus.PUBLISHED, typeof BulkPublishNewsletterItemStatus.VALIDATED];
+    static valueOf(value: string): BulkPublishNewsletterItemStatus;
+    get name(): "PUBLISHED" | "VALIDATED";
+    get ordinal(): 0 | 1;
+    get value(): string;
+    toString(): string;
+}
+export declare namespace BulkPublishNewsletterItemStatus {
+    /** @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 () => BulkPublishNewsletterItemStatus;
+    }
+    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<BulkPublishNewsletterItemStatus>;
+                private constructor();
+            }
+        }
+    }
+}
+export declare class BulkPublishNewslettersCommand {
+    constructor(dryRun: Nullable<boolean> | undefined, items: KtList<BulkPublishNewsletterCommand>);
+    get dryRun(): Nullable<boolean>;
+    get items(): KtList<BulkPublishNewsletterCommand>;
+    copy(dryRun?: Nullable<boolean>, items?: KtList<BulkPublishNewsletterCommand>): BulkPublishNewslettersCommand;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkPublishNewslettersCommand {
+    /** @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 () => BulkPublishNewslettersCommand;
+    }
+}
+export declare class BulkPublishNewslettersResult {
+    constructor(items: KtList<BulkPublishNewsletterItemResult>, summary?: Nullable<BulkPublishNewslettersSummary>);
+    get items(): KtList<BulkPublishNewsletterItemResult>;
+    get summary(): Nullable<BulkPublishNewslettersSummary>;
+    copy(items?: KtList<BulkPublishNewsletterItemResult>, summary?: Nullable<BulkPublishNewslettersSummary>): BulkPublishNewslettersResult;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkPublishNewslettersResult {
+    /** @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 () => BulkPublishNewslettersResult;
+    }
+}
+export declare class BulkPublishNewslettersSummary {
+    constructor(dryRun: boolean, published: bigint, total: bigint, validated: bigint);
+    get dryRun(): boolean;
+    get published(): bigint;
+    get total(): bigint;
+    get validated(): bigint;
+    copy(dryRun?: boolean, published?: bigint, total?: bigint, validated?: bigint): BulkPublishNewslettersSummary;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkPublishNewslettersSummary {
+    /** @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 () => BulkPublishNewslettersSummary;
+    }
+}
+export declare class BulkPublishSMSBroadcastCommand {
+    constructor(broadcastId: bigint, clientReference: Nullable<string> | undefined, companyId: bigint);
+    get broadcastId(): bigint;
+    get clientReference(): Nullable<string>;
+    get companyId(): bigint;
+    copy(broadcastId?: bigint, clientReference?: Nullable<string>, companyId?: bigint): BulkPublishSMSBroadcastCommand;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkPublishSMSBroadcastCommand {
+    /** @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 () => BulkPublishSMSBroadcastCommand;
+    }
+}
+export declare class BulkPublishSMSBroadcastItemResult {
+    constructor(broadcastId: bigint, clientReference: Nullable<string> | undefined, companyId: bigint, index: bigint, status: BulkPublishSMSBroadcastItemStatus);
+    get broadcastId(): bigint;
+    get clientReference(): Nullable<string>;
+    get companyId(): bigint;
+    get index(): bigint;
+    get status(): BulkPublishSMSBroadcastItemStatus;
+    copy(broadcastId?: bigint, clientReference?: Nullable<string>, companyId?: bigint, index?: bigint, status?: BulkPublishSMSBroadcastItemStatus): BulkPublishSMSBroadcastItemResult;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkPublishSMSBroadcastItemResult {
+    /** @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 () => BulkPublishSMSBroadcastItemResult;
+    }
+}
+export declare abstract class BulkPublishSMSBroadcastItemStatus {
+    private constructor();
+    static get PUBLISHED(): BulkPublishSMSBroadcastItemStatus & {
+        get name(): "PUBLISHED";
+        get ordinal(): 0;
+    };
+    static get VALIDATED(): BulkPublishSMSBroadcastItemStatus & {
+        get name(): "VALIDATED";
+        get ordinal(): 1;
+    };
+    static get Published(): BulkPublishSMSBroadcastItemStatus & {
+        get name(): "PUBLISHED";
+        get ordinal(): 0;
+    };
+    static get Validated(): BulkPublishSMSBroadcastItemStatus & {
+        get name(): "VALIDATED";
+        get ordinal(): 1;
+    };
+    static values(): [typeof BulkPublishSMSBroadcastItemStatus.PUBLISHED, typeof BulkPublishSMSBroadcastItemStatus.VALIDATED];
+    static valueOf(value: string): BulkPublishSMSBroadcastItemStatus;
+    get name(): "PUBLISHED" | "VALIDATED";
+    get ordinal(): 0 | 1;
+    get value(): string;
+    toString(): string;
+}
+export declare namespace BulkPublishSMSBroadcastItemStatus {
+    /** @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 () => BulkPublishSMSBroadcastItemStatus;
+    }
+    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<BulkPublishSMSBroadcastItemStatus>;
+                private constructor();
+            }
+        }
+    }
+}
+export declare class BulkPublishSMSBroadcastsCommand {
+    constructor(dryRun: Nullable<boolean> | undefined, items: KtList<BulkPublishSMSBroadcastCommand>);
+    get dryRun(): Nullable<boolean>;
+    get items(): KtList<BulkPublishSMSBroadcastCommand>;
+    copy(dryRun?: Nullable<boolean>, items?: KtList<BulkPublishSMSBroadcastCommand>): BulkPublishSMSBroadcastsCommand;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkPublishSMSBroadcastsCommand {
+    /** @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 () => BulkPublishSMSBroadcastsCommand;
+    }
+}
+export declare class BulkPublishSMSBroadcastsResult {
+    constructor(items: KtList<BulkPublishSMSBroadcastItemResult>, summary?: Nullable<BulkPublishSMSBroadcastsSummary>);
+    get items(): KtList<BulkPublishSMSBroadcastItemResult>;
+    get summary(): Nullable<BulkPublishSMSBroadcastsSummary>;
+    copy(items?: KtList<BulkPublishSMSBroadcastItemResult>, summary?: Nullable<BulkPublishSMSBroadcastsSummary>): BulkPublishSMSBroadcastsResult;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkPublishSMSBroadcastsResult {
+    /** @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 () => BulkPublishSMSBroadcastsResult;
+    }
+}
+export declare class BulkPublishSMSBroadcastsSummary {
+    constructor(dryRun: boolean, published: bigint, total: bigint, validated: bigint);
+    get dryRun(): boolean;
+    get published(): bigint;
+    get total(): bigint;
+    get validated(): bigint;
+    copy(dryRun?: boolean, published?: bigint, total?: bigint, validated?: bigint): BulkPublishSMSBroadcastsSummary;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkPublishSMSBroadcastsSummary {
+    /** @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 () => BulkPublishSMSBroadcastsSummary;
+    }
+}
+export declare class BulkUserActions {
+    constructor(items: KtList<UserActionsByCompany>);
+    get items(): KtList<UserActionsByCompany>;
+    copy(items?: KtList<UserActionsByCompany>): BulkUserActions;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace BulkUserActions {
+    /** @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 () => BulkUserActions;
+    }
+}
 export declare class BusinessAddress {
     constructor(address?: Nullable<AddressSpecifics>, country?: Nullable<bigint>, matrikkel?: Nullable<CompanyMatrikkel>);
     get address(): Nullable<AddressSpecifics>;
@@ -6354,6 +7484,27 @@ export declare namespace InvoicePlanTransaction {
         const constructor: abstract new () => InvoicePlanTransaction;
     }
 }
+export declare class InvoicePlanTransactionOverview {
+    constructor(companyId: bigint, createdAt: any/* Instant */, id: bigint, invoicePlanActive: boolean, invoicePlanId: bigint, invoicePlanName: string, invoicePlanType: InvoicePlanType, overdueEnabled: boolean);
+    get companyId(): bigint;
+    get createdAt(): any/* Instant */;
+    get id(): bigint;
+    get invoicePlanActive(): boolean;
+    get invoicePlanId(): bigint;
+    get invoicePlanName(): string;
+    get invoicePlanType(): InvoicePlanType;
+    get overdueEnabled(): boolean;
+    copy(companyId?: bigint, createdAt?: any/* Instant */, id?: bigint, invoicePlanActive?: boolean, invoicePlanId?: bigint, invoicePlanName?: string, invoicePlanType?: InvoicePlanType, overdueEnabled?: boolean): InvoicePlanTransactionOverview;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace InvoicePlanTransactionOverview {
+    /** @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 () => InvoicePlanTransactionOverview;
+    }
+}
 export declare abstract class InvoicePlanType {
     private constructor();
     static get FELLESKOSTNADER(): InvoicePlanType & {
@@ -9873,6 +11024,22 @@ export declare namespace PagedListInvoicePlanTransaction {
         const constructor: abstract new () => PagedListInvoicePlanTransaction;
     }
 }
+export declare class PagedListInvoicePlanTransactionOverview {
+    constructor(items: KtList<InvoicePlanTransactionOverview>, meta: Meta, paging: Paging);
+    get items(): KtList<InvoicePlanTransactionOverview>;
+    get meta(): Meta;
+    get paging(): Paging;
+    copy(items?: KtList<InvoicePlanTransactionOverview>, meta?: Meta, paging?: Paging): PagedListInvoicePlanTransactionOverview;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace PagedListInvoicePlanTransactionOverview {
+    /** @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 () => PagedListInvoicePlanTransactionOverview;
+    }
+}
 export declare class PagedListInvoicePlanType {
     constructor(items: KtList<InvoicePlanType>, meta: Meta, paging: Paging);
     get items(): KtList<InvoicePlanType>;
@@ -9905,6 +11072,22 @@ export declare namespace PagedListInvoicePreview {
         const constructor: abstract new () => PagedListInvoicePreview;
     }
 }
+export declare class PagedListInvoiceSettings {
+    constructor(items: KtList<InvoiceSettings>, meta: Meta, paging: Paging);
+    get items(): KtList<InvoiceSettings>;
+    get meta(): Meta;
+    get paging(): Paging;
+    copy(items?: KtList<InvoiceSettings>, meta?: Meta, paging?: Paging): PagedListInvoiceSettings;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace PagedListInvoiceSettings {
+    /** @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 () => PagedListInvoiceSettings;
+    }
+}
 export declare class PagedListIssue {
     constructor(items: KtList<Issue>, meta: Meta, paging: Paging);
     get items(): KtList<Issue>;
@@ -10145,6 +11328,22 @@ export declare namespace PagedListPost {
         const constructor: abstract new () => PagedListPost;
     }
 }
+export declare class PagedListQueuedInvoice {
+    constructor(items: KtList<QueuedInvoice>, meta: Meta, paging: Paging);
+    get items(): KtList<QueuedInvoice>;
+    get meta(): Meta;
+    get paging(): Paging;
+    copy(items?: KtList<QueuedInvoice>, meta?: Meta, paging?: Paging): PagedListQueuedInvoice;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace PagedListQueuedInvoice {
+    /** @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 () => PagedListQueuedInvoice;
+    }
+}
 export declare class PagedListResident {
     constructor(items: KtList<Resident>, meta: Meta, paging: Paging);
     get items(): KtList<Resident>;
@@ -11189,21 +12388,20 @@ export declare namespace PaymentHandlingStatus {
     }
 }
 export declare class PaymentRecord {
-    constructor(amount?: Nullable<number>, currency?: Nullable<string>, id?: Nullable<string>, invoiceId?: Nullable<string>, kid?: Nullable<string>, note?: Nullable<string>, origin?: Nullable<string>, payee?: Nullable<string>, payer?: Nullable<string>, payerName?: Nullable<string>, paymentDate?: Nullable<bigint>, paymentHandling?: Nullable<PaymentHandling>, tenant?: Nullable<string>);
+    constructor(amount: Nullable<number> | undefined, currency: Nullable<string> | undefined, id: string, invoiceId: Nullable<string> | undefined, kid: Nullable<string> | undefined, note: Nullable<string> | undefined, origin: Nullable<string> | undefined, payee: string, payer: string, payerName: Nullable<string> | undefined, paymentDate: bigint, tenant: string);
     get amount(): Nullable<number>;
     get currency(): Nullable<string>;
-    get id(): Nullable<string>;
+    get id(): string;
     get invoiceId(): Nullable<string>;
     get kid(): Nullable<string>;
     get note(): Nullable<string>;
     get origin(): Nullable<string>;
-    get payee(): Nullable<string>;
-    get payer(): Nullable<string>;
+    get payee(): string;
+    get payer(): string;
     get payerName(): Nullable<string>;
-    get paymentDate(): Nullable<bigint>;
-    get paymentHandling(): Nullable<PaymentHandling>;
-    get tenant(): Nullable<string>;
-    copy(amount?: Nullable<number>, currency?: Nullable<string>, id?: Nullable<string>, invoiceId?: Nullable<string>, kid?: Nullable<string>, note?: Nullable<string>, origin?: Nullable<string>, payee?: Nullable<string>, payer?: Nullable<string>, payerName?: Nullable<string>, paymentDate?: Nullable<bigint>, paymentHandling?: Nullable<PaymentHandling>, tenant?: Nullable<string>): PaymentRecord;
+    get paymentDate(): bigint;
+    get tenant(): string;
+    copy(amount?: Nullable<number>, currency?: Nullable<string>, id?: string, invoiceId?: Nullable<string>, kid?: Nullable<string>, note?: Nullable<string>, origin?: Nullable<string>, payee?: string, payer?: string, payerName?: Nullable<string>, paymentDate?: bigint, tenant?: string): PaymentRecord;
     toString(): string;
     hashCode(): number;
     equals(other: Nullable<any>): boolean;
@@ -12070,6 +13268,21 @@ export declare namespace PublicMessage {
         const constructor: abstract new () => PublicMessage;
     }
 }
+export declare class QueuedInvoice {
+    constructor(companyId: bigint, invoice: InvoiceInput);
+    get companyId(): bigint;
+    get invoice(): InvoiceInput;
+    copy(companyId?: bigint, invoice?: InvoiceInput): QueuedInvoice;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace QueuedInvoice {
+    /** @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 () => QueuedInvoice;
+    }
+}
 export declare class ReceiverFraction {
     constructor(denominator: bigint, numerator: bigint, receiverId: bigint, receiverType: InvoiceDistributionReceiverType, recipients?: Nullable<KtList<FractionRecipient>>);
     get denominator(): bigint;
@@ -16879,6 +18092,21 @@ export declare namespace UrlWrapper {
         const constructor: abstract new () => UrlWrapper;
     }
 }
+export declare class UserActionsByCompany {
+    constructor(actions: KtList<string>, companyId: bigint);
+    get actions(): KtList<string>;
+    get companyId(): bigint;
+    copy(actions?: KtList<string>, companyId?: bigint): UserActionsByCompany;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace UserActionsByCompany {
+    /** @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 () => UserActionsByCompany;
+    }
+}
 export declare class UserConversations {
     constructor(company: Company, conversations: KtList<Conversation>);
     get company(): Company;
@@ -17119,6 +18347,8 @@ export declare class CommunicationApi extends ApiClient.$metadata$.constructor {
     createEmailNewsletter(companyId: bigint, createNewsletterCommand: CreateNewsletterCommand): Promise<HttpResponse<Newsletter>>;
     createLetter(sendLetterCommand: SendLetterCommand): Promise<HttpResponse<SentLetter>>;
     createLetterInCompany(companyId: bigint, sendLetterCommand: SendLetterCommand): Promise<HttpResponse<SentLetter>>;
+    createMultipleEmailNewsletters(bulkCreateNewslettersCommand: BulkCreateNewslettersCommand): Promise<HttpResponse<BulkCreateNewslettersResult>>;
+    createMultipleSMSBroadcasts(bulkCreateSMSBroadcastsCommand: BulkCreateSMSBroadcastsCommand): Promise<HttpResponse<BulkCreateSMSBroadcastsResult>>;
     createSMSBroadcast(companyId: bigint, createSMSBroadcastCommand: CreateSMSBroadcastCommand): Promise<HttpResponse<SMSBroadcast>>;
     createSMSPurchase(companyId: bigint, bundleId: bigint): Promise<HttpResponse<void>>;
     deleteEmailNewsletter(companyId: bigint, newsletterId: bigint): Promise<HttpResponse<void>>;
@@ -17132,6 +18362,8 @@ export declare class CommunicationApi extends ApiClient.$metadata$.constructor {
     indexSMSNotificationGroups(companyId: bigint, fields?: Nullable<string>): Promise<HttpResponse<MassCommunicationGroups>>;
     indexSMSPurchases(companyId: bigint, fields?: Nullable<string>, pageToken?: Nullable<string>, autoPaginate?: Nullable<boolean>, count?: Nullable<number>): Promise<HttpResponse<PagedListSMSBundlePurchase>>;
     publishEmailNewsletter(companyId: bigint, newsletterId: bigint): Promise<HttpResponse<Newsletter>>;
+    publishMultipleEmailNewsletters(bulkPublishNewslettersCommand: BulkPublishNewslettersCommand): Promise<HttpResponse<BulkPublishNewslettersResult>>;
+    publishMultipleSMSBroadcasts(bulkPublishSMSBroadcastsCommand: BulkPublishSMSBroadcastsCommand): Promise<HttpResponse<BulkPublishSMSBroadcastsResult>>;
     publishSMSBroadcast(companyId: bigint, broadcastId: bigint, purchaseBundleId?: Nullable<bigint>): Promise<HttpResponse<SMSBroadcast>>;
     reportPushNotificationRead(companyId: bigint, trackingId: string): Promise<HttpResponse<void>>;
     showCommunicationReport(companyId: bigint, communicationType: string, communicationId: bigint, reportType: string, fields?: Nullable<string>): Promise<HttpResponse<CommunicationReport>>;
@@ -17209,6 +18441,7 @@ export declare class ConversationApi extends ApiClient.$metadata$.constructor {
     createInternalMessage(companyId: bigint, conversationId: bigint, createInternalMessageCommand: CreateInternalMessageCommand): Promise<HttpResponse<MessageInConversation>>;
     createMessage(companyId: bigint, conversationId: bigint, createMessageCommand: CreateMessageCommand): Promise<HttpResponse<MessageInConversation>>;
     createMessagePublicConversation(companySlug: string, conversationId: bigint, createMessageCommand: CreateMessageCommand): Promise<HttpResponse<void>>;
+    createMultipleConversations(bulkCreateConversationsCommand: BulkCreateConversationsCommand): Promise<HttpResponse<BulkCreateConversationsResult>>;
     deleteConversation(companyId: bigint, conversationId: bigint, translateToCountryId?: Nullable<bigint>): Promise<HttpResponse<void>>;
     deleteConversationCategory(companyId: bigint, categoryId: bigint): Promise<HttpResponse<void>>;
     deleteConversationFlag(companyId: bigint, conversationId: bigint): Promise<HttpResponse<void>>;
@@ -17332,6 +18565,8 @@ export declare class HomepageApi extends ApiClient.$metadata$.constructor {
     static create(baseUrl?: string, httpClientEngine?: Nullable<any>/* Nullable<HttpClientEngine> */, httpClientConfig?: Nullable<(p0: any/* HttpClientConfig<UnknownType *> */) => void>, jsonSerializer?: any/* Json */): HomepageApi;
     static createWithClient(baseUrl: string, httpClient: any/* HttpClient */): HomepageApi;
     checkSMSForPost(companyId: bigint, validateSMSCommand: ValidateSMSCommand, postId?: Nullable<bigint>): Promise<HttpResponse<SMSBundle>>;
+    createMultipleHomepagePosts(bulkCreateHomepagePostsCommand: BulkCreateHomepagePostsCommand): Promise<HttpResponse<BulkCreateHomepagePostsResult>>;
+    createMultipleHomepagePracticalInfo(bulkCreateHomepagePracticalInfoCommand: BulkCreateHomepagePracticalInfoCommand): Promise<HttpResponse<BulkCreateHomepagePracticalInfoResult>>;
     createPost(companyId: bigint, createPostCommand: CreatePostCommand, purchaseBundleId?: Nullable<bigint>): Promise<HttpResponse<Post>>;
     createPracticalInfo(companyId: bigint, createPostCommand: CreatePostCommand, purchaseBundleId?: Nullable<bigint>): Promise<HttpResponse<Post>>;
     deletePost(companyId: bigint, postId: bigint, purchaseBundleId?: Nullable<bigint>, publishChanges?: Nullable<boolean>): Promise<HttpResponse<void>>;
@@ -17435,6 +18670,7 @@ export declare class InvoicingApi extends ApiClient.$metadata$.constructor {
     indexInvoicingCustomerInvoices(companyId: bigint, customerType: string, customerId: bigint, fields?: Nullable<string>, pageToken?: Nullable<string>, autoPaginate?: Nullable<boolean>, count?: Nullable<number>): Promise<HttpResponse<PagedListInvoice>>;
     indexInvoicingCustomerMetadata(companyId: bigint, customerType: string, customerId: bigint, fields?: Nullable<string>): Promise<HttpResponse<CustomerMetadata>>;
     indexInvoicingCustomers(companyId: bigint, fields?: Nullable<string>, pageToken?: Nullable<string>, autoPaginate?: Nullable<boolean>, count?: Nullable<number>): Promise<HttpResponse<PagedListCustomer>>;
+    indexInvoicingCustomersForCompanies(companyIds?: Nullable<KtList<bigint>>, search?: Nullable<string>, active?: Nullable<boolean>, external?: Nullable<boolean>, isRecipient?: Nullable<boolean>, customerType?: Nullable<CustomerType>, fields?: Nullable<string>, pageToken?: Nullable<string>, autoPaginate?: Nullable<boolean>, count?: Nullable<number>): Promise<HttpResponse<PagedListCustomer>>;
     indexInvoicingForCompaniesExpired(fields?: Nullable<string>): Promise<HttpResponse<TriplewinOverdueInvoiceOverview>>;
     indexInvoicingForCompaniesExpiredTypes(fields?: Nullable<string>, pageToken?: Nullable<string>, autoPaginate?: Nullable<boolean>, count?: Nullable<number>): Promise<HttpResponse<PagedListExpiredType>>;
     indexInvoicingForCompaniesOverdue(expiredType: ExpiredType, fields?: Nullable<string>, pageToken?: Nullable<string>, autoPaginate?: Nullable<boolean>, count?: Nullable<number>): Promise<HttpResponse<PagedListInvoice>>;
@@ -17443,14 +18679,19 @@ export declare class InvoicingApi extends ApiClient.$metadata$.constructor {
     indexInvoicingForCompanyHistory(companyId: bigint, periodStart: bigint, periodEnd: bigint, fields?: Nullable<string>, pageToken?: Nullable<string>, autoPaginate?: Nullable<boolean>, count?: Nullable<number>): Promise<HttpResponse<PagedListInvoice>>;
     indexInvoicingForCompanyQueued(companyId: bigint, fields?: Nullable<string>, pageToken?: Nullable<string>, autoPaginate?: Nullable<boolean>, count?: Nullable<number>): Promise<HttpResponse<PagedListInvoiceInput>>;
     indexInvoicingForCompanyQueuedPreview(companyId: bigint, invoiceId: string, fields?: Nullable<string>): Promise<HttpResponse<InvoiceResultPreview>>;
+    indexInvoicingHistoryForCompanies(periodStart: bigint, periodEnd: bigint, companyIds?: Nullable<KtList<bigint>>, search?: Nullable<string>, payerType?: Nullable<PayerType>, open?: Nullable<boolean>, fields?: Nullable<string>, pageToken?: Nullable<string>, autoPaginate?: Nullable<boolean>, count?: Nullable<number>): Promise<HttpResponse<PagedListInvoice>>;
     indexInvoicingInvoiceCredits(companyId: bigint, invoiceId: string, fields?: Nullable<string>, pageToken?: Nullable<string>, autoPaginate?: Nullable<boolean>, count?: Nullable<number>): Promise<HttpResponse<PagedListInvoice>>;
     indexInvoicingInvoicePayments(companyId: bigint, invoiceId: string, fields?: Nullable<string>, pageToken?: Nullable<string>, autoPaginate?: Nullable<boolean>, count?: Nullable<number>): Promise<HttpResponse<PagedListPaymentRecord>>;
     indexInvoicingInvoicePdfs(companyId: bigint, ids: KtList<string>): Promise<HttpResponse<Base64ByteArray>>;
+    indexInvoicingPlanTransactionsForCompanies(companyIds?: Nullable<KtList<bigint>>, invoicePlanIds?: Nullable<KtList<bigint>>, search?: Nullable<string>, active?: Nullable<boolean>, type?: Nullable<InvoicePlanType>, overdueEnabled?: Nullable<boolean>, createdAtFrom?: Nullable<bigint>, createdAtTo?: Nullable<bigint>, fields?: Nullable<string>, pageToken?: Nullable<string>, autoPaginate?: Nullable<boolean>, count?: Nullable<number>): Promise<HttpResponse<PagedListInvoicePlanTransactionOverview>>;
     indexInvoicingPlanTypes(companyId: bigint, fields?: Nullable<string>, pageToken?: Nullable<string>, autoPaginate?: Nullable<boolean>, count?: Nullable<number>): Promise<HttpResponse<PagedListInvoicePlanType>>;
     indexInvoicingPlans(companyId: bigint, active?: Nullable<boolean>, type?: Nullable<InvoicePlanType>, fields?: Nullable<string>, pageToken?: Nullable<string>, autoPaginate?: Nullable<boolean>, count?: Nullable<number>): Promise<HttpResponse<PagedListInvoicePlan>>;
+    indexInvoicingPlansForCompanies(companyIds?: Nullable<KtList<bigint>>, search?: Nullable<string>, active?: Nullable<boolean>, type?: Nullable<InvoicePlanType>, fields?: Nullable<string>, pageToken?: Nullable<string>, autoPaginate?: Nullable<boolean>, count?: Nullable<number>): Promise<HttpResponse<PagedListInvoicePlan>>;
     indexInvoicingSectionInvoiceRecipients(companyId: bigint, sectionId: bigint, fields?: Nullable<string>, pageToken?: Nullable<string>, autoPaginate?: Nullable<boolean>, count?: Nullable<number>): Promise<HttpResponse<PagedListSectionInvoiceRecipientOverview>>;
     indexInvoicingSectionInvoices(companyId: bigint, sectionId: bigint, fields?: Nullable<string>, pageToken?: Nullable<string>, autoPaginate?: Nullable<boolean>, count?: Nullable<number>): Promise<HttpResponse<PagedListInvoice>>;
     indexInvoicingSectionPlans(companyId: bigint, sectionId: bigint, active?: Nullable<boolean>, fields?: Nullable<string>, pageToken?: Nullable<string>, autoPaginate?: Nullable<boolean>, count?: Nullable<number>): Promise<HttpResponse<PagedListInvoicePlan>>;
+    indexInvoicingSettingsForCompanies(companyIds?: Nullable<KtList<bigint>>, fields?: Nullable<string>, pageToken?: Nullable<string>, autoPaginate?: Nullable<boolean>, count?: Nullable<number>): Promise<HttpResponse<PagedListInvoiceSettings>>;
+    indexQueuedInvoicingForCompanies(companyIds?: Nullable<KtList<bigint>>, fields?: Nullable<string>, pageToken?: Nullable<string>, autoPaginate?: Nullable<boolean>, count?: Nullable<number>): Promise<HttpResponse<PagedListQueuedInvoice>>;
     indexUpcomingInvoicing(fields?: Nullable<string>, pageToken?: Nullable<string>, autoPaginate?: Nullable<boolean>, count?: Nullable<number>): Promise<HttpResponse<PagedListGlobalPreview>>;
     lossInvoice(companyId: bigint, customerType: string, customerId: bigint, invoiceId: string): Promise<HttpResponse<void>>;
     putCompanyInvoiceClose(companyId: bigint, invoiceId: string, closeInvoiceCommand: CloseInvoiceCommand): Promise<HttpResponse<void>>;
@@ -17514,6 +18755,7 @@ export declare class IssueApi extends ApiClient.$metadata$.constructor {
     createIssueComment(companyId: bigint, issueId: bigint, createIssueCommentCommand: CreateIssueCommentCommand): Promise<HttpResponse<IssueDetails>>;
     createIssueConversation(companyId: bigint, issueId: bigint, conversationId: bigint): Promise<HttpResponse<IssueDetails>>;
     createIssueSection(companyId: bigint, issueId: bigint, sectionId: bigint): Promise<HttpResponse<IssueDetails>>;
+    createMultipleIssues(bulkCreateIssuesCommand: BulkCreateIssuesCommand): Promise<HttpResponse<BulkCreateIssuesResult>>;
     deleteIssue(companyId: bigint, issueId: bigint): Promise<HttpResponse<void>>;
     deleteIssueConversation(companyId: bigint, issueId: bigint, conversationId: bigint): Promise<HttpResponse<void>>;
     deleteIssueSection(companyId: bigint, issueId: bigint, sectionId: bigint): Promise<HttpResponse<void>>;
@@ -17591,6 +18833,7 @@ export declare class MeetingApi extends ApiClient.$metadata$.constructor {
     closeMeeting(companyId: bigint, meetingId: bigint, closeMeetingCommand: CloseMeetingCommand): Promise<HttpResponse<void>>;
     createMeeting(companyId: bigint, createMeetingCommand: CreateMeetingCommand): Promise<HttpResponse<MeetingDetails>>;
     createMeetingIssue(companyId: bigint, meetingId: bigint, issueId: bigint, attachIssueToMeetingCommand: AttachIssueToMeetingCommand): Promise<HttpResponse<IssueDetails>>;
+    createMultipleMeetings(bulkCreateMeetingsCommand: BulkCreateMeetingsCommand): Promise<HttpResponse<BulkCreateMeetingsResult>>;
     deleteMeeting(companyId: bigint, meetingId: bigint): Promise<HttpResponse<void>>;
     deleteMeetingIssue(companyId: bigint, meetingId: bigint, issueId: bigint): Promise<HttpResponse<void>>;
     finalizeMeetingSigning(companyId: bigint, meetingId: bigint): Promise<HttpResponse<void>>;
@@ -17961,6 +19204,7 @@ export declare class UserApi extends ApiClient.$metadata$.constructor {
     indexUserConversations(unread?: Nullable<boolean>, search?: Nullable<string>, fields?: Nullable<string>, pageToken?: Nullable<string>, autoPaginate?: Nullable<boolean>, count?: Nullable<number>): Promise<HttpResponse<PagedListUserConversations>>;
     me(fields?: Nullable<string>): Promise<HttpResponse<AuthUser>>;
     showAuthedUser(fields?: Nullable<string>): Promise<HttpResponse<AuthUser>>;
+    showBulkUserActions(companyIds: KtList<bigint>, fields?: Nullable<string>): Promise<HttpResponse<BulkUserActions>>;
     showUser(fields?: Nullable<string>): Promise<HttpResponse<PersonUser>>;
     showUserActions(companyId?: Nullable<bigint>, fields?: Nullable<string>, pageToken?: Nullable<string>, autoPaginate?: Nullable<boolean>, count?: Nullable<number>): Promise<HttpResponse<PagedListString>>;
     showUserImage(personId: bigint, fileName: string, size?: Nullable<string>): Promise<HttpResponse<void>>;