@brifle/brifle-sdk 0.0.2

package/dist/esm/api/api.d.ts

@@ -0,0 +1,30 @@
+import { AuthenticationEndpoints } from "../endpoints/v1/authentication";
+import { ContentEndpoints } from "../endpoints/v1/content";
+import { SignaturesEndpoint } from "../endpoints/v1/signatures";
+declare class ApiV1 {
+    readonly endpoint: string;
+    readonly apiState: ApiV1State;
+    constructor(endpoint: string);
+    static get sandbox(): ApiV1;
+    static get production(): ApiV1;
+    /**
+     * gets an instance of the AuthenticationEndpoints
+     * @returns AuthenticationEndpoints
+     */
+    authentication(): AuthenticationEndpoints;
+    /**
+     * gets an instance of the ContentEndpoints
+     * @returns ContentEndpoints
+     */
+    content(): ContentEndpoints;
+    /**
+     * gets an instance of the SignatureEndpoints
+     * @returns ContentEndpoints
+     */
+    signature(): SignaturesEndpoint;
+}
+export interface ApiV1State {
+    auth_token?: string;
+    auth_token_expire_date?: Date;
+}
+export { ApiV1 };

package/dist/esm/endpoints/v1/apiResponse.d.ts

@@ -0,0 +1,42 @@
+import { AxiosError } from "axios";
+export declare class ApiResponse<ResponseType> {
+    private _data?;
+    private _error?;
+    private constructor();
+    /**
+     * create a success response from data
+     * @param data - The data to return
+     */
+    static success<ResponseType>(data: ResponseType): ApiResponse<ResponseType>;
+    /**
+     * create an error response from an AxiosError
+     * @param error - The AxiosError object
+     */
+    static error<ResponseType>(error: ErrorResponse): ApiResponse<ResponseType>;
+    /**
+     * create an error response from an AxiosError
+     * @param error - The AxiosError object
+     */
+    static errorAxios<ResponseType>(error: AxiosError): ApiResponse<ResponseType>;
+    /**
+     * check if the response is a success
+     */
+    get isSuccess(): boolean;
+    /**
+     * check if the response is an error
+     */
+    get isError(): boolean;
+    /**
+     * get the data from the response
+     */
+    get data(): ResponseType | undefined;
+    /**
+     * get the error from the response
+     */
+    get error(): ErrorResponse | undefined;
+}
+export interface ErrorResponse {
+    code: number;
+    message: string;
+    status: number;
+}

package/dist/esm/endpoints/v1/authentication.d.ts

@@ -0,0 +1,23 @@
+import { ApiV1 } from "../../api/api";
+import { ApiResponse } from "./apiResponse";
+import { LoginRequest } from "./requests/authentication";
+import { LoginResponse } from "./responses/authentication";
+declare class AuthenticationEndpoints {
+    private endpoint;
+    private readonly VERSION;
+    private state;
+    constructor(api: ApiV1);
+    /**
+     * builds the full path
+     * @param path - The path to the endpoint, e.g. "authentication/login"
+     * @returns
+     */
+    private getPath;
+    /**
+     * login to the API
+     * @param loginRequest - The login request object
+     * @returns the login response object
+     */
+    login(loginRequest: LoginRequest): Promise<ApiResponse<LoginResponse>>;
+}
+export { AuthenticationEndpoints };

package/dist/esm/endpoints/v1/content.d.ts

@@ -0,0 +1,42 @@
+import { ApiResponse } from "./apiResponse";
+import { CheckReceiverResponse, ContentActionsResponse, ContentResponse, SendContentResponse } from "./responses/content";
+import { ApiV1 } from "../../api/api";
+import { ReceiverRequest, SendContentRequest } from "./requests/content";
+declare class ContentEndpoints {
+    private endpoint;
+    private readonly VERSION;
+    private state;
+    constructor(api: ApiV1);
+    /**
+     * builds the full path
+     * @param path - The path to the endpoint, e.g. "authentication/login"
+     * @returns
+     */
+    private getPath;
+    /**
+     * get the content of a document
+     * @param documentId - The id of the document
+     * @returns the content of the document
+     */
+    getContent(documentId: string): Promise<ApiResponse<ContentResponse>>;
+    /**
+     * get the actions of a document
+     * @param documentId - The id of the document
+     * @returns the actions of the document
+     */
+    getContentActions(documentId: string): Promise<ApiResponse<ContentActionsResponse>>;
+    /**
+     * checks if a receiver is existing in Brifle
+     * @param receiver - The receiver object to check
+     * @returns
+     */
+    checkReceiver(receiver: ReceiverRequest): Promise<ApiResponse<CheckReceiverResponse>>;
+    /**
+     * send a content to a receiver
+     * @param tenantId - The tenant id of the receiver
+     * @param request - The request object to send
+     * @returns
+     */
+    sendContent(tenantId: string, request: SendContentRequest): Promise<ApiResponse<SendContentResponse>>;
+}
+export { ContentEndpoints };

package/dist/esm/endpoints/v1/requests/authentication.d.ts

@@ -0,0 +1,7 @@
+export interface LoginRequest {
+    key: string;
+    secret: string;
+}
+export interface LogoutRequest {
+    token: string;
+}

package/dist/esm/endpoints/v1/requests/content.d.ts

@@ -0,0 +1,50 @@
+interface ReceiverRequest {
+    account_id?: string;
+    birth_information?: BirthInformation;
+    email?: string;
+    tel?: string;
+    vad_id?: string;
+    ssn?: string;
+    first_name?: string;
+    last_name?: string;
+    full_name?: string;
+    date_of_birth?: string;
+}
+interface BirthInformation {
+    birth_name?: string;
+    date_of_birth: string;
+    place_of_birth: string;
+    nationality?: string;
+    given_names?: string;
+    last_name?: string;
+    postaL_address?: string;
+}
+interface PaymentDetails {
+    amount: number;
+    currency: 'EUR';
+    description: string;
+    due_date: string;
+    iban: string;
+    reference: string;
+}
+interface SendContentRequest {
+    to: ReceiverRequest;
+    type: 'letter' | 'invoice' | 'contract';
+    subject: string;
+    body: {
+        type: 'application/pdf';
+        content: string;
+    }[];
+    payment_info?: {
+        details?: PaymentDetails;
+        payable: boolean;
+    };
+    signature_info?: {
+        signature_reference: string;
+        requesting_signer: {
+            field: string;
+            signer: 'sender' | 'receiver';
+        }[];
+    };
+}
+export type { SendContentRequest, ReceiverRequest, BirthInformation, PaymentDetails };

package/dist/esm/endpoints/v1/requests/signatures.d.ts

@@ -0,0 +1,8 @@
+interface CreateSignatureReferenceRequest {
+    fields: {
+        name: string;
+        purpose: string;
+        role: string;
+    }[];
+}
+export type { CreateSignatureReferenceRequest };

package/dist/esm/endpoints/v1/responses/authentication.d.ts

@@ -0,0 +1,8 @@
+export interface LoginResponse {
+    access_token: string;
+    created_at: string;
+    expires_in: number;
+    refresh_token: string;
+    token_type: string;
+    scope: string;
+}

package/dist/esm/endpoints/v1/responses/content.d.ts

@@ -0,0 +1,68 @@
+interface SendContentResponse {
+    id: string;
+}
+interface CheckReceiverResponse {
+    receiver: {
+        type: string;
+    };
+}
+interface ContentMeta {
+    delivered: boolean;
+    delivered_date: string;
+    read: boolean;
+    read_date: string;
+    receiver?: string;
+    sender?: string;
+    receiver_state?: 'unread' | 'read' | 'archived' | 'trashed' | 'deleted' | 'pending';
+    sender_state?: 'activate' | 'activated' | 'trashed' | 'deleted' | 'pending';
+    sent_date: string;
+    size: number;
+    subject: string;
+    type: string;
+}
+interface ContentResponse {
+    content: {
+        content: string;
+        type: string;
+    };
+    meta: ContentMeta;
+}
+interface ContentActionsPaymentResponse {
+    details: {
+        amount: number;
+        currency: string;
+        due_date: string;
+        market: string;
+        reference: string;
+        iban: string;
+        tink_payment_id: string;
+    };
+    link: string;
+}
+interface ContentActionsSignatureResponse {
+    document_signatures: {
+        signature_ids: string[];
+        signature_reference: string;
+    };
+    embedded_signatures: {
+        created_by: string;
+        created_date: string;
+        document_signature_id: string;
+        due_date: string;
+        field_name: string;
+        history?: string;
+        purpose: string;
+        request_date: string;
+        requested_to: string;
+        signature_date: string;
+        signed_by: string;
+        signed_for: string;
+        value: string;
+    }[];
+    signature_reference: string;
+}
+interface ContentActionsResponse {
+    payments: ContentActionsPaymentResponse[];
+    signatures: ContentActionsSignatureResponse[];
+}
+export type { SendContentResponse, CheckReceiverResponse, ContentMeta, ContentResponse, ContentActionsResponse };

package/dist/esm/endpoints/v1/responses/signatures.d.ts

@@ -0,0 +1,10 @@
+interface CreateSignatureReferenceResponse {
+    id: string;
+    managed_by: string;
+    signature_fields: {
+        name: string;
+        purpose: string;
+        role: string;
+    }[];
+}
+export type { CreateSignatureReferenceResponse };

package/dist/esm/endpoints/v1/signatures.d.ts

@@ -0,0 +1,30 @@
+import { ApiV1 } from "../../api/api";
+import { CreateSignatureReferenceRequest } from "./requests/signatures";
+import { ApiResponse } from "./apiResponse";
+import { CreateSignatureReferenceResponse } from "./responses/signatures";
+declare class SignaturesEndpoint {
+    private endpoint;
+    private readonly VERSION;
+    private state;
+    constructor(api: ApiV1);
+    /**
+     * builds the full path
+     * @param path - The path to the endpoint, e.g. "authentication/login"
+     * @returns
+     */
+    private getPath;
+    /**
+     * creates a signature reference
+     * @param tenantId - The id of the tenant
+     * @param request - The request object
+     * @returns the response object
+     */
+    createSignatureReference(tenantId: string, request: CreateSignatureReferenceRequest): Promise<ApiResponse<CreateSignatureReferenceResponse>>;
+    /**
+     * gets a signature reference
+     * @param signatureId - The id of the signature
+     * @returns the response object
+     */
+    exportSignature(signatureId: string, format: 'xml'): Promise<ApiResponse<any>>;
+}
+export { SignaturesEndpoint };

package/dist/esm/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./api/api";
+export * from "./endpoints/v1/requests/authentication";
+export * from "./endpoints/v1/responses/authentication";
+export * from "./endpoints/v1/requests/content";
+export * from "./endpoints/v1/responses/content";
+export * from "./endpoints/v1/requests/signatures";
+export * from "./endpoints/v1/responses/signatures";
+export * from "./endpoints/v1/apiResponse";
+export * from "./endpoints/v1/authentication";
+export * from "./endpoints/v1/content";
+export * from "./endpoints/v1/signatures";

package/dist/esm/index.mjs

@@ -0,0 +1,300 @@
+import axios from 'axios';
+
+class ApiResponse {
+    constructor(data, error) {
+        this._data = data;
+        this._error = error;
+    }
+    /**
+     * create a success response from data
+     * @param data - The data to return
+     */
+    static success(data) {
+        return new ApiResponse(data);
+    }
+    /**
+     * create an error response from an AxiosError
+     * @param error - The AxiosError object
+     */
+    static error(error) {
+        return new ApiResponse(undefined, error);
+    }
+    /**
+     * create an error response from an AxiosError
+     * @param error - The AxiosError object
+     */
+    static errorAxios(error) {
+        const response = error.response;
+        if (response === undefined) {
+            return ApiResponse.error({
+                code: 50000,
+                message: "Unknown error",
+                status: 500
+            });
+        }
+        const data = response.data;
+        return ApiResponse.error({
+            code: data.code,
+            message: data.message,
+            status: response.status
+        });
+    }
+    /**
+     * check if the response is a success
+     */
+    get isSuccess() {
+        return this._data !== undefined;
+    }
+    /**
+     * check if the response is an error
+     */
+    get isError() {
+        return this._error !== undefined;
+    }
+    /**
+     * get the data from the response
+     */
+    get data() {
+        return this._data;
+    }
+    /**
+     * get the error from the response
+     */
+    get error() {
+        return this._error;
+    }
+}
+
+class AuthenticationEndpoints {
+    constructor(api) {
+        this.VERSION = "v1";
+        this.endpoint = api.endpoint;
+        this.state = api.apiState;
+    }
+    /**
+     * builds the full path
+     * @param path - The path to the endpoint, e.g. "authentication/login"
+     * @returns
+     */
+    getPath(path) {
+        return `${this.endpoint}/${this.VERSION}/auth/${path}`;
+    }
+    /**
+     * login to the API
+     * @param loginRequest - The login request object
+     * @returns the login response object
+     */
+    login(loginRequest) {
+        const path = this.getPath("login");
+        // axios.post(path, loginRequest)
+        return axios.post(path, loginRequest)
+            .then((response) => {
+            return ApiResponse.success(response.data);
+        }).then((response) => {
+            var _a, _b, _c, _d, _e;
+            const at = (_a = response.data) === null || _a === void 0 ? void 0 : _a.access_token;
+            this.state.auth_token = at;
+            const expire_in = ((_c = (_b = response.data) === null || _b === void 0 ? void 0 : _b.expires_in) !== null && _c !== void 0 ? _c : 0) * 1000;
+            const issue_time = new Date((_e = (_d = response.data) === null || _d === void 0 ? void 0 : _d.created_at) !== null && _e !== void 0 ? _e : new Date()).getMilliseconds();
+            const expires_milli = issue_time + expire_in;
+            this.state.auth_token_expire_date = new Date(expires_milli);
+            return response;
+        })
+            .catch((error) => {
+            return ApiResponse.errorAxios(error);
+        });
+    }
+}
+
+class ContentEndpoints {
+    constructor(api) {
+        this.VERSION = "v1";
+        this.endpoint = api.endpoint;
+        this.state = api.apiState;
+    }
+    /**
+     * builds the full path
+     * @param path - The path to the endpoint, e.g. "authentication/login"
+     * @returns
+     */
+    getPath(path) {
+        return `${this.endpoint}/${this.VERSION}/content/${path}`;
+    }
+    /**
+     * get the content of a document
+     * @param documentId - The id of the document
+     * @returns the content of the document
+     */
+    getContent(documentId) {
+        const path = this.getPath(`document/${documentId}`);
+        return axios.get(path, {
+            headers: {
+                "Authorization": `Bearer ${this.state.auth_token}`
+            }
+        })
+            .then((response) => {
+            return ApiResponse.success(response.data);
+        })
+            .catch((error) => {
+            return ApiResponse.errorAxios(error);
+        });
+    }
+    /**
+     * get the actions of a document
+     * @param documentId - The id of the document
+     * @returns the actions of the document
+     */
+    getContentActions(documentId) {
+        const path = this.getPath(`document/${documentId}/actions`);
+        return axios.get(path, {
+            headers: {
+                "Authorization": `Bearer ${this.state.auth_token}`
+            }
+        })
+            .then((response) => {
+            return ApiResponse.success(response.data);
+        })
+            .catch((error) => {
+            return ApiResponse.errorAxios(error);
+        });
+    }
+    /**
+     * checks if a receiver is existing in Brifle
+     * @param receiver - The receiver object to check
+     * @returns
+     */
+    checkReceiver(receiver) {
+        const path = this.getPath(`receiver/check`);
+        return axios.post(path, receiver, {
+            headers: {
+                "Authorization": `Bearer ${this.state.auth_token}`
+            }
+        })
+            .then((response) => {
+            return ApiResponse.success(response.data);
+        })
+            .catch((error) => {
+            return ApiResponse.errorAxios(error);
+        });
+    }
+    /**
+     * send a content to a receiver
+     * @param tenantId - The tenant id of the receiver
+     * @param request - The request object to send
+     * @returns
+     */
+    sendContent(tenantId, request) {
+        const path = this.getPath(`send/${tenantId}`);
+        return axios.post(path, request, {
+            headers: {
+                "Authorization": `Bearer ${this.state.auth_token}`
+            }
+        })
+            .then((response) => {
+            return ApiResponse.success(response.data);
+        })
+            .catch((error) => {
+            return ApiResponse.errorAxios(error);
+        });
+    }
+}
+
+class SignaturesEndpoint {
+    constructor(api) {
+        this.VERSION = "v1";
+        this.endpoint = api.endpoint;
+        this.state = api.apiState;
+    }
+    /**
+     * builds the full path
+     * @param path - The path to the endpoint, e.g. "authentication/login"
+     * @returns
+     */
+    getPath(path) {
+        return `${this.endpoint}/${this.VERSION}/signature/${path}`;
+    }
+    /**
+     * creates a signature reference
+     * @param tenantId - The id of the tenant
+     * @param request - The request object
+     * @returns the response object
+     */
+    createSignatureReference(tenantId, request) {
+        const path = this.getPath(`${tenantId}/reference`);
+        const headers = {
+            "Authorization": `Bearer ${this.state.auth_token}`,
+        };
+        return axios.post(path, request, { headers })
+            .then((response) => {
+            return ApiResponse.success(response.data);
+        })
+            .catch((error) => {
+            return ApiResponse.errorAxios(error);
+        });
+    }
+    /**
+     * gets a signature reference
+     * @param signatureId - The id of the signature
+     * @returns the response object
+     */
+    exportSignature(signatureId, format) {
+        const path = this.getPath(`${signatureId}/export/${format}`);
+        const headers = {
+            "Authorization": `Bearer ${this.state.auth_token}`,
+        };
+        return axios.get(path, { headers })
+            .then((response) => {
+            return ApiResponse.success(response.data);
+        })
+            .catch((error) => {
+            return ApiResponse.errorAxios(error);
+        });
+    }
+}
+
+var ENDPOINTS;
+(function (ENDPOINTS) {
+    ENDPOINTS["SANDBOX"] = "https://sandbox-api.brifle.de";
+    ENDPOINTS["PRODUCTION"] = "https://api.brifle.de";
+})(ENDPOINTS || (ENDPOINTS = {}));
+class ApiV1 {
+    constructor(endpoint) {
+        if (endpoint.endsWith("/")) {
+            this.endpoint = endpoint.slice(0, -1);
+        }
+        else {
+            this.endpoint = endpoint;
+        }
+        this.apiState = {};
+    }
+    static get sandbox() {
+        return new ApiV1(ENDPOINTS.SANDBOX);
+    }
+    static get production() {
+        return new ApiV1(ENDPOINTS.PRODUCTION);
+    }
+    /**
+     * gets an instance of the AuthenticationEndpoints
+     * @returns AuthenticationEndpoints
+     */
+    authentication() {
+        return new AuthenticationEndpoints(this);
+    }
+    /**
+     * gets an instance of the ContentEndpoints
+     * @returns ContentEndpoints
+     */
+    content() {
+        return new ContentEndpoints(this);
+    }
+    /**
+     * gets an instance of the SignatureEndpoints
+     * @returns ContentEndpoints
+     */
+    signature() {
+        return new SignaturesEndpoint(this);
+    }
+}
+
+export { ApiResponse, ApiV1, AuthenticationEndpoints, ContentEndpoints, SignaturesEndpoint };
+//# sourceMappingURL=index.mjs.map

package/dist/esm/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}