@c8y/ngx-components/trusted-certificates/list/trusted-certificate-list.component.d.ts

Angular modules for Cumulocity IoT applications

import { OnInit } from '@angular/core';
import { AlertService, ClipboardService, FeatureCacheService, ForOfFilterPipe, GainsightService, ModalService } from '@c8y/ngx-components';
import { BsModalService } from 'ngx-bootstrap/modal';
import { IResultList, ITrustedCertificate, SystemOptionsService, TrustedCertificateService } from '@c8y/client';
import { TranslateService } from '@ngx-translate/core';
import { BehaviorSubject, Observable } from 'rxjs';
import { TrustedCertificate } from './trusted-certificate.model';
import * as i0 from "@angular/core";
export declare class TrustedCertificateListComponent implements OnInit {
    private bsModal;
    private alertService;
    private trustedCertificateService;
    private modalService;
    private translateService;
    private clipboardService;
    private gainsightService;
    private systemOptionsService;
    private featureCacheService;
    PROOF_OF_POSSESSION_POPOVER: "\"Proof of possession\" is a security method used to prove that whoever sends a message is also in the possession of the particular cryptographic key.";
    SIGNED_VERIFICATION_CODE_POPOVER: "Use the following openssl command to create the signed verification code: openssl dgst -sha256 -sign <private.key> <verification_code.txt> | openssl base64 -A";
    AUTO_REGISTRATION_POPOVER: "Devices using the MQTT protocol with credentials signed by this certificate will be able to communicate with the platform without prior registration. The option does not support devices using the LWM2M protocol.";
    reloading: BehaviorSubject<boolean>;
    reload: BehaviorSubject<void>;
    trustedCertificates: Observable<IResultList<ITrustedCertificate>>;
    sortByExpirationDateAsc: ForOfFilterPipe<ITrustedCertificate>;
    certificateAuthorityExists: boolean;
    signedVerificationCode: string;
    PRODUCT_EXPERIENCE: {
        readonly EVENT: "trustedCertificate";
        readonly CERTIFICATES: {
            readonly COMPONENTS: {
                readonly TRUSTED_CERTIFICATE: "trusted-certificate";
            };
            readonly ACTIONS: {
                readonly ADD: "add";
                readonly UPDATE: "update";
                readonly DELETE: "delete";
                readonly RENEW: "renew";
            };
            readonly RESULTS: {
                readonly ADD_SUCCESS: "certificateAdded";
                readonly UPDATE_SUCCESS: "certificateUpdated";
                readonly DELETE_SUCCESS: "certificateDeleted";
                readonly RENEW_SUCCESS: "certificateRenewed";
            };
        };
        readonly VERIFICATION_CODE: {
            readonly COMPONENTS: {
                readonly REGENERATE_CODE: "regenerate-unsigned-verification-code";
                readonly VERIFY_CODE: "verify-signed-verification-code";
                readonly DOWNLOAD_CODE: "download-unsigned-verification-code";
            };
            readonly ACTIONS: {
                readonly REGENERATE: "regenerate";
                readonly VERIFY: "verify";
                readonly DOWNLOAD: "download";
            };
            readonly RESULTS: {
                readonly REGENERATE_SUCCESS: "unsignedVerificationCodeRegenerated";
                readonly VERIFY_SUCCESS: "signedCodeVerified";
                readonly VERIFY_FAILED: "signedCodeVerificationFailed";
            };
        };
    };
    certificateAuthorityFeatureEnabled: boolean;
    constructor(bsModal: BsModalService, alertService: AlertService, trustedCertificateService: TrustedCertificateService, modalService: ModalService, translateService: TranslateService, clipboardService: ClipboardService, gainsightService: GainsightService, systemOptionsService: SystemOptionsService, featureCacheService: FeatureCacheService);
    ngOnInit(): Promise<void>;
    loadTrustedCertificates(): Promise<void>;
    getTrustedCertificates(): Promise<IResultList<ITrustedCertificate>>;
    addTrustedCertificate(): Promise<void>;
    addCACertificate(): Promise<void>;
    deleteTrustedCertificate(certificate: any): Promise<void>;
    updateCertificate(trustedCertificate: ITrustedCertificate, updatingPart: Partial<ITrustedCertificate>): Promise<void>;
    getExpirationHighlight(item: ITrustedCertificate): {
        expired: boolean;
        icon: string;
        textClass: string;
        tooltipText: string;
        renewable: boolean;
    };
    regenerateUnsignedVerificationCode(trustedCertificate: ITrustedCertificate): void;
    verifySignedVerificationCode(trustedCertificate: TrustedCertificate): void;
    downloadUnsignedVerificationCode(trustedCertificate: ITrustedCertificate): void;
    copyUnsignedVerificationCodeToClipboard(trustedCertificate: ITrustedCertificate): void;
    onFileInput(event: any, trustedCertificate: TrustedCertificate): void;
    renewCertificate(): Promise<void>;
    private showLimitationAlert;
    private checkCertificateAuthorityFeature;
    static ɵfac: i0.ɵɵFactoryDeclaration<TrustedCertificateListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TrustedCertificateListComponent, "c8y-trusted-certificates", never, {}, {}, never, never, true, never>;
}
//# sourceMappingURL=trusted-certificate-list.component.d.ts.map