@diia-inhouse/types 6.24.0

package/dist/types/generated/google/protobuf/empty.d.ts

@@ -0,0 +1,25 @@
+import _m0 from "protobufjs/minimal.js";
+/**
+ * A generic empty message that you can re-use to avoid defining duplicated
+ * empty messages in your APIs. A typical example is to use it as the request
+ * or the response type of an API method. For instance:
+ *
+ *     service Foo {
+ *       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
+ *     }
+ */
+export interface Empty {
+}
+export declare const Empty: {
+    encode(_: Empty, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Empty;
+    fromJSON(_: any): Empty;
+    toJSON(_: Empty): unknown;
+    create(base?: DeepPartial<Empty>): Empty;
+    fromPartial(_: DeepPartial<Empty>): Empty;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export {};

package/dist/types/generated/google/protobuf/index.d.ts

@@ -0,0 +1,4 @@
+export * from './any.js';
+export * from './descriptor.js';
+export * from './empty.js';
+export * from './timestamp.js';

package/dist/types/generated/google/protobuf/timestamp.d.ts

@@ -0,0 +1,120 @@
+import _m0 from "protobufjs/minimal.js";
+/**
+ * A Timestamp represents a point in time independent of any time zone or local
+ * calendar, encoded as a count of seconds and fractions of seconds at
+ * nanosecond resolution. The count is relative to an epoch at UTC midnight on
+ * January 1, 1970, in the proleptic Gregorian calendar which extends the
+ * Gregorian calendar backwards to year one.
+ *
+ * All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
+ * second table is needed for interpretation, using a [24-hour linear
+ * smear](https://developers.google.com/time/smear).
+ *
+ * The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
+ * restricting to that range, we ensure that we can convert to and from [RFC
+ * 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
+ *
+ * # Examples
+ *
+ * Example 1: Compute Timestamp from POSIX `time()`.
+ *
+ *     Timestamp timestamp;
+ *     timestamp.set_seconds(time(NULL));
+ *     timestamp.set_nanos(0);
+ *
+ * Example 2: Compute Timestamp from POSIX `gettimeofday()`.
+ *
+ *     struct timeval tv;
+ *     gettimeofday(&tv, NULL);
+ *
+ *     Timestamp timestamp;
+ *     timestamp.set_seconds(tv.tv_sec);
+ *     timestamp.set_nanos(tv.tv_usec * 1000);
+ *
+ * Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
+ *
+ *     FILETIME ft;
+ *     GetSystemTimeAsFileTime(&ft);
+ *     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
+ *
+ *     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
+ *     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
+ *     Timestamp timestamp;
+ *     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
+ *     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
+ *
+ * Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
+ *
+ *     long millis = System.currentTimeMillis();
+ *
+ *     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
+ *         .setNanos((int) ((millis % 1000) * 1000000)).build();
+ *
+ * Example 5: Compute Timestamp from Java `Instant.now()`.
+ *
+ *     Instant now = Instant.now();
+ *
+ *     Timestamp timestamp =
+ *         Timestamp.newBuilder().setSeconds(now.getEpochSecond())
+ *             .setNanos(now.getNano()).build();
+ *
+ * Example 6: Compute Timestamp from current time in Python.
+ *
+ *     timestamp = Timestamp()
+ *     timestamp.GetCurrentTime()
+ *
+ * # JSON Mapping
+ *
+ * In JSON format, the Timestamp type is encoded as a string in the
+ * [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
+ * format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
+ * where {year} is always expressed using four digits while {month}, {day},
+ * {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
+ * seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
+ * are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
+ * is required. A proto3 JSON serializer should always use UTC (as indicated by
+ * "Z") when printing the Timestamp type and a proto3 JSON parser should be
+ * able to accept both UTC and other timezones (as indicated by an offset).
+ *
+ * For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
+ * 01:30 UTC on January 15, 2017.
+ *
+ * In JavaScript, one can convert a Date object to this format using the
+ * standard
+ * [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
+ * method. In Python, a standard `datetime.datetime` object can be converted
+ * to this format using
+ * [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
+ * the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
+ * the Joda Time's [`ISODateTimeFormat.dateTime()`](
+ * http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
+ * ) to obtain a formatter capable of generating timestamps in this format.
+ */
+export interface Timestamp {
+    /**
+     * Represents seconds of UTC time since Unix epoch
+     * 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
+     * 9999-12-31T23:59:59Z inclusive.
+     */
+    seconds: number;
+    /**
+     * Non-negative fractions of a second at nanosecond resolution. Negative
+     * second values with fractions must still have non-negative nanos values
+     * that count forward in time. Must be from 0 to 999,999,999
+     * inclusive.
+     */
+    nanos: number;
+}
+export declare const Timestamp: {
+    encode(message: Timestamp, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Timestamp;
+    fromJSON(object: any): Timestamp;
+    toJSON(message: Timestamp): unknown;
+    create(base?: DeepPartial<Timestamp>): Timestamp;
+    fromPartial(object: DeepPartial<Timestamp>): Timestamp;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export {};

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

@@ -0,0 +1,21 @@
+export * from './address.js';
+export * from './analytics.js';
+export * from './cardList.js';
+export * from './common.js';
+export * from './contextMenu.js';
+export * from './designSystem/index.js';
+export * from './documents/index.js';
+export * from './file/index.js';
+export * from './google/index.js';
+export * from './message.js';
+export * from './page/index.js';
+export * from './platformType.js';
+export * from './portal/index.js';
+export * from './profileFeature.js';
+export * from './publicService.js';
+export * from './publicServiceStatus.js';
+export * from './session/index.js';
+export * from './signing.js';
+export * from './token/index.js';
+export * from './ui.js';
+export * from './version.js';

package/dist/types/generated/message.d.ts

@@ -0,0 +1,135 @@
+import _m0 from "protobufjs/minimal.js";
+import { ArticlePicAtm } from "./designSystem/atoms/articlePicAtm.js";
+import { TextParameterAtm } from "./designSystem/atoms/textParameterAtm.js";
+import { ArticleVideoMlc } from "./designSystem/molecules/articleVideoMlc.js";
+import { TextLabelContainerMlc } from "./designSystem/molecules/textLabelContainerMlc.js";
+import { BottomGroupOrg } from "./designSystem/organisms/bottomGroupOrg.js";
+import { ListItemGroupOrg } from "./designSystem/organisms/listItemGroupOrg.js";
+export declare enum MessageBodyItemType {
+    text = "text",
+    image = "image",
+    video = "video",
+    internalArrowedLink = "internalArrowedLink",
+    externalArrowedLink = "externalArrowedLink",
+    downloadArrowedLink = "downloadArrowedLink",
+    separator = "separator"
+}
+export declare function messageBodyItemTypeFromJSON(object: any): MessageBodyItemType;
+export declare function messageBodyItemTypeToJSON(object: MessageBodyItemType): string;
+export declare function messageBodyItemTypeToNumber(object: MessageBodyItemType): number;
+export declare enum ArrowedLinkAction {
+    downloadLink = "downloadLink",
+    externalLink = "externalLink",
+    internalLink = "internalLink",
+    logout = "logout",
+    addDocument = "addDocument"
+}
+export declare function arrowedLinkActionFromJSON(object: any): ArrowedLinkAction;
+export declare function arrowedLinkActionToJSON(object: ArrowedLinkAction): string;
+export declare function arrowedLinkActionToNumber(object: ArrowedLinkAction): number;
+export declare enum ListItemState {
+    enabled = "enabled",
+    disabled = "disabled",
+    invisible = "invisible"
+}
+export declare function listItemStateFromJSON(object: any): ListItemState;
+export declare function listItemStateToJSON(object: ListItemState): string;
+export declare function listItemStateToNumber(object: ListItemState): number;
+export declare enum MessageActionSubtype {
+    pollVideo = "pollVideo",
+    pollImages = "pollImages",
+    pollText = "pollText",
+    status = "status",
+    cancelStatus = "cancelStatus",
+    application = "application",
+    courtHearing = "courtHearing",
+    courtDecision = "courtDecision",
+    courtPenalties = "courtPenalties",
+    onboarding = "onboarding",
+    authorization = "authorization",
+    signing = "signing",
+    notExist = "notExist",
+    map = "map",
+    download = "download",
+    delete = "delete",
+    update = "update",
+    route = "route",
+    share = "share",
+    downloadList = "downloadList",
+    pollQuestionnaire = "pollQuestionnaire"
+}
+export declare function messageActionSubtypeFromJSON(object: any): MessageActionSubtype;
+export declare function messageActionSubtypeToJSON(object: MessageActionSubtype): string;
+export declare function messageActionSubtypeToNumber(object: MessageActionSubtype): number;
+export interface MessageBodyItemData {
+    text: string;
+    parameters: TextParameterAtm[];
+    link?: string | undefined;
+    action?: ArrowedLinkAction | undefined;
+    image?: string | undefined;
+}
+export interface MessageBodyItem {
+    type: MessageBodyItemType;
+    data?: MessageBodyItemData | undefined;
+}
+/** @deprecated textLabelContainerMlc used instead */
+export interface TextContainer {
+    text?: string | undefined;
+    parameters: TextParameterAtm[];
+    label?: string | undefined;
+}
+export interface MessageBodyItemV2 {
+    textLabelContainerMlc?: TextLabelContainerMlc | undefined;
+    articlePicAtm?: ArticlePicAtm | undefined;
+    articleVideoMlc?: ArticleVideoMlc | undefined;
+    listItemGroupOrg?: ListItemGroupOrg | undefined;
+}
+export interface MessageBottomGroupItem {
+    listItemGroupOrg?: ListItemGroupOrg | undefined;
+    bottomGroupOrg?: BottomGroupOrg | undefined;
+}
+export declare const MessageBodyItemData: {
+    encode(message: MessageBodyItemData, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MessageBodyItemData;
+    fromJSON(object: any): MessageBodyItemData;
+    toJSON(message: MessageBodyItemData): unknown;
+    create(base?: DeepPartial<MessageBodyItemData>): MessageBodyItemData;
+    fromPartial(object: DeepPartial<MessageBodyItemData>): MessageBodyItemData;
+};
+export declare const MessageBodyItem: {
+    encode(message: MessageBodyItem, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MessageBodyItem;
+    fromJSON(object: any): MessageBodyItem;
+    toJSON(message: MessageBodyItem): unknown;
+    create(base?: DeepPartial<MessageBodyItem>): MessageBodyItem;
+    fromPartial(object: DeepPartial<MessageBodyItem>): MessageBodyItem;
+};
+export declare const TextContainer: {
+    encode(message: TextContainer, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): TextContainer;
+    fromJSON(object: any): TextContainer;
+    toJSON(message: TextContainer): unknown;
+    create(base?: DeepPartial<TextContainer>): TextContainer;
+    fromPartial(object: DeepPartial<TextContainer>): TextContainer;
+};
+export declare const MessageBodyItemV2: {
+    encode(message: MessageBodyItemV2, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MessageBodyItemV2;
+    fromJSON(object: any): MessageBodyItemV2;
+    toJSON(message: MessageBodyItemV2): unknown;
+    create(base?: DeepPartial<MessageBodyItemV2>): MessageBodyItemV2;
+    fromPartial(object: DeepPartial<MessageBodyItemV2>): MessageBodyItemV2;
+};
+export declare const MessageBottomGroupItem: {
+    encode(message: MessageBottomGroupItem, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MessageBottomGroupItem;
+    fromJSON(object: any): MessageBottomGroupItem;
+    toJSON(message: MessageBottomGroupItem): unknown;
+    create(base?: DeepPartial<MessageBottomGroupItem>): MessageBottomGroupItem;
+    fromPartial(object: DeepPartial<MessageBottomGroupItem>): MessageBottomGroupItem;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export {};

package/dist/types/generated/page/bodyparam/bodyparam.d.ts

@@ -0,0 +1,6 @@
+export declare enum PageBodyParameterType {
+    link = "link"
+}
+export declare function pageBodyParameterTypeFromJSON(object: any): PageBodyParameterType;
+export declare function pageBodyParameterTypeToJSON(object: PageBodyParameterType): string;
+export declare function pageBodyParameterTypeToNumber(object: PageBodyParameterType): number;

package/dist/types/generated/page/bodyparam/index.d.ts

@@ -0,0 +1 @@
+export * from './bodyparam.js';

package/dist/types/generated/page/index.d.ts

@@ -0,0 +1,2 @@
+export * from './bodyparam/index.js';
+export * from './page.js';

package/dist/types/generated/page/page.d.ts

@@ -0,0 +1,131 @@
+import _m0 from "protobufjs/minimal.js";
+import { PublicServiceContextMenu } from "../contextMenu.js";
+import { AttentionMessage } from "../ui.js";
+import { PageBodyParameterType } from "./bodyparam/bodyparam.js";
+export declare enum PageListType {
+    singleChoice = "singleChoice",
+    link = "link"
+}
+export declare function pageListTypeFromJSON(object: any): PageListType;
+export declare function pageListTypeToJSON(object: PageListType): string;
+export declare function pageListTypeToNumber(object: PageListType): number;
+export declare enum PageBodyParameterName {
+    banks = "banks"
+}
+export declare function pageBodyParameterNameFromJSON(object: any): PageBodyParameterName;
+export declare function pageBodyParameterNameToJSON(object: PageBodyParameterName): string;
+export declare function pageBodyParameterNameToNumber(object: PageBodyParameterName): number;
+export declare enum PageButtonAction {
+    bankAccountSelection = "bankAccountSelection",
+    vaccinationCertificate = "vaccinationCertificate",
+    sendApplication = "sendApplication",
+    bankAccounts = "bankAccounts",
+    assistanceTypes = "assistanceTypes",
+    contacts = "contacts"
+}
+export declare function pageButtonActionFromJSON(object: any): PageButtonAction;
+export declare function pageButtonActionToJSON(object: PageButtonAction): string;
+export declare function pageButtonActionToNumber(object: PageButtonAction): number;
+export interface PageListItem {
+    id: string;
+    title: string;
+    description?: string | undefined;
+    icon?: string | undefined;
+    image?: string | undefined;
+    link?: string | undefined;
+}
+export interface PageBodyParameter {
+    type: PageBodyParameterType;
+    data: PageBodyParameterData | undefined;
+}
+export interface PageBodyParameterData {
+    name: PageBodyParameterName;
+    alt: string;
+    resource?: string | undefined;
+}
+export interface PageList {
+    type: PageListType;
+    description?: string | undefined;
+    searchable?: boolean | undefined;
+    items: PageListItem[];
+    altChoiceName?: string | undefined;
+}
+export interface PageBody {
+    text: string;
+    parameters: PageBodyParameter[];
+}
+export interface PageButton {
+    action: PageButtonAction;
+    name: string;
+    isActive?: boolean | undefined;
+}
+export interface Page {
+    title: string;
+    contextMenu: PublicServiceContextMenu[];
+    attentionMessage: AttentionMessage | undefined;
+    statusMessage: AttentionMessage | undefined;
+    body: PageBody | undefined;
+    list: PageList | undefined;
+    button: PageButton | undefined;
+}
+export declare const PageListItem: {
+    encode(message: PageListItem, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PageListItem;
+    fromJSON(object: any): PageListItem;
+    toJSON(message: PageListItem): unknown;
+    create(base?: DeepPartial<PageListItem>): PageListItem;
+    fromPartial(object: DeepPartial<PageListItem>): PageListItem;
+};
+export declare const PageBodyParameter: {
+    encode(message: PageBodyParameter, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PageBodyParameter;
+    fromJSON(object: any): PageBodyParameter;
+    toJSON(message: PageBodyParameter): unknown;
+    create(base?: DeepPartial<PageBodyParameter>): PageBodyParameter;
+    fromPartial(object: DeepPartial<PageBodyParameter>): PageBodyParameter;
+};
+export declare const PageBodyParameterData: {
+    encode(message: PageBodyParameterData, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PageBodyParameterData;
+    fromJSON(object: any): PageBodyParameterData;
+    toJSON(message: PageBodyParameterData): unknown;
+    create(base?: DeepPartial<PageBodyParameterData>): PageBodyParameterData;
+    fromPartial(object: DeepPartial<PageBodyParameterData>): PageBodyParameterData;
+};
+export declare const PageList: {
+    encode(message: PageList, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PageList;
+    fromJSON(object: any): PageList;
+    toJSON(message: PageList): unknown;
+    create(base?: DeepPartial<PageList>): PageList;
+    fromPartial(object: DeepPartial<PageList>): PageList;
+};
+export declare const PageBody: {
+    encode(message: PageBody, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PageBody;
+    fromJSON(object: any): PageBody;
+    toJSON(message: PageBody): unknown;
+    create(base?: DeepPartial<PageBody>): PageBody;
+    fromPartial(object: DeepPartial<PageBody>): PageBody;
+};
+export declare const PageButton: {
+    encode(message: PageButton, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PageButton;
+    fromJSON(object: any): PageButton;
+    toJSON(message: PageButton): unknown;
+    create(base?: DeepPartial<PageButton>): PageButton;
+    fromPartial(object: DeepPartial<PageButton>): PageButton;
+};
+export declare const Page: {
+    encode(message: Page, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Page;
+    fromJSON(object: any): Page;
+    toJSON(message: Page): unknown;
+    create(base?: DeepPartial<Page>): Page;
+    fromPartial(object: DeepPartial<Page>): Page;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export {};

package/dist/types/generated/platformType.d.ts

@@ -0,0 +1,9 @@
+export declare enum PlatformType {
+    iOS = "iOS",
+    Android = "Android",
+    Huawei = "Huawei",
+    Browser = "Browser"
+}
+export declare function platformTypeFromJSON(object: any): PlatformType;
+export declare function platformTypeToJSON(object: PlatformType): string;
+export declare function platformTypeToNumber(object: PlatformType): number;

package/dist/types/generated/portal/index.d.ts

@@ -0,0 +1,2 @@
+export * from './poll/index.js';
+export * from './portalUserPermissions.js';

package/dist/types/generated/portal/poll/index.d.ts

@@ -0,0 +1 @@
+export * from './portalPollUserPermissions.js';

package/dist/types/generated/portal/poll/portalPollUserPermissions.d.ts

@@ -0,0 +1,7 @@
+export declare enum PortalUserPollPermissions {
+    user = "user",
+    masterAdministrator = "masterAdministrator"
+}
+export declare function portalUserPollPermissionsFromJSON(object: any): PortalUserPollPermissions;
+export declare function portalUserPollPermissionsToJSON(object: PortalUserPollPermissions): string;
+export declare function portalUserPollPermissionsToNumber(object: PortalUserPollPermissions): number;

package/dist/types/generated/portal/portalUserPermissions.d.ts

@@ -0,0 +1,28 @@
+import _m0 from "protobufjs/minimal.js";
+import { PortalUserPollPermissions } from "./poll/portalPollUserPermissions.js";
+export declare enum PortalUserPetitionPermissions {
+    user = "user",
+    moderator = "moderator",
+    proModerator = "proModerator",
+    administrator = "administrator"
+}
+export declare function portalUserPetitionPermissionsFromJSON(object: any): PortalUserPetitionPermissions;
+export declare function portalUserPetitionPermissionsToJSON(object: PortalUserPetitionPermissions): string;
+export declare function portalUserPetitionPermissionsToNumber(object: PortalUserPetitionPermissions): number;
+export interface PortalUserPermissions {
+    petition?: PortalUserPetitionPermissions | undefined;
+    poll?: PortalUserPollPermissions | undefined;
+}
+export declare const PortalUserPermissions: {
+    encode(message: PortalUserPermissions, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PortalUserPermissions;
+    fromJSON(object: any): PortalUserPermissions;
+    toJSON(message: PortalUserPermissions): unknown;
+    create(base?: DeepPartial<PortalUserPermissions>): PortalUserPermissions;
+    fromPartial(object: DeepPartial<PortalUserPermissions>): PortalUserPermissions;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export {};

package/dist/types/generated/profileFeature.d.ts

@@ -0,0 +1,52 @@
+import _m0 from "protobufjs/minimal.js";
+export declare enum DiiaOfficeStatus {
+    ACTIVE = "ACTIVE",
+    SUSPENDED = "SUSPENDED",
+    DISMISSED = "DISMISSED"
+}
+export declare function diiaOfficeStatusFromJSON(object: any): DiiaOfficeStatus;
+export declare function diiaOfficeStatusToJSON(object: DiiaOfficeStatus): string;
+export declare function diiaOfficeStatusToNumber(object: DiiaOfficeStatus): number;
+export declare enum ProfileFeature {
+    office = "office",
+    student = "student"
+}
+export declare function profileFeatureFromJSON(object: any): ProfileFeature;
+export declare function profileFeatureToJSON(object: ProfileFeature): string;
+export declare function profileFeatureToNumber(object: ProfileFeature): number;
+export interface DiiaOfficeProfileData {
+    officeIdentifier: string;
+    profileId: string;
+    organizationId: string;
+    unitId: string;
+    isOrganizationAdmin: boolean;
+    scopes: string[];
+    status: DiiaOfficeStatus;
+    tokenError?: string | undefined;
+    tokenFailedAt: Date | undefined;
+    googleWorkspace?: string | undefined;
+}
+export interface UserFeatures {
+    office?: DiiaOfficeProfileData | undefined;
+}
+export declare const DiiaOfficeProfileData: {
+    encode(message: DiiaOfficeProfileData, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): DiiaOfficeProfileData;
+    fromJSON(object: any): DiiaOfficeProfileData;
+    toJSON(message: DiiaOfficeProfileData): unknown;
+    create(base?: DeepPartial<DiiaOfficeProfileData>): DiiaOfficeProfileData;
+    fromPartial(object: DeepPartial<DiiaOfficeProfileData>): DiiaOfficeProfileData;
+};
+export declare const UserFeatures: {
+    encode(message: UserFeatures, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): UserFeatures;
+    fromJSON(object: any): UserFeatures;
+    toJSON(message: UserFeatures): unknown;
+    create(base?: DeepPartial<UserFeatures>): UserFeatures;
+    fromPartial(object: DeepPartial<UserFeatures>): UserFeatures;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export {};

package/dist/types/generated/publicService.d.ts

@@ -0,0 +1,22 @@
+import _m0 from "protobufjs/minimal.js";
+import { AttentionMessage } from "./ui.js";
+export interface ContactsResponse {
+    title: string;
+    attentionMessage: AttentionMessage | undefined;
+    text?: string | undefined;
+    phoneNumber?: string | undefined;
+    email?: string | undefined;
+}
+export declare const ContactsResponse: {
+    encode(message: ContactsResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): ContactsResponse;
+    fromJSON(object: any): ContactsResponse;
+    toJSON(message: ContactsResponse): unknown;
+    create(base?: DeepPartial<ContactsResponse>): ContactsResponse;
+    fromPartial(object: DeepPartial<ContactsResponse>): ContactsResponse;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export {};

package/dist/types/generated/publicServiceStatus.d.ts

@@ -0,0 +1,7 @@
+export declare enum PublicServiceStatus {
+    active = "active",
+    inactive = "inactive"
+}
+export declare function publicServiceStatusFromJSON(object: any): PublicServiceStatus;
+export declare function publicServiceStatusToJSON(object: PublicServiceStatus): string;
+export declare function publicServiceStatusToNumber(object: PublicServiceStatus): number;

package/dist/types/generated/session/index.d.ts

@@ -0,0 +1 @@
+export * from './sessionType.js';

package/dist/types/generated/session/sessionType.d.ts

@@ -0,0 +1,16 @@
+export declare enum SessionType {
+    Acquirer = "Acquirer",
+    None = "None",
+    Partner = "Partner",
+    Temporary = "Temporary",
+    User = "User",
+    EResident = "EResident",
+    EResidentApplicant = "EResidentApplicant",
+    ServiceEntrance = "ServiceEntrance",
+    PortalUser = "PortalUser",
+    ServiceUser = "ServiceUser",
+    CabinetUser = "CabinetUser"
+}
+export declare function sessionTypeFromJSON(object: any): SessionType;
+export declare function sessionTypeToJSON(object: SessionType): string;
+export declare function sessionTypeToNumber(object: SessionType): number;

package/dist/types/generated/signing.d.ts

@@ -0,0 +1,43 @@
+import _m0 from "protobufjs/minimal.js";
+export interface HashedFile {
+    fileName: string;
+    fileHash: string;
+}
+export interface SignedItem {
+    name: string;
+    signature: string;
+}
+export interface HashedFileWithSignature {
+    name: string;
+    hash: string;
+    signature: string;
+}
+export declare const HashedFile: {
+    encode(message: HashedFile, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): HashedFile;
+    fromJSON(object: any): HashedFile;
+    toJSON(message: HashedFile): unknown;
+    create(base?: DeepPartial<HashedFile>): HashedFile;
+    fromPartial(object: DeepPartial<HashedFile>): HashedFile;
+};
+export declare const SignedItem: {
+    encode(message: SignedItem, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SignedItem;
+    fromJSON(object: any): SignedItem;
+    toJSON(message: SignedItem): unknown;
+    create(base?: DeepPartial<SignedItem>): SignedItem;
+    fromPartial(object: DeepPartial<SignedItem>): SignedItem;
+};
+export declare const HashedFileWithSignature: {
+    encode(message: HashedFileWithSignature, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): HashedFileWithSignature;
+    fromJSON(object: any): HashedFileWithSignature;
+    toJSON(message: HashedFileWithSignature): unknown;
+    create(base?: DeepPartial<HashedFileWithSignature>): HashedFileWithSignature;
+    fromPartial(object: DeepPartial<HashedFileWithSignature>): HashedFileWithSignature;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export {};