@brifle/brifle-sdk 0.0.5 → 0.2.0

package/dist/api/api.js

@@ -0,0 +1,79 @@
+import { AuthenticationEndpoints } from "../endpoints/v1/authentication";
+import { ContentEndpoints } from "../endpoints/v1/content";
+import { SignaturesEndpoint } from "../endpoints/v1/signatures";
+import { MailboxEndpoints } from "../endpoints/v1/mailbox";
+import { TenantsEndpoints } from "../endpoints/v1/tenant";
+import { AccountsEndpoints } from "../endpoints/v1/accounts";
+import { StatusEndpoint } from "../endpoints/v1/status";
+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);
+    }
+    /**
+     * gets an instance of the TenantsEndpoints
+     * @returns TenantsEndpoints
+     */
+    tenants() {
+        return new TenantsEndpoints(this);
+    }
+    /**
+     * gets an instance of the AccountsEndpoints
+     * @returns AccountsEndpoints
+     */
+    accounts() {
+        return new AccountsEndpoints(this);
+    }
+    /**
+     * gets an instance of the MailboxEndpoints
+     * @returns MailboxEndpoints
+     */
+    mailbox() {
+        return new MailboxEndpoints(this);
+    }
+    /**
+     * gets an instance of the StatusEndpoint
+     * @returns StatusEndpoint
+     */
+    status() {
+        return new StatusEndpoint(this);
+    }
+}
+export { ApiV1 };

package/dist/cjs/api/api.d.ts

@@ -4,6 +4,7 @@ import { SignaturesEndpoint } from "../endpoints/v1/signatures";
 import { MailboxEndpoints } from "../endpoints/v1/mailbox";
 import { TenantsEndpoints } from "../endpoints/v1/tenant";
 import { AccountsEndpoints } from "../endpoints/v1/accounts";
+import { StatusEndpoint } from "../endpoints/v1/status";
 declare class ApiV1 {
     readonly endpoint: string;
     readonly apiState: ApiV1State;
@@ -40,6 +41,11 @@ declare class ApiV1 {
      * @returns MailboxEndpoints
      */
     mailbox(): MailboxEndpoints;
+    /**
+     * gets an instance of the StatusEndpoint
+     * @returns StatusEndpoint
+     */
+    status(): StatusEndpoint;
 }
 export interface ApiV1State {
     auth_token?: string;

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

@@ -1,5 +1,5 @@
 import { ApiResponse } from "./apiResponse";
-import { CheckReceiverResponse, ContentActionsResponse, ContentResponse, SendContentResponse } from "./responses/content";
+import { CheckReceiverResponse, ContentActionsResponse, ContentResponse, CoverLetterOverviewResponse, SendContentResponse } from "./responses/content";
 import { ApiV1 } from "../../api/api";
 import { ReceiverRequest, SendContentRequest } from "./requests/content";
 declare class ContentEndpoints {
@@ -38,5 +38,20 @@ declare class ContentEndpoints {
      * @returns
      */
     sendContent(tenantId: string, request: SendContentRequest): Promise<ApiResponse<SendContentResponse>>;
+    /**
+     * list all cover letters for a tenant
+     * @param tenantId - The tenant id
+     * @returns
+     */
+    listCoverLetters(tenantId: string): Promise<ApiResponse<CoverLetterOverviewResponse>>;
+    /**
+     * get the content of a cover letter
+     * @param tenantId - The tenant id
+     * @param type - The type of the cover letter (custom | default)
+     * @param name - The name of the cover letter
+     * @param encoding - The encoding of the cover letter (base64 | pdf)
+     * @returns
+     */
+    getCoverLetterContent(tenantId: string, type: 'custom' | 'default', name: string, encoding: 'base64' | 'pdf'): Promise<import("axios").AxiosResponse<Blob, any>>;
 }
 export { ContentEndpoints };

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

@@ -9,6 +9,17 @@ interface ReceiverRequest {
     last_name?: string;
     full_name?: string;
     date_of_birth?: string;
+    postal_address?: PostalAddress;
+}
+interface PostalAddress {
+    city: string;
+    country: string;
+    date_of_birth?: string;
+    first_name: string;
+    house_number: string;
+    last_name: string;
+    postcode: string;
+    street: string;
 }
 interface BirthInformation {
     birth_name?: string;
@@ -17,7 +28,7 @@ interface BirthInformation {
     nationality?: string;
     given_names?: string;
     last_name?: string;
-    postaL_address?: string;
+    postal_address?: string;
 }
 interface PaymentDetails {
     amount: number;
@@ -35,6 +46,7 @@ interface SendContentRequest {
         type: 'application/pdf';
         content: string;
     }[];
+    fallback?: FallbackOptions;
     payment_info?: {
         details?: PaymentDetails;
         payable: boolean;
@@ -47,4 +59,21 @@ interface SendContentRequest {
         }[];
     };
 }
-export type { SendContentRequest, ReceiverRequest, BirthInformation, PaymentDetails };
+interface FallbackOptions {
+    enabled_physical_delivery: boolean;
+    paper_mail: {
+        recipient: {
+            address_line1: string;
+            address_line2?: string;
+            address_line3?: string;
+            postal_code: string;
+            city: string;
+            country: string;
+        };
+        test_mode: {
+            email: string;
+            enabled: boolean;
+        };
+    };
+}
+export type { SendContentRequest, ReceiverRequest, BirthInformation, PaymentDetails, FallbackOptions };

package/dist/cjs/endpoints/v1/requests/mailbox.d.ts

@@ -6,5 +6,7 @@ interface InboxFilter {
 }
 interface OutboxFilter {
     state?: Array<'active' | 'trashed'>;
+    subject?: string;
+    type?: 'letter' | 'invoice' | 'contract';
 }
 export type { InboxFilter, OutboxFilter };

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

@@ -19,14 +19,16 @@ interface ContentMeta {
     size: number;
     subject: string;
     type: string;
+    size_responsive?: number;
 }
 interface ContentResponse {
-    content: {
-        content: string;
-        type: string;
-    };
+    content: Content[];
     meta: ContentMeta;
 }
+interface Content {
+    content: string;
+    type: string;
+}
 interface ContentActionsPaymentResponse {
     details: {
         amount: number;
@@ -39,30 +41,41 @@ interface ContentActionsPaymentResponse {
     };
     link: string;
 }
+interface CoverLetterOverviewItem {
+    type: string;
+    name: string;
+    display_name: string;
+}
+interface CoverLetterOverviewResponse {
+    cover_letters: CoverLetterOverviewItem[];
+}
+interface EmbbededSignatureResponse {
+    id: string;
+    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;
+    status: 'pending' | 'signed' | 'rejected';
+}
 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;
-    }[];
+    embedded_signatures: EmbbededSignatureResponse[];
     signature_reference: string;
 }
 interface ContentActionsResponse {
-    payments: ContentActionsPaymentResponse[];
-    signatures: ContentActionsSignatureResponse[];
+    payments: ContentActionsPaymentResponse;
+    signatures: ContentActionsSignatureResponse;
 }
-export type { SendContentResponse, CheckReceiverResponse, ContentMeta, ContentResponse, ContentActionsResponse };
+export type { EmbbededSignatureResponse, Content, CoverLetterOverviewResponse, CoverLetterOverviewItem, ContentActionsSignatureResponse, ContentActionsPaymentResponse, SendContentResponse, CheckReceiverResponse, ContentMeta, ContentResponse, ContentActionsResponse };

package/dist/cjs/endpoints/v1/responses/status.d.ts

@@ -0,0 +1,8 @@
+interface StatusResponse {
+    status: string;
+    timestamp: string;
+    version: string;
+    service: string;
+    features: string[];
+}
+export type { StatusResponse };

package/dist/cjs/endpoints/v1/status.d.ts

@@ -0,0 +1,16 @@
+import { ApiV1 } from "../../api/api";
+import { ApiResponse } from "./apiResponse";
+import { StatusResponse } from "./responses/status";
+declare class StatusEndpoint {
+    private endpoint;
+    private readonly VERSION;
+    private state;
+    constructor(api: ApiV1);
+    private getPath;
+    /**
+     *
+     * @returns the
+     */
+    getStatus(): Promise<ApiResponse<StatusResponse>>;
+}
+export { StatusEndpoint };

package/dist/cjs/index.js

@@ -199,6 +199,42 @@ class ContentEndpoints {
             return ApiResponse.errorAxios(error);
         });
     }
+    /**
+     * list all cover letters for a tenant
+     * @param tenantId - The tenant id
+     * @returns
+     */
+    listCoverLetters(tenantId) {
+        const path = this.getPath(`cover_letters/${tenantId}/list`);
+        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 content of a cover letter
+     * @param tenantId - The tenant id
+     * @param type - The type of the cover letter (custom | default)
+     * @param name - The name of the cover letter
+     * @param encoding - The encoding of the cover letter (base64 | pdf)
+     * @returns
+     */
+    getCoverLetterContent(tenantId, type, name, encoding) {
+        const path = this.getPath(`cover_letter/${tenantId}/${type}/${name}/${encoding}`);
+        return axios.get(path, {
+            headers: {
+                "Authorization": `Bearer ${this.state.auth_token}`
+            },
+            responseType: 'blob'
+        });
+    }
 }
 
 class SignaturesEndpoint {
@@ -384,6 +420,31 @@ class AccountsEndpoints {
     }
 }
 
+class StatusEndpoint {
+    constructor(api) {
+        this.VERSION = "v1";
+        this.endpoint = api.endpoint;
+        this.state = api.apiState;
+    }
+    getPath(path) {
+        return `${this.endpoint}/${this.VERSION}/status/${path}`;
+    }
+    /**
+     *
+     * @returns the
+     */
+    getStatus() {
+        const path = this.getPath("");
+        return axios.get(path)
+            .then((response) => {
+            return ApiResponse.success(response.data);
+        })
+            .catch((error) => {
+            return ApiResponse.errorAxios(error);
+        });
+    }
+}
+
 var ENDPOINTS;
 (function (ENDPOINTS) {
     ENDPOINTS["SANDBOX"] = "https://sandbox-api.brifle.de";
@@ -447,6 +508,13 @@ class ApiV1 {
     mailbox() {
         return new MailboxEndpoints(this);
     }
+    /**
+     * gets an instance of the StatusEndpoint
+     * @returns StatusEndpoint
+     */
+    status() {
+        return new StatusEndpoint(this);
+    }
 }
 
 exports.AccountsEndpoints = AccountsEndpoints;

package/dist/cjs/index.js.map

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

package/dist/endpoints/v1/accounts.js

@@ -0,0 +1,32 @@
+import axios from "axios";
+import { ApiResponse } from "./apiResponse";
+class AccountsEndpoints {
+    constructor(api) {
+        this.VERSION = "v1";
+        this.endpoint = api.endpoint;
+        this.state = api.apiState;
+    }
+    getPath(path) {
+        return `${this.endpoint}/${this.VERSION}/accounts/${path}`;
+    }
+    /**
+     * Gets a tenant by its ID
+     */
+    getById(accountId) {
+        const path = this.getPath(`${accountId}`);
+        console.log(path, path);
+        return axios.get(path, {
+            headers: {
+                "Authorization": `Bearer ${this.state.auth_token}`,
+                "Content-Type": "application/json"
+            }
+        })
+            .then((response) => {
+            return ApiResponse.success(response.data);
+        })
+            .catch((error) => {
+            return ApiResponse.errorAxios(error);
+        });
+    }
+}
+export { AccountsEndpoints };

package/dist/endpoints/v1/apiResponse.js

@@ -0,0 +1,64 @@
+export 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;
+    }
+}

package/dist/endpoints/v1/authentication.js

@@ -0,0 +1,43 @@
+import { ApiResponse } from "./apiResponse";
+import axios from "axios";
+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);
+        });
+    }
+}
+export { AuthenticationEndpoints };

package/dist/endpoints/v1/content.js

@@ -0,0 +1,131 @@
+import axios from "axios";
+import { ApiResponse } from "./apiResponse";
+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);
+        });
+    }
+    /**
+     * list all cover letters for a tenant
+     * @param tenantId - The tenant id
+     * @returns
+     */
+    listCoverLetters(tenantId) {
+        const path = this.getPath(`cover_letters/${tenantId}/list`);
+        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 content of a cover letter
+     * @param tenantId - The tenant id
+     * @param type - The type of the cover letter (custom | default)
+     * @param name - The name of the cover letter
+     * @param encoding - The encoding of the cover letter (base64 | pdf)
+     * @returns
+     */
+    getCoverLetterContent(tenantId, type, name, encoding) {
+        const path = this.getPath(`cover_letter/${tenantId}/${type}/${name}/${encoding}`);
+        return axios.get(path, {
+            headers: {
+                "Authorization": `Bearer ${this.state.auth_token}`
+            },
+            responseType: 'blob'
+        });
+    }
+}
+export { ContentEndpoints };