@justifi/webcomponents 4.23.1 → 5.0.0-rc-2

package/dist/collection/components/dispute-management/dispute-response/dispute-response.js

@@ -0,0 +1,186 @@
+import { h } from "@stencil/core";
+import { checkPkgVersion } from "../../../utils/check-pkg-version";
+import { config } from "../../../../config";
+import { StyledHost } from "../../../ui-components";
+import { makeCreateDisputeEvidence, makeUpdateDisputeResponse, makeSubmitDisputeResponse } from "./dispute-response-actions";
+import JustifiAnalytics from "../../../api/Analytics";
+import { ComponentErrorCodes, ComponentErrorSeverity } from "../../../api/ComponentError";
+import { DisputeService } from "../../../api/services/dispute.service";
+export class DisputeResponse {
+    constructor() {
+        this.handleErrorEvent = (event) => {
+            this.errorMessage = event.detail.message;
+            this.errorEvent.emit(event.detail);
+        };
+        this.updateDisputeResponse = undefined;
+        this.submitDisputeResponse = undefined;
+        this.createDisputeEvidence = undefined;
+        this.errorMessage = null;
+        this.authToken = undefined;
+        this.disputeId = undefined;
+        this.disputeResponse = undefined;
+        this.apiOrigin = config.proxyApiOrigin;
+    }
+    componentWillLoad() {
+        checkPkgVersion();
+        this.analytics = new JustifiAnalytics(this);
+        this.initializeDisputeServiceMethods();
+    }
+    disconnectedCallback() {
+        this.analytics.cleanup();
+    }
+    propChanged() {
+        this.initializeDisputeServiceMethods();
+    }
+    initializeDisputeServiceMethods() {
+        if (this.disputeId && this.authToken) {
+            this.updateDisputeResponse = makeUpdateDisputeResponse({
+                disputeId: this.disputeId,
+                authToken: this.authToken,
+                service: new DisputeService()
+            });
+            this.createDisputeEvidence = makeCreateDisputeEvidence({
+                disputeId: this.disputeId,
+                authToken: this.authToken,
+                service: new DisputeService()
+            });
+            this.submitDisputeResponse = makeSubmitDisputeResponse({
+                disputeId: this.disputeId,
+                authToken: this.authToken,
+                service: new DisputeService()
+            });
+        }
+        else {
+            this.errorMessage = 'Account ID and Auth Token are required';
+            this.errorEvent.emit({
+                errorCode: ComponentErrorCodes.MISSING_PROPS,
+                message: this.errorMessage,
+                severity: ComponentErrorSeverity.ERROR,
+            });
+        }
+    }
+    render() {
+        return (h(StyledHost, { key: '359300bac34b3e344e045750f354ce974f6a02ed' }, h("justifi-dispute-response-core", { key: '121c8c358b1a8a6e9084a9de00c977ff806be974', "onError-event": this.handleErrorEvent, "dispute-id": this.disputeId, disputeResponse: this.disputeResponse, createDisputeEvidence: this.createDisputeEvidence, updateDisputeResponse: this.updateDisputeResponse, submitDisputeResponse: this.submitDisputeResponse })));
+    }
+    ;
+    static get is() { return "justifi-dispute-response"; }
+    static get encapsulation() { return "shadow"; }
+    static get properties() {
+        return {
+            "authToken": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "attribute": "auth-token",
+                "reflect": false
+            },
+            "disputeId": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "attribute": "dispute-id",
+                "reflect": false
+            },
+            "disputeResponse": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "DisputeResponse",
+                    "resolved": "DisputeResponse",
+                    "references": {
+                        "DisputeResponse": {
+                            "location": "global",
+                            "id": "global::DisputeResponse"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                }
+            },
+            "apiOrigin": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "attribute": "api-origin",
+                "reflect": false,
+                "defaultValue": "config.proxyApiOrigin"
+            }
+        };
+    }
+    static get states() {
+        return {
+            "updateDisputeResponse": {},
+            "submitDisputeResponse": {},
+            "createDisputeEvidence": {},
+            "errorMessage": {}
+        };
+    }
+    static get events() {
+        return [{
+                "method": "errorEvent",
+                "name": "error-event",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "complexType": {
+                    "original": "ComponentErrorEvent",
+                    "resolved": "ComponentErrorEvent",
+                    "references": {
+                        "ComponentErrorEvent": {
+                            "location": "import",
+                            "path": "../../../api/ComponentEvents",
+                            "id": "src/api/ComponentEvents.ts::ComponentErrorEvent"
+                        }
+                    }
+                }
+            }];
+    }
+    static get watchers() {
+        return [{
+                "propName": "accountId",
+                "methodName": "propChanged"
+            }, {
+                "propName": "authToken",
+                "methodName": "propChanged"
+            }];
+    }
+}
+;

package/dist/collection/components/dispute-management/dispute-response/duplicate-charge.js

@@ -0,0 +1,106 @@
+import { h } from "@stencil/core";
+import { FormController } from "../../../ui-components/form/form";
+import DuplicateChargeSchema from "./schemas/duplicate-charge-schema";
+import { DisputeEvidenceDocument } from "../../../api/DisputeEvidenceDocument";
+import { DisputeResponseFormStep } from "./dispute-response-form-types";
+import { heading5 } from "../../../styles/parts";
+export class DuplicateCharge {
+    constructor() {
+        this.inputHandler = (name, value) => {
+            this.form.setValues(Object.assign(Object.assign({}, this.form.values.getValue()), { [name]: value }));
+        };
+        this.handleFileSelection = (e) => {
+            const target = e.target;
+            const name = target.name;
+            const files = target.files;
+            for (const file of files) {
+                this.documentList.push(new DisputeEvidenceDocument(file, name));
+            }
+        };
+        this.disputeResponse = undefined;
+        this.form = undefined;
+        this.errors = {};
+        this.documentList = [];
+    }
+    async validateAndSubmit(onSuccess) {
+        this.form.validateAndSubmit((formData) => onSuccess(formData, this.documentList, DisputeResponseFormStep.duplicateCharge));
+    }
+    ;
+    componentWillLoad() {
+        this.form = new FormController(DuplicateChargeSchema);
+    }
+    componentDidLoad() {
+        this.form.errors.subscribe(errors => {
+            this.errors = Object.assign({}, errors);
+        });
+    }
+    render() {
+        var _a, _b;
+        return (h("div", { key: 'a6729feaab17744bbd3c256b5bdee89939c9be55' }, h("div", { key: 'd3729ddaa5983766f87aa634399704c52ee4979c', class: "row gy-3" }, h("div", { key: '9c9288b63b688e83f53353a110ec31c078068312', class: "col-12" }, h("h2", { key: '431878c838002b8a15d202793ab3701cbc81df7e', class: "h5", part: heading5 }, "Duplicate Charge")), h("div", { key: 'f8b9a8dbb78777cb9c63a4296e41fdfe4edb2c7c', class: "col-12" }, h("form-control-text", { key: '8dc4ddad5ab952a09c99deef8734374891075575', label: "Original Payment ID", name: "duplicate_charge_original_payment_id", defaultValue: (_a = this.disputeResponse) === null || _a === void 0 ? void 0 : _a.duplicate_charge_original_payment_id, inputHandler: this.inputHandler, errorText: this.errors.duplicate_charge_original_payment_id })), h("div", { key: 'c5445211510dbdf1f6b547ef82ce128d3a316554', class: "col-12" }, h("form-control-textarea", { key: 'a650bf8ca839ae86d00d9df0eb77815a63ebafd6', label: "Duplicate Charge Explanation", name: "duplicate_charge_explanation", defaultValue: (_b = this.disputeResponse) === null || _b === void 0 ? void 0 : _b.duplicate_charge_explanation, inputHandler: this.inputHandler, errorText: this.errors.duplicate_charge_explanation })), h("div", { key: '47625dc4a02045230234220e24295b8260f38043', class: "col-12" }, h("form-control-file-v2", { key: '242b9ae244cc8fbad3721053a50042a76d8f40ad', label: "Duplicate Charge Documentation", name: "duplicate_charge_documentation", onChange: this.handleFileSelection })))));
+    }
+    static get is() { return "justifi-duplicate-charge"; }
+    static get properties() {
+        return {
+            "disputeResponse": {
+                "type": "any",
+                "mutable": false,
+                "complexType": {
+                    "original": "any",
+                    "resolved": "any",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "attribute": "dispute-response",
+                "reflect": false
+            }
+        };
+    }
+    static get states() {
+        return {
+            "form": {},
+            "errors": {},
+            "documentList": {}
+        };
+    }
+    static get methods() {
+        return {
+            "validateAndSubmit": {
+                "complexType": {
+                    "signature": "(onSuccess: (formData: any, documentList: DisputeEvidenceDocument[], formStep: DisputeResponseFormStep) => void) => Promise<void>",
+                    "parameters": [{
+                            "name": "onSuccess",
+                            "type": "(formData: any, documentList: DisputeEvidenceDocument[], formStep: DisputeResponseFormStep) => void",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "DisputeEvidenceDocument": {
+                            "location": "import",
+                            "path": "../../../api/DisputeEvidenceDocument",
+                            "id": "src/api/DisputeEvidenceDocument.ts::DisputeEvidenceDocument"
+                        },
+                        "DisputeResponseFormStep": {
+                            "location": "import",
+                            "path": "./dispute-response-form-types",
+                            "id": "src/components/dispute-management/dispute-response/dispute-response-form-types.ts::DisputeResponseFormStep"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            }
+        };
+    }
+}
+;

package/dist/collection/components/dispute-management/dispute-response/electronic-evidence.js

@@ -0,0 +1,106 @@
+import { h } from "@stencil/core";
+import { FormController } from "../../../ui-components/form/form";
+import ElectronicEvidenceSchema from "./schemas/electronic-evidence-schema";
+import { DisputeEvidenceDocument } from "../../../api/DisputeEvidenceDocument";
+import { DisputeResponseFormStep } from "./dispute-response-form-types";
+import { heading5 } from "../../../styles/parts";
+export class ElectronicEvidence {
+    constructor() {
+        this.handleFileSelection = (e) => {
+            const target = e.target;
+            const name = target.name;
+            const files = target.files;
+            for (const file of files) {
+                this.documentList.push(new DisputeEvidenceDocument(file, name));
+            }
+        };
+        this.inputHandler = (name, value) => {
+            this.form.setValues(Object.assign(Object.assign({}, this.form.values.getValue()), { [name]: value }));
+        };
+        this.disputeResponse = undefined;
+        this.form = undefined;
+        this.errors = {};
+        this.documentList = [];
+    }
+    async validateAndSubmit(onSuccess) {
+        this.form.validateAndSubmit((formData) => onSuccess(formData, this.documentList, DisputeResponseFormStep.electronicEvidence));
+    }
+    ;
+    componentWillLoad() {
+        this.form = new FormController(ElectronicEvidenceSchema);
+    }
+    componentDidLoad() {
+        this.form.errors.subscribe(errors => {
+            this.errors = Object.assign({}, errors);
+        });
+    }
+    render() {
+        var _a;
+        return (h("div", { key: '5521599b8e6d23412a06b4a9c6f5360f92ec9c12' }, h("div", { key: 'b1863623b1ffa07c18940d744184c7678515e1f3', class: "row gy-3" }, h("div", { key: '131410f3882f96e0346776db4c213e2ef17b546e', class: "col-12" }, h("h2", { key: '30120f59c8a7896f5294b4ccaf09165c1d28771e', class: "h5", part: heading5 }, "Electronic Evidence")), h("div", { key: '7211111acc93fd40b4140d49d4b1e3d268d13829', class: "col-12" }, h("form-control-text", { key: 'eeb3aeaa550569db5c977f3d2ef68b879be446c6', label: "Purchase IP Address", name: "customer_purchase_ip_address", helpText: "The IP address used by the customer during the purchase.", defaultValue: (_a = this.disputeResponse) === null || _a === void 0 ? void 0 : _a.customer_purchase_ip_address, inputHandler: this.inputHandler, errorText: this.errors.customer_purchase_ip_address })), h("div", { key: '7f98aae20a9f87d4f4f0b42f86350bb1468cc767', class: "col-12" }, h("form-control-file-v2", { key: '342b76753a12784852f2eb087941796874b90d39', label: "Activity Logs", name: "activity_log", helpText: "Any server or activity logs that provide evidence of the customer's access to or download of the purchased digital product. This information should encompass IP addresses, relevant timestamps, and any detailed records of activity.", onChange: this.handleFileSelection, errorText: this.errors.activity_log })))));
+    }
+    static get is() { return "justifi-electronic-evidence"; }
+    static get properties() {
+        return {
+            "disputeResponse": {
+                "type": "any",
+                "mutable": false,
+                "complexType": {
+                    "original": "any",
+                    "resolved": "any",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "attribute": "dispute-response",
+                "reflect": false
+            }
+        };
+    }
+    static get states() {
+        return {
+            "form": {},
+            "errors": {},
+            "documentList": {}
+        };
+    }
+    static get methods() {
+        return {
+            "validateAndSubmit": {
+                "complexType": {
+                    "signature": "(onSuccess: (formData: any, documentList: DisputeEvidenceDocument[], formStep: DisputeResponseFormStep) => void) => Promise<void>",
+                    "parameters": [{
+                            "name": "onSuccess",
+                            "type": "(formData: any, documentList: DisputeEvidenceDocument[], formStep: DisputeResponseFormStep) => void",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "DisputeEvidenceDocument": {
+                            "location": "import",
+                            "path": "../../../api/DisputeEvidenceDocument",
+                            "id": "src/api/DisputeEvidenceDocument.ts::DisputeEvidenceDocument"
+                        },
+                        "DisputeResponseFormStep": {
+                            "location": "import",
+                            "path": "./dispute-response-form-types",
+                            "id": "src/components/dispute-management/dispute-response/dispute-response-form-types.ts::DisputeResponseFormStep"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            }
+        };
+    }
+}
+;

package/dist/collection/components/dispute-management/dispute-response/product-or-service.js

@@ -0,0 +1,106 @@
+import { h } from "@stencil/core";
+import { FormController } from "../../../ui-components/form/form";
+import ProductOrServiceSchema from "./schemas/product-or-service-schema";
+import { DisputeEvidenceDocument } from "../../../api/DisputeEvidenceDocument";
+import { DisputeResponseFormStep } from "./dispute-response-form-types";
+import { heading5 } from "../../../styles/parts";
+export class ProductOrService {
+    constructor() {
+        this.handleFileSelection = (e) => {
+            const target = e.target;
+            const name = target.name;
+            const files = target.files;
+            for (const file of files) {
+                this.documentList.push(new DisputeEvidenceDocument(file, name));
+            }
+        };
+        this.inputHandler = (name, value) => {
+            this.form.setValues(Object.assign(Object.assign({}, this.form.values.getValue()), { [name]: value }));
+        };
+        this.disputeResponse = undefined;
+        this.form = undefined;
+        this.errors = {};
+        this.documentList = [];
+    }
+    async validateAndSubmit(onSuccess) {
+        this.form.validateAndSubmit((formData) => onSuccess(formData, this.documentList, DisputeResponseFormStep.productOrService));
+    }
+    ;
+    componentWillLoad() {
+        this.form = new FormController(ProductOrServiceSchema);
+    }
+    componentDidLoad() {
+        this.form.errors.subscribe(errors => {
+            this.errors = Object.assign({}, errors);
+        });
+    }
+    render() {
+        var _a, _b;
+        return (h("div", { key: 'ad4e3c33f8bc1c295ea51257afc41e6247537022' }, h("div", { key: 'a87f06ff09eadf63ee358a84759d6bd9223c76ec', class: "row gy-3" }, h("div", { key: 'a3053e1d5e2192786fab4592a3ef5a6614fa0de3', class: "col-12" }, h("h2", { key: 'e2b97bf1d8e6f964306f1d2292f00daf5f4e997d', class: "h5", part: heading5 }, "Product & Service Details")), h("div", { key: '0f4e0c72a0b145ec689e7f0a96df86d10be38423', class: "col-12" }, h("form-control-text", { key: 'dd6a94690ac454a35d3b9ddeadde3ae5926ae170', label: "Product Description", name: "product_description", defaultValue: (_a = this.disputeResponse) === null || _a === void 0 ? void 0 : _a.product_description, inputHandler: this.inputHandler, errorText: this.errors.product_description })), h("div", { key: 'd9c437dfc8e02bfacc27143e16b753b7940db409', class: "col-12" }, h("form-control-text", { key: '42e638a983cf713f0055d409b305b8fca2ac6bda', label: "Service Date", name: "service_date", defaultValue: (_b = this.disputeResponse) === null || _b === void 0 ? void 0 : _b.service_date, inputHandler: this.inputHandler, errorText: this.errors.service_date })), h("div", { key: 'df1f9b6153433e60973723ab20139fe3c739a4cf', class: "col-12" }, h("form-control-file-v2", { key: '6a03cdafcf9d8a4913eaf9b876500792022c58f4', label: "Service Documentation", name: "service_documentation", onChange: this.handleFileSelection, errorText: this.errors.service_documentation })))));
+    }
+    static get is() { return "justifi-product-or-service"; }
+    static get properties() {
+        return {
+            "disputeResponse": {
+                "type": "any",
+                "mutable": false,
+                "complexType": {
+                    "original": "any",
+                    "resolved": "any",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "attribute": "dispute-response",
+                "reflect": false
+            }
+        };
+    }
+    static get states() {
+        return {
+            "form": {},
+            "errors": {},
+            "documentList": {}
+        };
+    }
+    static get methods() {
+        return {
+            "validateAndSubmit": {
+                "complexType": {
+                    "signature": "(onSuccess: (formData: any, documentList: DisputeEvidenceDocument[], formStep: DisputeResponseFormStep) => void) => Promise<void>",
+                    "parameters": [{
+                            "name": "onSuccess",
+                            "type": "(formData: any, documentList: DisputeEvidenceDocument[], formStep: DisputeResponseFormStep) => void",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "DisputeEvidenceDocument": {
+                            "location": "import",
+                            "path": "../../../api/DisputeEvidenceDocument",
+                            "id": "src/api/DisputeEvidenceDocument.ts::DisputeEvidenceDocument"
+                        },
+                        "DisputeResponseFormStep": {
+                            "location": "import",
+                            "path": "./dispute-response-form-types",
+                            "id": "src/components/dispute-management/dispute-response/dispute-response-form-types.ts::DisputeResponseFormStep"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            }
+        };
+    }
+}
+;

package/dist/collection/components/dispute-management/dispute-response/refund-policy.js

@@ -0,0 +1,106 @@
+import { h } from "@stencil/core";
+import { FormController } from "../../../ui-components/form/form";
+import RefundPolicySchema from "./schemas/refund-policy-schema";
+import { DisputeEvidenceDocument } from "../../../api/DisputeEvidenceDocument";
+import { DisputeResponseFormStep } from "./dispute-response-form-types";
+import { heading5 } from "../../../styles/parts";
+export class RefundPolicy {
+    constructor() {
+        this.inputHandler = (name, value) => {
+            this.form.setValues(Object.assign(Object.assign({}, this.form.values.getValue()), { [name]: value }));
+        };
+        this.handleFileSelection = (e) => {
+            const target = e.target;
+            const name = target.name;
+            const files = target.files;
+            for (const file of files) {
+                this.documentList.push(new DisputeEvidenceDocument(file, name));
+            }
+        };
+        this.disputeResponse = undefined;
+        this.form = undefined;
+        this.errors = {};
+        this.documentList = [];
+    }
+    async validateAndSubmit(onSuccess) {
+        this.form.validateAndSubmit((formData) => onSuccess(formData, this.documentList, DisputeResponseFormStep.refundPolicy));
+    }
+    ;
+    componentWillLoad() {
+        this.form = new FormController(RefundPolicySchema);
+    }
+    componentDidLoad() {
+        this.form.errors.subscribe(errors => {
+            this.errors = Object.assign({}, errors);
+        });
+    }
+    render() {
+        var _a, _b;
+        return (h("div", { key: '54885e971c2d21be1d3c2a4654616e6406a425e5' }, h("div", { key: 'aefe693ee221d72f44a87806ca5ddc257bbf4073', class: "row gy-3" }, h("div", { key: '5a4c220a9cbcd8accd8dd3a3e9c5db74f520f483', class: "col-12" }, h("h2", { key: 'fee6747bc31eeee7648c5af1fec4e86dd33d2f21', class: "h5", part: heading5 }, "Refund Policy and Receipt")), h("div", { key: '70f2d38f553a77c6e5a4e2ec25bed11665cd56e5', class: "col-12" }, h("form-control-textarea", { key: 'a0635424932726c980d68bad1c7758159d382575', label: "Refund Policy Disclosure", name: "refund_policy_disclosure", defaultValue: (_a = this.disputeResponse) === null || _a === void 0 ? void 0 : _a.refund_policy_disclosure, inputHandler: this.inputHandler })), h("div", { key: 'b63f29f32b4a2bb35ec2dbeb2d26695bd58d2c32', class: "col-12" }, h("form-control-textarea", { key: '41787fd17b44810eb19945ce7ea5f340ee40ea98', label: "Refund Refusal Explanation", name: "refund_refusal_explanation", defaultValue: (_b = this.disputeResponse) === null || _b === void 0 ? void 0 : _b.refund_refusal_explanation, inputHandler: this.inputHandler })), h("div", { key: 'acff917b1af1babc1f93cf0541d9d2f22f8f4460', class: "col-12" }, h("form-control-file-v2", { key: '52bee3670ca1cae28fd2d07033796245b13306d4', label: "Upload Refund Policy", name: "refund_policy", onChange: this.handleFileSelection })), h("div", { key: '6e63ed1828f61cfec3882fba0ce0439668111a7a', class: "col-12" }, h("form-control-file-v2", { key: '99a13cfd6c0e662794c013368209c88065a7e404', label: "Upload Receipt", name: "receipt", onChange: this.handleFileSelection })))));
+    }
+    static get is() { return "justifi-refund-policy"; }
+    static get properties() {
+        return {
+            "disputeResponse": {
+                "type": "any",
+                "mutable": false,
+                "complexType": {
+                    "original": "any",
+                    "resolved": "any",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "attribute": "dispute-response",
+                "reflect": false
+            }
+        };
+    }
+    static get states() {
+        return {
+            "form": {},
+            "errors": {},
+            "documentList": {}
+        };
+    }
+    static get methods() {
+        return {
+            "validateAndSubmit": {
+                "complexType": {
+                    "signature": "(onSuccess: (formData: any, documentList: DisputeEvidenceDocument[], formStep: DisputeResponseFormStep) => void) => Promise<void>",
+                    "parameters": [{
+                            "name": "onSuccess",
+                            "type": "(formData: any, documentList: DisputeEvidenceDocument[], formStep: DisputeResponseFormStep) => void",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "DisputeEvidenceDocument": {
+                            "location": "import",
+                            "path": "../../../api/DisputeEvidenceDocument",
+                            "id": "src/api/DisputeEvidenceDocument.ts::DisputeEvidenceDocument"
+                        },
+                        "DisputeResponseFormStep": {
+                            "location": "import",
+                            "path": "./dispute-response-form-types",
+                            "id": "src/components/dispute-management/dispute-response/dispute-response-form-types.ts::DisputeResponseFormStep"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            }
+        };
+    }
+}
+;

package/dist/collection/components/dispute-management/dispute-response/schemas/additional-statement-schema.js

@@ -0,0 +1,5 @@
+import { object, string } from "yup";
+const AdditionalStatementSchema = object({
+    additional_statement: string().nullable(),
+});
+export default AdditionalStatementSchema;

package/dist/collection/components/dispute-management/dispute-response/schemas/cancellation-policy-schema.js

@@ -0,0 +1,6 @@
+import { object, string } from "yup";
+const CancellationPolicySchema = object({
+    cancellation_policy_disclosure: string().nullable(),
+    cancellation_rebuttal: string().nullable(),
+});
+export default CancellationPolicySchema;

package/dist/collection/components/dispute-management/dispute-response/schemas/customer-details-schema.js

@@ -0,0 +1,7 @@
+import { object, string } from "yup";
+const CustomerDetailsSchema = object({
+    customer_name: string().nullable(),
+    customer_email_address: string().nullable(),
+    customer_billing_address: string().nullable(),
+});
+export default CustomerDetailsSchema;

package/dist/collection/components/dispute-management/dispute-response/schemas/dispute-reason-schema.js

@@ -0,0 +1,5 @@
+import { object, string } from "yup";
+const DisputeResponseSchema = object({
+    reason: string().required('Dispute reason is required')
+});
+export default DisputeResponseSchema;

package/dist/collection/components/dispute-management/dispute-response/schemas/duplicate-charge-schema.js

@@ -0,0 +1,6 @@
+import { object, string } from "yup";
+const DuplicateChargeSchema = object({
+    duplicate_charge_original_payment_id: string().nullable(),
+    duplicate_charge_explanation: string().nullable(),
+});
+export default DuplicateChargeSchema;

package/dist/collection/components/dispute-management/dispute-response/schemas/electronic-evidence-schema.js

@@ -0,0 +1,5 @@
+import { object, string } from "yup";
+const ElectronicEvidenceSchema = object({
+    customer_purchase_ip_address: string().nullable(),
+});
+export default ElectronicEvidenceSchema;