@vicacha-devs/strapi-plugin-certificates 0.0.0-stage → 1.1.0

package/dist/server/src/index.d.ts

@@ -0,0 +1,413 @@
+declare const _default: {
+    register: ({ strapi }: {
+        strapi: import("@strapi/strapi").Core.Strapi;
+    }) => void;
+    bootstrap: ({ strapi }: {
+        strapi: import("@strapi/strapi").Core.Strapi;
+    }) => Promise<void>;
+    contentTypes: {
+        template: {
+            schema: {
+                kind: string;
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                    description: string;
+                };
+                options: {
+                    draftAndPublish: boolean;
+                };
+                pluginOptions: {
+                    "content-manager": {
+                        visible: boolean;
+                    };
+                    "content-type-builder": {
+                        visible: boolean;
+                    };
+                };
+                attributes: {
+                    name: {
+                        type: string;
+                        required: boolean;
+                        maxLength: number;
+                    };
+                    slug: {
+                        type: string;
+                        targetField: string;
+                        required: boolean;
+                    };
+                    description: {
+                        type: string;
+                    };
+                    serialPrefix: {
+                        type: string;
+                        required: boolean;
+                        default: string;
+                        maxLength: number;
+                    };
+                    defaultValidityDays: {
+                        type: string;
+                        min: number;
+                    };
+                    requiresWitnesses: {
+                        type: string;
+                        default: boolean;
+                    };
+                    minWitnesses: {
+                        type: string;
+                        default: number;
+                        min: number;
+                        max: number;
+                    };
+                    requiresApproval: {
+                        type: string;
+                        default: boolean;
+                    };
+                    esignEnabled: {
+                        type: string;
+                        default: boolean;
+                    };
+                    esignProvider: {
+                        type: string;
+                        enum: string[];
+                        default: string;
+                    };
+                    organizationName: {
+                        type: string;
+                        required: boolean;
+                        maxLength: number;
+                    };
+                    organizationSubheader: {
+                        type: string;
+                        maxLength: number;
+                    };
+                    headerText: {
+                        type: string;
+                        maxLength: number;
+                    };
+                    titleText: {
+                        type: string;
+                        required: boolean;
+                        maxLength: number;
+                    };
+                    bodyTemplate: {
+                        type: string;
+                        required: boolean;
+                    };
+                    footerText: {
+                        type: string;
+                    };
+                    defaultSignatories: {
+                        type: string;
+                        default: never[];
+                    };
+                    customFieldsSchema: {
+                        type: string;
+                        default: never[];
+                    };
+                    secondaryCalendars: {
+                        type: string;
+                        default: never[];
+                    };
+                    accentColor: {
+                        type: string;
+                        default: string;
+                        maxLength: number;
+                    };
+                    active: {
+                        type: string;
+                        default: boolean;
+                    };
+                };
+            };
+        };
+        certificate: {
+            schema: {
+                kind: string;
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                    description: string;
+                };
+                options: {
+                    draftAndPublish: boolean;
+                };
+                pluginOptions: {
+                    "content-manager": {
+                        visible: boolean;
+                    };
+                    "content-type-builder": {
+                        visible: boolean;
+                    };
+                };
+                attributes: {
+                    serialNumber: {
+                        type: string;
+                        required: boolean;
+                        unique: boolean;
+                        maxLength: number;
+                    };
+                    templateDocumentId: {
+                        type: string;
+                        required: boolean;
+                        maxLength: number;
+                    };
+                    templateSlug: {
+                        type: string;
+                        required: boolean;
+                        maxLength: number;
+                    };
+                    templateName: {
+                        type: string;
+                        required: boolean;
+                        maxLength: number;
+                    };
+                    status: {
+                        type: string;
+                        enum: string[];
+                        default: string;
+                        required: boolean;
+                    };
+                    recipientFullName: {
+                        type: string;
+                        required: boolean;
+                        maxLength: number;
+                    };
+                    recipientChosenName: {
+                        type: string;
+                        maxLength: number;
+                    };
+                    recipientEmail: {
+                        type: string;
+                    };
+                    recipientPhone: {
+                        type: string;
+                        maxLength: number;
+                    };
+                    recipientNationality: {
+                        type: string;
+                        maxLength: number;
+                    };
+                    nationalIdMasked: {
+                        type: string;
+                        maxLength: number;
+                    };
+                    nationalIdHash: {
+                        type: string;
+                        private: boolean;
+                        maxLength: number;
+                    };
+                    issuedAt: {
+                        type: string;
+                        required: boolean;
+                        maxLength: number;
+                    };
+                    expiresAt: {
+                        type: string;
+                        maxLength: number;
+                    };
+                    revokedAt: {
+                        type: string;
+                        maxLength: number;
+                    };
+                    revocationReason: {
+                        type: string;
+                    };
+                    signatories: {
+                        type: string;
+                        default: never[];
+                    };
+                    witnesses: {
+                        type: string;
+                        default: never[];
+                    };
+                    customData: {
+                        type: string;
+                        default: {};
+                    };
+                    secondaryDates: {
+                        type: string;
+                        default: {};
+                    };
+                    canonicalPayloadHash: {
+                        type: string;
+                        required: boolean;
+                        maxLength: number;
+                    };
+                    cryptographicSignature: {
+                        type: string;
+                        required: boolean;
+                    };
+                    publicKeyFingerprint: {
+                        type: string;
+                        required: boolean;
+                        maxLength: number;
+                    };
+                    verificationToken: {
+                        type: string;
+                        private: boolean;
+                        maxLength: number;
+                    };
+                    esignProvider: {
+                        type: string;
+                        enum: string[];
+                        default: string;
+                    };
+                    esignEnvelopeId: {
+                        type: string;
+                        maxLength: number;
+                    };
+                    esignEnvelopeStatus: {
+                        type: string;
+                        enum: string[];
+                        default: string;
+                    };
+                    esignCompletedAt: {
+                        type: string;
+                        maxLength: number;
+                    };
+                    linkedBookingCode: {
+                        type: string;
+                        maxLength: number;
+                    };
+                    notes: {
+                        type: string;
+                    };
+                };
+            };
+        };
+    };
+    controllers: {
+        admin: ({ strapi }: {
+            strapi: import("@strapi/strapi").Core.Strapi;
+        }) => {
+            getSettings(ctx: import('./controllers/admin').KoaContext): Promise<void>;
+            updateSettings(ctx: import('./controllers/admin').KoaContext): Promise<void>;
+            rotateKeys(ctx: import('./controllers/admin').KoaContext): Promise<void>;
+            listTemplates(ctx: import('./controllers/admin').KoaContext): Promise<void>;
+            createTemplate(ctx: import('./controllers/admin').KoaContext): Promise<void>;
+            seedTemplates(ctx: import('./controllers/admin').KoaContext): Promise<void>;
+            listCertificates(ctx: import('./controllers/admin').KoaContext): Promise<void>;
+            issueCertificate(ctx: import('./controllers/admin').KoaContext): Promise<void>;
+            sendDocuSignEnvelope(ctx: import('./controllers/admin').KoaContext): Promise<void>;
+            approveCertificate(ctx: import('./controllers/admin').KoaContext): Promise<void>;
+            revokeCertificate(ctx: import('./controllers/admin').KoaContext): Promise<void>;
+            printCertificate(ctx: import('./controllers/admin').KoaContext): Promise<void>;
+            exportCsv(ctx: import('./controllers/admin').KoaContext): Promise<void>;
+        };
+        "content-api": ({ strapi }: {
+            strapi: import("@strapi/strapi").Core.Strapi;
+        }) => {
+            listPublicTemplates(ctx: import('./controllers/content-api').KoaContext): Promise<void>;
+            getPublicKey(ctx: import('./controllers/content-api').KoaContext): Promise<void>;
+            applyCertificate(ctx: import('./controllers/content-api').KoaContext): Promise<void>;
+            verifyBySerial(ctx: import('./controllers/content-api').KoaContext): Promise<void>;
+            downloadPrintableHtml(ctx: import('./controllers/content-api').KoaContext): Promise<void>;
+            docusignWebhook(ctx: import('./controllers/content-api').KoaContext): Promise<void>;
+        };
+    };
+    routes: {
+        admin: {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    policies: never[];
+                };
+            }[];
+        };
+        "content-api": {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    auth: boolean;
+                };
+            }[];
+        };
+    };
+    services: {
+        settings: ({ strapi }: {
+            strapi: import("@strapi/strapi").Core.Strapi;
+        }) => {
+            getSigningKeyPair(): Promise<import('../../shared').Ed25519KeyPairMaterial>;
+            rotateKeyPair(): Promise<{
+                publicKeyPem: string;
+                publicKeyFingerprint: string;
+            }>;
+            getSettings(): Promise<import('../../shared').CertificatesPluginSettings>;
+            updateSettings(partial: Partial<import('../../shared').CertificatesPluginSettings>): Promise<import('../../shared').CertificatesPluginSettings>;
+        };
+        issuance: ({ strapi }: {
+            strapi: import("@strapi/strapi").Core.Strapi;
+        }) => {
+            listTemplates(activeOnly?: boolean): Promise<import('../../shared').CertificateTemplate[]>;
+            findTemplate(identifier: {
+                templateDocumentId?: string;
+                templateSlug?: string;
+            }): Promise<import('../../shared').CertificateTemplate | null>;
+            createTemplate(data: Partial<import('../../shared').CertificateTemplate>): Promise<import('../../shared').CertificateTemplate>;
+            seedDefaultTemplates(): Promise<number>;
+            issueCertificate(input: import('../../shared').CertificateIssueInput): Promise<import('../../shared').CertificateRecord>;
+            approveCertificate(documentId: string, options?: import('./services/issuance').ApproveCertificateOptions): Promise<import('../../shared').CertificateRecord>;
+            revokeCertificate(documentId: string, reason: string): Promise<import('../../shared').CertificateRecord>;
+            verifyCertificateBySerial(serialNumber: string, options?: {
+                token?: string;
+                nationalId?: string;
+            }): Promise<import('../../shared').CertificateVerificationResult | null>;
+            renderCertificateDocument(identifier: {
+                documentId?: string;
+                serialNumber?: string;
+            }, options?: {
+                token?: string;
+                isAdmin?: boolean;
+            }): Promise<{
+                html: string;
+                serialNumber: string;
+            } | null>;
+            listCertificates(filters?: {
+                status?: string;
+                templateSlug?: string;
+                search?: string;
+            }): Promise<{
+                records: import('../../shared').CertificateRecord[];
+                stats: import('../../shared').CertificateStats;
+            }>;
+            exportCsv(filters?: {
+                status?: string;
+                templateSlug?: string;
+            }): Promise<string>;
+        };
+        docusign: ({ strapi }: {
+            strapi: import("@strapi/strapi").Core.Strapi;
+        }) => {
+            sendEnvelopeForCertificate(documentId: string, options?: {
+                fetchImpl?: import('./services/docusign').FetchLikeFn;
+                accessToken?: string;
+            }): Promise<{
+                envelopeId: string;
+                envelopeStatus: import('../../shared').ESignEnvelopeStatus;
+                certificate: import('../../shared').CertificateRecord;
+            }>;
+            handleWebhookEvent(params: {
+                rawBody: string;
+                signatureHeader?: string;
+                payload: Record<string, unknown>;
+                webhookSecret?: string;
+            }): Promise<{
+                envelopeId: string;
+                envelopeStatus: import('../../shared').ESignEnvelopeStatus;
+                certificate: import('../../shared').CertificateRecord;
+            }>;
+        };
+    };
+};
+export default _default;

package/dist/server/src/register.d.ts

@@ -0,0 +1,5 @@
+import { Core } from '@strapi/strapi';
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => void;
+export default _default;

package/dist/server/src/routes/admin.d.ts

@@ -0,0 +1,12 @@
+declare const _default: {
+    type: string;
+    routes: {
+        method: string;
+        path: string;
+        handler: string;
+        config: {
+            policies: never[];
+        };
+    }[];
+};
+export default _default;

package/dist/server/src/routes/content-api.d.ts

@@ -0,0 +1,12 @@
+declare const _default: {
+    type: string;
+    routes: {
+        method: string;
+        path: string;
+        handler: string;
+        config: {
+            auth: boolean;
+        };
+    }[];
+};
+export default _default;

package/dist/server/src/routes/index.d.ts

@@ -0,0 +1,25 @@
+declare const _default: {
+    admin: {
+        type: string;
+        routes: {
+            method: string;
+            path: string;
+            handler: string;
+            config: {
+                policies: never[];
+            };
+        }[];
+    };
+    "content-api": {
+        type: string;
+        routes: {
+            method: string;
+            path: string;
+            handler: string;
+            config: {
+                auth: boolean;
+            };
+        }[];
+    };
+};
+export default _default;

package/dist/server/src/services/docusign.d.ts

@@ -0,0 +1,76 @@
+import { Core } from '@strapi/strapi';
+import { CertificateRecord, ESignEnvelopeStatus } from '../../../shared';
+export interface DocuSignSignerTab {
+    anchorString: string;
+    anchorUnits: "pixels";
+    anchorXOffset: string;
+    anchorYOffset: string;
+}
+export interface DocuSignSignerRecipient {
+    email: string;
+    name: string;
+    recipientId: string;
+    routingOrder: string;
+    roleName?: string;
+    tabs: {
+        signHereTabs: DocuSignSignerTab[];
+    };
+}
+export interface DocuSignEnvelopePayload {
+    emailSubject: string;
+    status: "sent" | "created";
+    documents: Array<{
+        documentBase64: string;
+        name: string;
+        fileExtension: "html";
+        documentId: "1";
+    }>;
+    recipients: {
+        signers: DocuSignSignerRecipient[];
+    };
+    customFields: {
+        textCustomFields: Array<{
+            name: string;
+            value: string;
+            show: "false";
+        }>;
+    };
+}
+export declare function validateDocuSignBaseUrl(rawUrl: string): string;
+export declare function buildDocuSignEnvelopePayload(params: {
+    certificate: CertificateRecord;
+    htmlDocument: string;
+    emailSubjectPrefix?: string;
+}): DocuSignEnvelopePayload;
+export type FetchLikeFn = (url: string, init: {
+    method: string;
+    headers: Record<string, string>;
+    body: string;
+}) => Promise<{
+    ok: boolean;
+    status: number;
+    json(): Promise<Record<string, unknown>>;
+}>;
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    sendEnvelopeForCertificate(documentId: string, options?: {
+        fetchImpl?: FetchLikeFn;
+        accessToken?: string;
+    }): Promise<{
+        envelopeId: string;
+        envelopeStatus: ESignEnvelopeStatus;
+        certificate: CertificateRecord;
+    }>;
+    handleWebhookEvent(params: {
+        rawBody: string;
+        signatureHeader?: string;
+        payload: Record<string, unknown>;
+        webhookSecret?: string;
+    }): Promise<{
+        envelopeId: string;
+        envelopeStatus: ESignEnvelopeStatus;
+        certificate: CertificateRecord;
+    }>;
+};
+export default _default;

package/dist/server/src/services/index.d.ts

@@ -0,0 +1,76 @@
+declare const _default: {
+    settings: ({ strapi }: {
+        strapi: import("@strapi/strapi").Core.Strapi;
+    }) => {
+        getSigningKeyPair(): Promise<import('../../../shared').Ed25519KeyPairMaterial>;
+        rotateKeyPair(): Promise<{
+            publicKeyPem: string;
+            publicKeyFingerprint: string;
+        }>;
+        getSettings(): Promise<import('../../../shared').CertificatesPluginSettings>;
+        updateSettings(partial: Partial<import('../../../shared').CertificatesPluginSettings>): Promise<import('../../../shared').CertificatesPluginSettings>;
+    };
+    issuance: ({ strapi }: {
+        strapi: import("@strapi/strapi").Core.Strapi;
+    }) => {
+        listTemplates(activeOnly?: boolean): Promise<import('../../../shared').CertificateTemplate[]>;
+        findTemplate(identifier: {
+            templateDocumentId?: string;
+            templateSlug?: string;
+        }): Promise<import('../../../shared').CertificateTemplate | null>;
+        createTemplate(data: Partial<import('../../../shared').CertificateTemplate>): Promise<import('../../../shared').CertificateTemplate>;
+        seedDefaultTemplates(): Promise<number>;
+        issueCertificate(input: import('../../../shared').CertificateIssueInput): Promise<import('../../../shared').CertificateRecord>;
+        approveCertificate(documentId: string, options?: import('./issuance').ApproveCertificateOptions): Promise<import('../../../shared').CertificateRecord>;
+        revokeCertificate(documentId: string, reason: string): Promise<import('../../../shared').CertificateRecord>;
+        verifyCertificateBySerial(serialNumber: string, options?: {
+            token?: string;
+            nationalId?: string;
+        }): Promise<import('../../../shared').CertificateVerificationResult | null>;
+        renderCertificateDocument(identifier: {
+            documentId?: string;
+            serialNumber?: string;
+        }, options?: {
+            token?: string;
+            isAdmin?: boolean;
+        }): Promise<{
+            html: string;
+            serialNumber: string;
+        } | null>;
+        listCertificates(filters?: {
+            status?: string;
+            templateSlug?: string;
+            search?: string;
+        }): Promise<{
+            records: import('../../../shared').CertificateRecord[];
+            stats: import('../../../shared').CertificateStats;
+        }>;
+        exportCsv(filters?: {
+            status?: string;
+            templateSlug?: string;
+        }): Promise<string>;
+    };
+    docusign: ({ strapi }: {
+        strapi: import("@strapi/strapi").Core.Strapi;
+    }) => {
+        sendEnvelopeForCertificate(documentId: string, options?: {
+            fetchImpl?: import('./docusign').FetchLikeFn;
+            accessToken?: string;
+        }): Promise<{
+            envelopeId: string;
+            envelopeStatus: import('../../../shared').ESignEnvelopeStatus;
+            certificate: import('../../../shared').CertificateRecord;
+        }>;
+        handleWebhookEvent(params: {
+            rawBody: string;
+            signatureHeader?: string;
+            payload: Record<string, unknown>;
+            webhookSecret?: string;
+        }): Promise<{
+            envelopeId: string;
+            envelopeStatus: import('../../../shared').ESignEnvelopeStatus;
+            certificate: import('../../../shared').CertificateRecord;
+        }>;
+    };
+};
+export default _default;

package/dist/server/src/services/issuance.d.ts

@@ -0,0 +1,54 @@
+import { Core } from '@strapi/strapi';
+import { CertificateIssueInput, CertificateRecord, CertificateSignatory, CertificateStats, CertificateTemplate, CertificateVerificationResult } from '../../../shared';
+export interface ApproveCertificateOptions {
+    signatories?: CertificateSignatory[];
+    witnesses?: Array<{
+        fullName: string;
+        documentIdRaw?: string;
+        documentIdMasked?: string;
+        role?: string;
+    }>;
+    recipientChosenName?: string;
+    notes?: string;
+}
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    listTemplates(activeOnly?: boolean): Promise<CertificateTemplate[]>;
+    findTemplate(identifier: {
+        templateDocumentId?: string;
+        templateSlug?: string;
+    }): Promise<CertificateTemplate | null>;
+    createTemplate(data: Partial<CertificateTemplate>): Promise<CertificateTemplate>;
+    seedDefaultTemplates(): Promise<number>;
+    issueCertificate(input: CertificateIssueInput): Promise<CertificateRecord>;
+    approveCertificate(documentId: string, options?: ApproveCertificateOptions): Promise<CertificateRecord>;
+    revokeCertificate(documentId: string, reason: string): Promise<CertificateRecord>;
+    verifyCertificateBySerial(serialNumber: string, options?: {
+        token?: string;
+        nationalId?: string;
+    }): Promise<CertificateVerificationResult | null>;
+    renderCertificateDocument(identifier: {
+        documentId?: string;
+        serialNumber?: string;
+    }, options?: {
+        token?: string;
+        isAdmin?: boolean;
+    }): Promise<{
+        html: string;
+        serialNumber: string;
+    } | null>;
+    listCertificates(filters?: {
+        status?: string;
+        templateSlug?: string;
+        search?: string;
+    }): Promise<{
+        records: CertificateRecord[];
+        stats: CertificateStats;
+    }>;
+    exportCsv(filters?: {
+        status?: string;
+        templateSlug?: string;
+    }): Promise<string>;
+};
+export default _default;