@zwave-js/cc 14.0.0-beta.1 → 14.0.0-beta.4

package/build/cjs/cc/UserCodeCC.d.ts

@@ -0,0 +1,683 @@
+import { CommandClasses, type EndpointId, type MaybeNotKnown, type MessageOrCCLogEntry, type SupervisionResult, type WithAddress } from "@zwave-js/core/safe";
+import type { CCEncodingContext, CCParsingContext, GetValueDB } from "@zwave-js/host/safe";
+import { Bytes } from "@zwave-js/shared/safe";
+import { POLL_VALUE, PhysicalCCAPI, type PollValueImplementation, SET_VALUE, type SetValueImplementation } from "../lib/API.js";
+import { type CCRaw, CommandClass, type InterviewContext, type PersistValuesContext, type RefreshValuesContext } from "../lib/CommandClass.js";
+import type { NotificationEventPayload } from "../lib/NotificationEventPayload.js";
+import { KeypadMode, UserCodeCommand, UserIDStatus } from "../lib/_Types.js";
+export declare const UserCodeCCValues: Readonly<{
+    userCode: ((userId: number) => {
+        readonly meta: {
+            readonly type: "any";
+            readonly readable: true;
+            readonly writeable: true;
+        };
+        readonly id: {
+            commandClass: (typeof CommandClasses)["User Code"];
+            property: "userCode";
+            propertyKey: number;
+        };
+        readonly endpoint: (endpoint?: number | undefined) => {
+            readonly commandClass: (typeof CommandClasses)["User Code"];
+            readonly endpoint: number;
+            readonly property: "userCode";
+            readonly propertyKey: number;
+        };
+    }) & {
+        is: (valueId: import("@zwave-js/core/safe").ValueID) => boolean;
+        readonly options: {
+            readonly stateful: true;
+            readonly internal: false;
+            readonly minVersion: 1;
+            readonly supportsEndpoints: true;
+            readonly autoCreate: true;
+            readonly secret: true;
+        };
+    };
+    userIdStatus: ((userId: number) => {
+        readonly meta: {
+            readonly label: `User ID status (${number})`;
+            readonly type: "number";
+            readonly readable: true;
+            readonly writeable: true;
+        };
+        readonly id: {
+            commandClass: (typeof CommandClasses)["User Code"];
+            property: "userIdStatus";
+            propertyKey: number;
+        };
+        readonly endpoint: (endpoint?: number | undefined) => {
+            readonly commandClass: (typeof CommandClasses)["User Code"];
+            readonly endpoint: number;
+            readonly property: "userIdStatus";
+            readonly propertyKey: number;
+        };
+    }) & {
+        is: (valueId: import("@zwave-js/core/safe").ValueID) => boolean;
+        readonly options: {
+            readonly internal: false;
+            readonly minVersion: 1;
+            readonly secret: false;
+            readonly stateful: true;
+            readonly supportsEndpoints: true;
+            readonly autoCreate: true;
+        };
+    };
+    adminCode: {
+        readonly id: {
+            commandClass: (typeof CommandClasses)["User Code"];
+            property: "adminCode";
+        };
+        readonly endpoint: (endpoint?: number | undefined) => {
+            readonly commandClass: (typeof CommandClasses)["User Code"];
+            readonly endpoint: number;
+            readonly property: "adminCode";
+        };
+        readonly is: (valueId: import("@zwave-js/core/safe").ValueID) => boolean;
+        readonly meta: {
+            readonly label: "Admin Code";
+            readonly minLength: 4;
+            readonly maxLength: 10;
+            readonly type: "string";
+            readonly readable: true;
+            readonly writeable: true;
+        };
+        readonly options: {
+            readonly stateful: true;
+            readonly internal: false;
+            readonly supportsEndpoints: true;
+            readonly autoCreate: true;
+            readonly minVersion: 2;
+            readonly secret: true;
+        };
+    };
+    keypadMode: {
+        readonly id: {
+            commandClass: (typeof CommandClasses)["User Code"];
+            property: "keypadMode";
+        };
+        readonly endpoint: (endpoint?: number | undefined) => {
+            readonly commandClass: (typeof CommandClasses)["User Code"];
+            readonly endpoint: number;
+            readonly property: "keypadMode";
+        };
+        readonly is: (valueId: import("@zwave-js/core/safe").ValueID) => boolean;
+        readonly meta: {
+            readonly label: "Keypad Mode";
+            readonly writeable: false;
+            readonly type: "number";
+            readonly readable: true;
+        };
+        readonly options: {
+            readonly stateful: true;
+            readonly secret: false;
+            readonly internal: false;
+            readonly supportsEndpoints: true;
+            readonly autoCreate: true;
+            readonly minVersion: 2;
+        };
+    };
+    userCodeChecksum: {
+        readonly id: {
+            commandClass: (typeof CommandClasses)["User Code"];
+            property: "userCodeChecksum";
+        };
+        readonly endpoint: (endpoint?: number | undefined) => {
+            readonly commandClass: (typeof CommandClasses)["User Code"];
+            readonly endpoint: number;
+            readonly property: "userCodeChecksum";
+        };
+        readonly is: (valueId: import("@zwave-js/core/safe").ValueID) => boolean;
+        readonly meta: {
+            readonly type: "any";
+            readonly readable: true;
+            readonly writeable: true;
+        };
+        readonly options: {
+            readonly stateful: true;
+            readonly secret: false;
+            readonly minVersion: 1;
+            readonly supportsEndpoints: true;
+            readonly autoCreate: true;
+            readonly internal: true;
+        };
+    };
+    supportedASCIIChars: {
+        readonly id: {
+            commandClass: (typeof CommandClasses)["User Code"];
+            property: "supportedASCIIChars";
+        };
+        readonly endpoint: (endpoint?: number | undefined) => {
+            readonly commandClass: (typeof CommandClasses)["User Code"];
+            readonly endpoint: number;
+            readonly property: "supportedASCIIChars";
+        };
+        readonly is: (valueId: import("@zwave-js/core/safe").ValueID) => boolean;
+        readonly meta: {
+            readonly type: "any";
+            readonly readable: true;
+            readonly writeable: true;
+        };
+        readonly options: {
+            readonly stateful: true;
+            readonly secret: false;
+            readonly minVersion: 1;
+            readonly supportsEndpoints: true;
+            readonly autoCreate: true;
+            readonly internal: true;
+        };
+    };
+    supportedKeypadModes: {
+        readonly id: {
+            commandClass: (typeof CommandClasses)["User Code"];
+            property: "supportedKeypadModes";
+        };
+        readonly endpoint: (endpoint?: number | undefined) => {
+            readonly commandClass: (typeof CommandClasses)["User Code"];
+            readonly endpoint: number;
+            readonly property: "supportedKeypadModes";
+        };
+        readonly is: (valueId: import("@zwave-js/core/safe").ValueID) => boolean;
+        readonly meta: {
+            readonly type: "any";
+            readonly readable: true;
+            readonly writeable: true;
+        };
+        readonly options: {
+            readonly stateful: true;
+            readonly secret: false;
+            readonly minVersion: 1;
+            readonly supportsEndpoints: true;
+            readonly autoCreate: true;
+            readonly internal: true;
+        };
+    };
+    supportedUserIDStatuses: {
+        readonly id: {
+            commandClass: (typeof CommandClasses)["User Code"];
+            property: "supportedUserIDStatuses";
+        };
+        readonly endpoint: (endpoint?: number | undefined) => {
+            readonly commandClass: (typeof CommandClasses)["User Code"];
+            readonly endpoint: number;
+            readonly property: "supportedUserIDStatuses";
+        };
+        readonly is: (valueId: import("@zwave-js/core/safe").ValueID) => boolean;
+        readonly meta: {
+            readonly type: "any";
+            readonly readable: true;
+            readonly writeable: true;
+        };
+        readonly options: {
+            readonly stateful: true;
+            readonly secret: false;
+            readonly minVersion: 1;
+            readonly supportsEndpoints: true;
+            readonly autoCreate: true;
+            readonly internal: true;
+        };
+    };
+    supportsMultipleUserCodeSet: {
+        readonly id: {
+            commandClass: (typeof CommandClasses)["User Code"];
+            property: "supportsMultipleUserCodeSet";
+        };
+        readonly endpoint: (endpoint?: number | undefined) => {
+            readonly commandClass: (typeof CommandClasses)["User Code"];
+            readonly endpoint: number;
+            readonly property: "supportsMultipleUserCodeSet";
+        };
+        readonly is: (valueId: import("@zwave-js/core/safe").ValueID) => boolean;
+        readonly meta: {
+            readonly type: "any";
+            readonly readable: true;
+            readonly writeable: true;
+        };
+        readonly options: {
+            readonly stateful: true;
+            readonly secret: false;
+            readonly minVersion: 1;
+            readonly supportsEndpoints: true;
+            readonly autoCreate: true;
+            readonly internal: true;
+        };
+    };
+    supportsMultipleUserCodeReport: {
+        readonly id: {
+            commandClass: (typeof CommandClasses)["User Code"];
+            property: "supportsMultipleUserCodeReport";
+        };
+        readonly endpoint: (endpoint?: number | undefined) => {
+            readonly commandClass: (typeof CommandClasses)["User Code"];
+            readonly endpoint: number;
+            readonly property: "supportsMultipleUserCodeReport";
+        };
+        readonly is: (valueId: import("@zwave-js/core/safe").ValueID) => boolean;
+        readonly meta: {
+            readonly type: "any";
+            readonly readable: true;
+            readonly writeable: true;
+        };
+        readonly options: {
+            readonly stateful: true;
+            readonly secret: false;
+            readonly minVersion: 1;
+            readonly supportsEndpoints: true;
+            readonly autoCreate: true;
+            readonly internal: true;
+        };
+    };
+    supportsUserCodeChecksum: {
+        readonly id: {
+            commandClass: (typeof CommandClasses)["User Code"];
+            property: "supportsUserCodeChecksum";
+        };
+        readonly endpoint: (endpoint?: number | undefined) => {
+            readonly commandClass: (typeof CommandClasses)["User Code"];
+            readonly endpoint: number;
+            readonly property: "supportsUserCodeChecksum";
+        };
+        readonly is: (valueId: import("@zwave-js/core/safe").ValueID) => boolean;
+        readonly meta: {
+            readonly type: "any";
+            readonly readable: true;
+            readonly writeable: true;
+        };
+        readonly options: {
+            readonly stateful: true;
+            readonly secret: false;
+            readonly minVersion: 1;
+            readonly supportsEndpoints: true;
+            readonly autoCreate: true;
+            readonly internal: true;
+        };
+    };
+    _deprecated_supportsMasterCodeDeactivation: {
+        readonly id: {
+            commandClass: (typeof CommandClasses)["User Code"];
+            property: "supportsMasterCodeDeactivation";
+        };
+        readonly endpoint: (endpoint?: number | undefined) => {
+            readonly commandClass: (typeof CommandClasses)["User Code"];
+            readonly endpoint: number;
+            readonly property: "supportsMasterCodeDeactivation";
+        };
+        readonly is: (valueId: import("@zwave-js/core/safe").ValueID) => boolean;
+        readonly meta: {
+            readonly type: "any";
+            readonly readable: true;
+            readonly writeable: true;
+        };
+        readonly options: {
+            readonly stateful: true;
+            readonly secret: false;
+            readonly minVersion: 1;
+            readonly supportsEndpoints: true;
+            readonly autoCreate: true;
+            readonly internal: true;
+        };
+    };
+    _deprecated_supportsMasterCode: {
+        readonly id: {
+            commandClass: (typeof CommandClasses)["User Code"];
+            property: "supportsMasterCode";
+        };
+        readonly endpoint: (endpoint?: number | undefined) => {
+            readonly commandClass: (typeof CommandClasses)["User Code"];
+            readonly endpoint: number;
+            readonly property: "supportsMasterCode";
+        };
+        readonly is: (valueId: import("@zwave-js/core/safe").ValueID) => boolean;
+        readonly meta: {
+            readonly type: "any";
+            readonly readable: true;
+            readonly writeable: true;
+        };
+        readonly options: {
+            readonly stateful: true;
+            readonly secret: false;
+            readonly minVersion: 1;
+            readonly supportsEndpoints: true;
+            readonly autoCreate: true;
+            readonly internal: true;
+        };
+    };
+    supportsAdminCodeDeactivation: {
+        readonly id: {
+            commandClass: (typeof CommandClasses)["User Code"];
+            property: "supportsAdminCodeDeactivation";
+        };
+        readonly endpoint: (endpoint?: number | undefined) => {
+            readonly commandClass: (typeof CommandClasses)["User Code"];
+            readonly endpoint: number;
+            readonly property: "supportsAdminCodeDeactivation";
+        };
+        readonly is: (valueId: import("@zwave-js/core/safe").ValueID) => boolean;
+        readonly meta: {
+            readonly type: "any";
+            readonly readable: true;
+            readonly writeable: true;
+        };
+        readonly options: {
+            readonly stateful: true;
+            readonly secret: false;
+            readonly minVersion: 1;
+            readonly supportsEndpoints: true;
+            readonly autoCreate: true;
+            readonly internal: true;
+        };
+    };
+    supportsAdminCode: {
+        readonly id: {
+            commandClass: (typeof CommandClasses)["User Code"];
+            property: "supportsAdminCode";
+        };
+        readonly endpoint: (endpoint?: number | undefined) => {
+            readonly commandClass: (typeof CommandClasses)["User Code"];
+            readonly endpoint: number;
+            readonly property: "supportsAdminCode";
+        };
+        readonly is: (valueId: import("@zwave-js/core/safe").ValueID) => boolean;
+        readonly meta: {
+            readonly type: "any";
+            readonly readable: true;
+            readonly writeable: true;
+        };
+        readonly options: {
+            readonly stateful: true;
+            readonly secret: false;
+            readonly minVersion: 1;
+            readonly supportsEndpoints: true;
+            readonly autoCreate: true;
+            readonly internal: true;
+        };
+    };
+    supportedUsers: {
+        readonly id: {
+            commandClass: (typeof CommandClasses)["User Code"];
+            property: "supportedUsers";
+        };
+        readonly endpoint: (endpoint?: number | undefined) => {
+            readonly commandClass: (typeof CommandClasses)["User Code"];
+            readonly endpoint: number;
+            readonly property: "supportedUsers";
+        };
+        readonly is: (valueId: import("@zwave-js/core/safe").ValueID) => boolean;
+        readonly meta: {
+            readonly type: "any";
+            readonly readable: true;
+            readonly writeable: true;
+        };
+        readonly options: {
+            readonly stateful: true;
+            readonly secret: false;
+            readonly minVersion: 1;
+            readonly supportsEndpoints: true;
+            readonly autoCreate: true;
+            readonly internal: true;
+        };
+    };
+}>;
+/** Formats a user code in a way that's safe to print in public logs */
+export declare function userCodeToLogString(userCode: string | Uint8Array): string;
+export declare class UserCodeCCAPI extends PhysicalCCAPI {
+    supportsCommand(cmd: UserCodeCommand): MaybeNotKnown<boolean>;
+    protected get [SET_VALUE](): SetValueImplementation;
+    protected get [POLL_VALUE](): PollValueImplementation;
+    getUsersCount(): Promise<MaybeNotKnown<number>>;
+    get(userId: number, multiple?: false): Promise<MaybeNotKnown<Pick<UserCode, "userIdStatus" | "userCode">>>;
+    get(userId: number, multiple: true): Promise<MaybeNotKnown<{
+        userCodes: readonly UserCode[];
+        nextUserId: number;
+    }>>;
+    /** Configures a single user code */
+    set(userId: number, userIdStatus: Exclude<UserIDStatus, UserIDStatus.Available | UserIDStatus.StatusNotAvailable>, userCode: string | Uint8Array): Promise<SupervisionResult | undefined>;
+    /** Configures multiple user codes */
+    setMany(codes: UserCodeCCSetOptions[]): Promise<SupervisionResult | undefined>;
+    /**
+     * Clears one or all user code
+     * @param userId The user code to clear. If none or 0 is given, all codes are cleared
+     */
+    clear(userId?: number): Promise<SupervisionResult | undefined>;
+    getCapabilities(): Promise<Pick<UserCodeCCCapabilitiesReport, "supportsAdminCode" | "supportsAdminCodeDeactivation" | "supportsUserCodeChecksum" | "supportsMultipleUserCodeReport" | "supportsMultipleUserCodeSet" | "supportedUserIDStatuses" | "supportedKeypadModes" | "supportedASCIIChars"> | undefined>;
+    getKeypadMode(): Promise<MaybeNotKnown<KeypadMode>>;
+    setKeypadMode(keypadMode: KeypadMode): Promise<SupervisionResult | undefined>;
+    getAdminCode(): Promise<MaybeNotKnown<string>>;
+    setAdminCode(adminCode: string): Promise<SupervisionResult | undefined>;
+    getUserCodeChecksum(): Promise<MaybeNotKnown<number>>;
+}
+export declare class UserCodeCC extends CommandClass {
+    ccCommand: UserCodeCommand;
+    interview(ctx: InterviewContext): Promise<void>;
+    refreshValues(ctx: RefreshValuesContext): Promise<void>;
+    /**
+     * Returns the number of supported users.
+     * This only works AFTER the interview process
+     */
+    static getSupportedUsersCached(ctx: GetValueDB, endpoint: EndpointId): MaybeNotKnown<number>;
+    /**
+     * Returns the supported keypad modes.
+     * This only works AFTER the interview process
+     */
+    static getSupportedKeypadModesCached(ctx: GetValueDB, endpoint: EndpointId): MaybeNotKnown<KeypadMode[]>;
+    /**
+     * Returns the supported user ID statuses.
+     * This only works AFTER the interview process
+     */
+    static getSupportedUserIDStatusesCached(ctx: GetValueDB, endpoint: EndpointId): MaybeNotKnown<UserIDStatus[]>;
+    /**
+     * Returns the supported ASCII characters.
+     * This only works AFTER the interview process
+     */
+    static getSupportedASCIICharsCached(ctx: GetValueDB, endpoint: EndpointId): MaybeNotKnown<string>;
+    /**
+     * Returns whether the admin code functionality is supported.
+     * This only works AFTER the interview process
+     */
+    static supportsAdminCodeCached(ctx: GetValueDB, endpoint: EndpointId): boolean;
+    /**
+     * Returns whether deactivating the admin code is supported.
+     * This only works AFTER the interview process
+     */
+    static supportsAdminCodeDeactivationCached(ctx: GetValueDB, endpoint: EndpointId): boolean;
+    /**
+     * Returns whether setting multiple user codes at once is supported.
+     * This only works AFTER the interview process
+     */
+    static supportsMultipleUserCodeSetCached(ctx: GetValueDB, endpoint: EndpointId): boolean;
+    /**
+     * Returns the current status of a user ID.
+     * This only works AFTER the user IDs have been queried.
+     */
+    static getUserIdStatusCached(ctx: GetValueDB, endpoint: EndpointId, userId: number): MaybeNotKnown<UserIDStatus>;
+    /**
+     * Returns the current code belonging to a user ID.
+     * This only works AFTER the user IDs have been queried.
+     */
+    static getUserCodeCached(ctx: GetValueDB, endpoint: EndpointId, userId: number): MaybeNotKnown<string | Uint8Array>;
+}
+export type UserCodeCCSetOptions = {
+    userId: 0;
+    userIdStatus: UserIDStatus.Available;
+    userCode?: undefined;
+} | {
+    userId: number;
+    userIdStatus: UserIDStatus.Available;
+    userCode?: undefined;
+} | {
+    userId: number;
+    userIdStatus: Exclude<UserIDStatus, UserIDStatus.Available | UserIDStatus.StatusNotAvailable>;
+    userCode: string | Uint8Array;
+};
+export declare class UserCodeCCSet extends UserCodeCC {
+    constructor(options: WithAddress<UserCodeCCSetOptions>);
+    static from(raw: CCRaw, ctx: CCParsingContext): UserCodeCCSet;
+    userId: number;
+    userIdStatus: UserIDStatus;
+    userCode: string | Uint8Array;
+    serialize(ctx: CCEncodingContext): Bytes;
+    toLogEntry(ctx?: GetValueDB): MessageOrCCLogEntry;
+}
+export interface UserCodeCCReportOptions {
+    userId: number;
+    userIdStatus: UserIDStatus;
+    userCode?: string | Bytes;
+}
+export declare class UserCodeCCReport extends UserCodeCC implements NotificationEventPayload {
+    constructor(options: WithAddress<UserCodeCCReportOptions>);
+    static from(raw: CCRaw, ctx: CCParsingContext): UserCodeCCReport;
+    readonly userId: number;
+    readonly userIdStatus: UserIDStatus;
+    readonly userCode: string | Bytes;
+    persistValues(ctx: PersistValuesContext): boolean;
+    serialize(ctx: CCEncodingContext): Bytes;
+    toLogEntry(ctx?: GetValueDB): MessageOrCCLogEntry;
+    toNotificationEventParameters(): {
+        userId: number;
+    };
+}
+export interface UserCodeCCGetOptions {
+    userId: number;
+}
+export declare class UserCodeCCGet extends UserCodeCC {
+    constructor(options: WithAddress<UserCodeCCGetOptions>);
+    static from(raw: CCRaw, ctx: CCParsingContext): UserCodeCCGet;
+    userId: number;
+    serialize(ctx: CCEncodingContext): Bytes;
+    toLogEntry(ctx?: GetValueDB): MessageOrCCLogEntry;
+}
+export interface UserCodeCCUsersNumberReportOptions {
+    supportedUsers: number;
+}
+export declare class UserCodeCCUsersNumberReport extends UserCodeCC {
+    constructor(options: WithAddress<UserCodeCCUsersNumberReportOptions>);
+    static from(raw: CCRaw, ctx: CCParsingContext): UserCodeCCUsersNumberReport;
+    readonly supportedUsers: number;
+    serialize(ctx: CCEncodingContext): Bytes;
+    toLogEntry(ctx?: GetValueDB): MessageOrCCLogEntry;
+}
+export declare class UserCodeCCUsersNumberGet extends UserCodeCC {
+}
+export interface UserCodeCCCapabilitiesReportOptions {
+    supportsAdminCode: boolean;
+    supportsAdminCodeDeactivation: boolean;
+    supportsUserCodeChecksum: boolean;
+    supportsMultipleUserCodeReport: boolean;
+    supportsMultipleUserCodeSet: boolean;
+    supportedUserIDStatuses: readonly UserIDStatus[];
+    supportedKeypadModes: readonly KeypadMode[];
+    supportedASCIIChars: string;
+}
+export declare class UserCodeCCCapabilitiesReport extends UserCodeCC {
+    constructor(options: WithAddress<UserCodeCCCapabilitiesReportOptions>);
+    static from(raw: CCRaw, ctx: CCParsingContext): UserCodeCCCapabilitiesReport;
+    readonly supportsAdminCode: boolean;
+    readonly supportsAdminCodeDeactivation: boolean;
+    readonly supportsUserCodeChecksum: boolean;
+    readonly supportsMultipleUserCodeReport: boolean;
+    readonly supportsMultipleUserCodeSet: boolean;
+    readonly supportedUserIDStatuses: readonly UserIDStatus[];
+    readonly supportedKeypadModes: readonly KeypadMode[];
+    readonly supportedASCIIChars: string;
+    serialize(ctx: CCEncodingContext): Bytes;
+    toLogEntry(ctx?: GetValueDB): MessageOrCCLogEntry;
+}
+export declare class UserCodeCCCapabilitiesGet extends UserCodeCC {
+}
+export interface UserCodeCCKeypadModeSetOptions {
+    keypadMode: KeypadMode;
+}
+export declare class UserCodeCCKeypadModeSet extends UserCodeCC {
+    constructor(options: WithAddress<UserCodeCCKeypadModeSetOptions>);
+    static from(raw: CCRaw, ctx: CCParsingContext): UserCodeCCKeypadModeSet;
+    keypadMode: KeypadMode;
+    serialize(ctx: CCEncodingContext): Bytes;
+    toLogEntry(ctx?: GetValueDB): MessageOrCCLogEntry;
+}
+export interface UserCodeCCKeypadModeReportOptions {
+    keypadMode: KeypadMode;
+}
+export declare class UserCodeCCKeypadModeReport extends UserCodeCC {
+    constructor(options: WithAddress<UserCodeCCKeypadModeReportOptions>);
+    static from(raw: CCRaw, ctx: CCParsingContext): UserCodeCCKeypadModeReport;
+    persistValues(ctx: PersistValuesContext): boolean;
+    readonly keypadMode: KeypadMode;
+    serialize(ctx: CCEncodingContext): Bytes;
+    toLogEntry(ctx?: GetValueDB): MessageOrCCLogEntry;
+}
+export declare class UserCodeCCKeypadModeGet extends UserCodeCC {
+}
+export interface UserCodeCCAdminCodeSetOptions {
+    adminCode: string;
+}
+export declare class UserCodeCCAdminCodeSet extends UserCodeCC {
+    constructor(options: WithAddress<UserCodeCCAdminCodeSetOptions>);
+    static from(raw: CCRaw, ctx: CCParsingContext): UserCodeCCAdminCodeSet;
+    adminCode: string;
+    serialize(ctx: CCEncodingContext): Bytes;
+    toLogEntry(ctx?: GetValueDB): MessageOrCCLogEntry;
+}
+export interface UserCodeCCAdminCodeReportOptions {
+    adminCode: string;
+}
+export declare class UserCodeCCAdminCodeReport extends UserCodeCC {
+    constructor(options: WithAddress<UserCodeCCAdminCodeReportOptions>);
+    static from(raw: CCRaw, ctx: CCParsingContext): UserCodeCCAdminCodeReport;
+    readonly adminCode: string;
+    serialize(ctx: CCEncodingContext): Bytes;
+    toLogEntry(ctx?: GetValueDB): MessageOrCCLogEntry;
+}
+export declare class UserCodeCCAdminCodeGet extends UserCodeCC {
+}
+export interface UserCodeCCUserCodeChecksumReportOptions {
+    userCodeChecksum: number;
+}
+export declare class UserCodeCCUserCodeChecksumReport extends UserCodeCC {
+    constructor(options: WithAddress<UserCodeCCUserCodeChecksumReportOptions>);
+    static from(raw: CCRaw, ctx: CCParsingContext): UserCodeCCUserCodeChecksumReport;
+    readonly userCodeChecksum: number;
+    serialize(ctx: CCEncodingContext): Bytes;
+    toLogEntry(ctx?: GetValueDB): MessageOrCCLogEntry;
+}
+export declare class UserCodeCCUserCodeChecksumGet extends UserCodeCC {
+}
+export interface UserCodeCCExtendedUserCodeSetOptions {
+    userCodes: UserCodeCCSetOptions[];
+}
+export interface UserCode {
+    userId: number;
+    userIdStatus: UserIDStatus;
+    userCode: string;
+}
+export declare class UserCodeCCExtendedUserCodeSet extends UserCodeCC {
+    constructor(options: WithAddress<UserCodeCCExtendedUserCodeSetOptions>);
+    static from(_raw: CCRaw, _ctx: CCParsingContext): UserCodeCCExtendedUserCodeSet;
+    userCodes: UserCodeCCSetOptions[];
+    serialize(ctx: CCEncodingContext): Bytes;
+    toLogEntry(ctx?: GetValueDB): MessageOrCCLogEntry;
+}
+export interface UserCodeCCExtendedUserCodeReportOptions {
+    userCodes: UserCode[];
+    nextUserId: number;
+}
+export declare class UserCodeCCExtendedUserCodeReport extends UserCodeCC {
+    constructor(options: WithAddress<UserCodeCCExtendedUserCodeReportOptions>);
+    static from(raw: CCRaw, ctx: CCParsingContext): UserCodeCCExtendedUserCodeReport;
+    persistValues(ctx: PersistValuesContext): boolean;
+    readonly userCodes: readonly UserCode[];
+    readonly nextUserId: number;
+    toLogEntry(ctx?: GetValueDB): MessageOrCCLogEntry;
+}
+export interface UserCodeCCExtendedUserCodeGetOptions {
+    userId: number;
+    reportMore?: boolean;
+}
+export declare class UserCodeCCExtendedUserCodeGet extends UserCodeCC {
+    constructor(options: WithAddress<UserCodeCCExtendedUserCodeGetOptions>);
+    static from(_raw: CCRaw, _ctx: CCParsingContext): UserCodeCCExtendedUserCodeGet;
+    userId: number;
+    reportMore: boolean;
+    serialize(ctx: CCEncodingContext): Bytes;
+    toLogEntry(ctx?: GetValueDB): MessageOrCCLogEntry;
+}
+//# sourceMappingURL=UserCodeCC.d.ts.map