@authvia/payment-method-create 0.1.0

package/dist/components/internal/AuthviaPaymentMethodAddAchOptions.vue.d.ts

@@ -0,0 +1,42 @@
+import { Ref } from 'vue';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    showConfirmLoader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    errorMessage: {
+        type: StringConstructor;
+        required: false;
+    };
+    isPlaidVisible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {
+    closePaymentMethodForms: () => void;
+    handleContinue: () => void;
+    formData: {
+        achOption: string;
+    };
+    isWorking: Ref<boolean, boolean>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("close-ach-options" | "ach-option-select")[], "close-ach-options" | "ach-option-select", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    showConfirmLoader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    errorMessage: {
+        type: StringConstructor;
+        required: false;
+    };
+    isPlaidVisible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onClose-ach-options"?: ((...args: any[]) => any) | undefined;
+    "onAch-option-select"?: ((...args: any[]) => any) | undefined;
+}>, {
+    isPlaidVisible: boolean;
+    showConfirmLoader: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/internal/AuthviaPaymentMethodCard.vue.d.ts

@@ -0,0 +1,22 @@
+import { PaymentMethodLogo } from '../../types';
+export interface Props {
+    disabled?: boolean;
+    title: string;
+    description: string;
+    logo?: PaymentMethodLogo;
+    /** Common size for logo slot (all methods use same box) */
+    logoSize?: number;
+    /** Size of SVG path icon inside slot */
+    iconSize?: number;
+    error?: string;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: () => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onClick?: (() => any) | undefined;
+}>, {
+    disabled: boolean;
+    logoSize: number;
+    iconSize: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/internal/AuthviaPaymentMethodCreditCard.vue.d.ts

@@ -0,0 +1,142 @@
+import { ComputedRef, PropType, Ref } from 'vue';
+import { PaymentMethodBillingAddress } from '../../model';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    demoMode: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    borderRadius: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    merchantId: {
+        type: StringConstructor;
+    };
+    forgetHidden: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    forgetDefault: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    authToken: {
+        type: StringConstructor;
+        required: true;
+    };
+    customerRef: {
+        type: StringConstructor;
+    };
+    billingAddress: {
+        type: PropType<PaymentMethodBillingAddress>;
+        required: false;
+    };
+    intent: {
+        type: StringConstructor;
+        required: false;
+    };
+    variant: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    color: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    submitLabel: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+}>, {
+    squelch: boolean;
+    token: string;
+    prefill: Ref<any, any>;
+    inDemoMode: Ref<boolean, boolean>;
+    isFormReady: Ref<boolean, boolean>;
+    isFormSubmit: Ref<boolean, boolean>;
+    isPaymentMethodAdded: Ref<boolean, boolean>;
+    paymentMethodResponse: Ref<any, any>;
+    working: Ref<boolean, boolean>;
+    isMerchantActive: ComputedRef<boolean>;
+    errorMessage: Ref<any, any>;
+    isBillingAddressMode: Ref<boolean, boolean>;
+    name: string;
+    streetAddress: string;
+    city: string;
+    state: string;
+    postalCode: string;
+    country: string;
+    isAddressEditable: boolean;
+    variant: string;
+    submitLabel: string;
+    handleSuccess: (event: any) => void;
+    handleError: (error: any) => void;
+    apiBaseUrl: string;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("error" | "success")[], "error" | "success", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    demoMode: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    borderRadius: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    merchantId: {
+        type: StringConstructor;
+    };
+    forgetHidden: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    forgetDefault: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    authToken: {
+        type: StringConstructor;
+        required: true;
+    };
+    customerRef: {
+        type: StringConstructor;
+    };
+    billingAddress: {
+        type: PropType<PaymentMethodBillingAddress>;
+        required: false;
+    };
+    intent: {
+        type: StringConstructor;
+        required: false;
+    };
+    variant: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    color: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    submitLabel: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+}>> & Readonly<{
+    onError?: ((...args: any[]) => any) | undefined;
+    onSuccess?: ((...args: any[]) => any) | undefined;
+}>, {
+    variant: string;
+    color: string;
+    forgetDefault: boolean;
+    demoMode: boolean;
+    borderRadius: string;
+    forgetHidden: boolean;
+    submitLabel: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/internal/AuthviaPaymentMethodRestrictions.vue.d.ts

@@ -0,0 +1,41 @@
+import { Ref } from 'vue';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    paymentMethodRestrictions: {
+        type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        required: true;
+    };
+}>, {
+    isShowRestrictions: Ref<boolean, boolean>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    paymentMethodRestrictions: {
+        type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/internal/AuthviaPazeForm.vue.d.ts

@@ -0,0 +1,48 @@
+export interface Props {
+    pzSettings?: {
+        clientId?: string;
+        name?: string;
+        profileId?: string;
+    };
+    amount?: number;
+    authToken?: string;
+    customerRef?: string;
+    autoStart?: boolean;
+}
+declare global {
+    interface Window {
+        DIGITAL_WALLET_SDK?: any;
+    }
+}
+declare const _default: import('vue').DefineComponent<Props, {
+    startPaze: () => Promise<void>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    error: (error: {
+        message: string;
+    }) => any;
+    success: (paymentMethodId: string | {
+        id: string;
+        forgetCard?: boolean;
+    }) => any;
+    cancel: () => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onError?: ((error: {
+        message: string;
+    }) => any) | undefined;
+    onSuccess?: ((paymentMethodId: string | {
+        id: string;
+        forgetCard?: boolean;
+    }) => any) | undefined;
+    onCancel?: (() => any) | undefined;
+}>, {
+    pzSettings: {
+        clientId?: string;
+        name?: string;
+        profileId?: string;
+    };
+    amount: number;
+    authToken: string;
+    customerRef: string;
+    autoStart: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/components/internal/AuthviaPciFooter.vue.d.ts

@@ -0,0 +1,5 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    pciLogo: string;
+    tlsSecureLogo: string;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/composables/useHostService.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Return type for useHostService composable
+ * Compatible with original HostService.instance() API
+ */
+export interface UseHostServiceReturn {
+    cdn: string;
+    api: string;
+    googleAPIKey: string;
+    isPlaidVisible: boolean;
+    pazeSDKURL: string;
+    plaidEnv: string;
+    paypalSDKURL: string;
+    paypalClientId: string;
+    paypalEnvironment: string;
+}
+/**
+ * Host Service Composable
+ * Provides host configuration management without singleton class dependency
+ * Maintains singleton behavior through module-level state
+ * Compatible with original HostService.instance() API
+ */
+export declare function useHostService(): UseHostServiceReturn;

package/dist/composables/usePaymentMethodService.d.ts

@@ -0,0 +1,34 @@
+import { Ref } from 'vue';
+import { PaymentMethod, APIOptions, PaymentMethodFilters, Token, PayPalSetupTokenResponse, PayPalIDTokenResponse } from '../model';
+import { useWalletMerchantService } from './useWalletMerchantService';
+/**
+ * Return type for usePaymentMethodService composable
+ */
+export interface UsePaymentMethodServiceReturn {
+    paymentMethod: Ref<PaymentMethod | undefined>;
+    all: Ref<PaymentMethod[] | undefined>;
+    options: Ref<PaymentMethod[]>;
+    filters: Ref<PaymentMethodFilters | undefined>;
+    permission: Ref<'use' | 'single-use' | undefined>;
+    setActivePaymentMethod: (paymentMethod: PaymentMethod | undefined) => void;
+    setActivePermission: (permission: 'use' | 'single-use' | undefined) => void;
+    resetPermission: () => void;
+    list: (userId: string, options: APIOptions) => Promise<PaymentMethod[]>;
+    create: (userId: string, paymentMethod: PaymentMethod, options: APIOptions, squelch?: boolean, customHeaders?: {
+        'x-avid'?: string;
+        'x-ref'?: string;
+        'x-intent'?: string;
+    }) => Promise<PaymentMethod>;
+    delete: (userId: string, options: APIOptions) => Promise<void>;
+    get: (options: APIOptions, paymentMethodId: string) => Promise<PaymentMethod>;
+    generatePlaidToken: (userId: string, options: APIOptions) => Promise<Token>;
+    filter: (filters: PaymentMethodFilters, userId: string, options: APIOptions, merchantService?: ReturnType<typeof useWalletMerchantService>) => Promise<void>;
+    generatePaypalIDToken: (options: APIOptions) => Promise<PayPalIDTokenResponse>;
+    getReturnUrl: () => string;
+    generatePaypalSetupToken: (options: APIOptions, paymentSourceType: string) => Promise<PayPalSetupTokenResponse>;
+}
+/**
+ * Payment Method Service Composable
+ * Provides payment method management functionality
+ */
+export declare function usePaymentMethodService(): UsePaymentMethodServiceReturn;

package/dist/composables/usePazeSDK.d.ts

@@ -0,0 +1,21 @@
+import { Ref } from 'vue';
+/**
+ * Composable for Paze SDK initialization and management
+ * Provides a shared instance that can be used across components
+ */
+export declare function usePazeSDK(): {
+    initPaze: (clientConfig?: {
+        clientId?: string;
+        name?: string;
+        profileId?: string;
+    }) => Promise<any>;
+    getPazeInstance: () => any;
+    resetPazeInstance: () => void;
+    isLoading: Ref<boolean, boolean>;
+    error: Ref<string, string>;
+};
+declare global {
+    interface Window {
+        DIGITAL_WALLET_SDK?: any;
+    }
+}

package/dist/composables/useWalletMerchantService.d.ts

@@ -0,0 +1,15 @@
+import { Ref, ComputedRef } from 'vue';
+import { Merchant } from '../model';
+/**
+ * Return type for useWalletMerchantService composable
+ */
+export interface UseWalletMerchantServiceReturn {
+    merchant: Ref<Merchant | undefined>;
+    tenderTypes: ComputedRef<string[] | undefined>;
+    setActiveMerchant: (merchant: Merchant | undefined) => void;
+}
+/**
+ * Wallet Merchant Service Composable
+ * Provides merchant management functionality
+ */
+export declare function useWalletMerchantService(): UseWalletMerchantServiceReturn;

package/dist/composables/useWalletTokenService.d.ts

@@ -0,0 +1,16 @@
+import { Ref } from 'vue';
+import { TokenGrants } from '../model/TokenGrants';
+/**
+ * Return type for useWalletTokenService composable
+ */
+export interface UseWalletTokenServiceReturn {
+    token: Ref<string | undefined>;
+    setActiveToken: (token: string) => void;
+    parse: (token: string) => TokenGrants;
+    isExpired: (token: string) => boolean;
+}
+/**
+ * Wallet Token Service Composable
+ * Provides token management functionality
+ */
+export declare function useWalletTokenService(): UseWalletTokenServiceReturn;

package/dist/entry/index.d.ts

@@ -0,0 +1,13 @@
+import { App } from 'vue';
+import { default as AuthviaPaymentMethodForm } from '../components/AuthviaPaymentMethodForm.vue';
+declare const AuthviaPaymentMethodFormPlugin: {
+    install: (app: App) => void;
+};
+export default AuthviaPaymentMethodFormPlugin;
+export { AuthviaPaymentMethodFormPlugin };
+export { AuthviaPaymentMethodForm };
+export type { AuthviaPaymentMethodFormProps, PaymentMethodFormData, VuetifyProps, SubmitEvent, SuccessEvent, ErrorEvent, PaymentMethodResponse, ValidationError, AVError } from '../types';
+export { ErrorHandler, ErrorCodes } from '../utils/errors';
+export { config, getApiEndpoint, getCdnUrl, isDevelopment, isProduction } from '../utils/config';
+export { getInputSpacingClasses, getSpacingCSSVariables } from '../utils/spacing';
+export { usePaymentMethodService } from '../composables/usePaymentMethodService';

package/dist/entry/web-component.d.ts

@@ -0,0 +1,92 @@
+import { AuthviaPaymentMethodFormProps } from '../types';
+type VueRuntime = typeof import('vue');
+type DependencyKey = 'vue-runtime' | 'vuetify-css' | 'mdi-css';
+type DependencyRegistry = Record<Extract<DependencyKey, 'vuetify-css' | 'mdi-css'>, {
+    status: 'pending' | 'ready' | 'missing';
+    href?: string;
+    version?: string;
+}>;
+declare global {
+    interface Window {
+        __AUTHVIA_DEPENDENCY_REGISTRY__?: DependencyRegistry;
+        __AUTHVIA_WEB_COMPONENT_CSS__?: string;
+        /** Set by @authvia/customer-add-physical-address plugin when used in web component build */
+        __AUTHVIA_VUE_PLUGIN_CSS__?: string;
+        Vue?: VueRuntime;
+    }
+    interface GlobalThis {
+        Vue?: VueRuntime;
+    }
+}
+declare class AuthviaPaymentMethodFormElement extends HTMLElement {
+    private app;
+    private shadow;
+    private container;
+    private vuetify;
+    private vueRuntime;
+    private dependencyObservers;
+    private readonly bundledMdiUrl;
+    private readonly hasBundledMdi;
+    constructor();
+    /**
+     * Copy CSS variables from document :root and host's ancestors to host element.
+     * This ensures demo/parent CSS variables are available inside Shadow DOM.
+     */
+    private copyCssVariablesFromRoot;
+    private initializeComponent;
+    private mountComponent;
+    private ensureDependencies;
+    private getAttributeValue;
+    /**
+     * Dialog overlays mount under {@link AuthviaPaymentMethodFormElement.container}, a sibling of the
+     * Vue form root, so they do not inherit inline --avwc-* from the inner div. Mirror theme tokens here.
+     */
+    private syncContainerThemeTokens;
+    private getComponentProps;
+    private dispatchCustomEvent;
+    static get observedAttributes(): string[];
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
+    private injectVuetifyOverrideStyles;
+    private getVuetifyOverrideCss;
+    private injectComponentStyles;
+    /**
+     * Injects ACH/dialog styles so inputs and buttons in dialogs get variable-based
+     * styling. Always run (with and without bundle CSS) so dialog overlay content
+     * is styled; appended last so it overrides. Scoped to .v-overlay__content for
+     * higher specificity so it wins over bundle CSS for overlay content.
+     */
+    private injectDevFallbackDialogStyles;
+    private injectDevVariablesStyles;
+    private ensureStylesheetDependency;
+    private findParentStylesheet;
+    private observeStylesheet;
+    private injectStylesheetFromHref;
+    private insertStylesheetElement;
+    private parseVersionFromHref;
+    private injectBundledMdi;
+    private getDependencyRegistry;
+    private handleMissingDependencies;
+    private dispatchMissingDependencyEvent;
+    private logMissingDependency;
+    private loadVueRuntime;
+    private getGlobalVueRuntime;
+    private waitForGlobalVueRuntime;
+    private cleanupDependencyObservers;
+    private removeDependencyObserver;
+    private isVersionSatisfied;
+    private compareSemver;
+    private forwardComponentEvents;
+}
+export declare function createEmbeddedPaymentMethodForm(config: {
+    container: HTMLElement;
+    props?: Partial<AuthviaPaymentMethodFormProps>;
+    onEvents?: Record<string, (e: Event) => void>;
+}): {
+    element: AuthviaPaymentMethodFormElement;
+    updateProps: (newProps: Partial<AuthviaPaymentMethodFormProps>) => void;
+    destroy: () => void;
+};
+export { AuthviaPaymentMethodFormElement };
+export default AuthviaPaymentMethodFormElement;

package/dist/model/APIOptions.d.ts

@@ -0,0 +1,3 @@
+export interface APIOptions {
+    token: string;
+}

package/dist/model/Contact.d.ts

@@ -0,0 +1,8 @@
+export type ContactPurpose = 'help' | 'technical' | 'business';
+export type ContactType = 'mobile-phone' | 'email' | 'phone';
+export interface Contact {
+    purpose: ContactPurpose;
+    type: ContactType;
+    value: string;
+    name?: string;
+}

package/dist/model/Merchant.d.ts

@@ -0,0 +1,8 @@
+import { MerchantProfile, Contact, MerchantProductSummary } from '../model';
+export interface Merchant {
+    id: string;
+    profile: MerchantProfile;
+    contacts: Contact[];
+    products: MerchantProductSummary[];
+    addresses?: string[];
+}

package/dist/model/MerchantProductSummary.d.ts

@@ -0,0 +1,6 @@
+export interface MerchantProductSummary {
+    line: string;
+    product: string;
+    provider: string;
+    demo: boolean;
+}

package/dist/model/MerchantProfile.d.ts

@@ -0,0 +1,22 @@
+import { MerchantTheme } from './MerchantTheme';
+export interface MerchantProfile {
+    name: string;
+    friendlyName?: string;
+    description: string;
+    businessAddress?: {
+        street?: string;
+        city?: string;
+        region?: string;
+        postalCode?: string;
+        country?: string;
+    };
+    logo?: string;
+    website?: string;
+    theme?: MerchantTheme;
+    docLinks?: {
+        privacyPolicy?: string;
+        returnPolicy?: string;
+        cancellationPolicy?: string;
+        shippingTerms?: string;
+    };
+}

package/dist/model/MerchantTheme.d.ts

@@ -0,0 +1,5 @@
+export interface MerchantTheme {
+    primaryColor?: string;
+    borderRadius?: string;
+    logo?: string;
+}

package/dist/model/PaymentMethod.d.ts

@@ -0,0 +1,65 @@
+export declare enum PaymentMethodType {
+    ACH = "ACH",
+    CreditCard = "CreditCard",
+    Token = "Token",
+    PLAID = "Plaid",
+    Tokenize = "Tokenize",
+    Paze = "Paze",
+    PayPal = "PayPal",
+    Venmo = "Venmo"
+}
+export interface PaymentMethod {
+    id: string;
+    type: PaymentMethodType;
+    identifier: string;
+    status: string;
+    userId?: string;
+    permissions?: Record<string, 'use' | 'single-use' | 'auto-charge'[]>;
+    forbidden?: string[];
+    ipAddress?: string;
+    hash?: string;
+    label?: string;
+    identity?: string;
+}
+export type CardType = string;
+export type CardCategory = string;
+export interface CreditCardIssuer {
+    name?: string;
+    website?: string;
+    phone?: string;
+    country?: string;
+}
+export interface CreditCard extends PaymentMethod {
+    nameOnCard: string;
+    cardNumber: string;
+    expirationMonth: number;
+    expirationYear: number;
+    streetAddress?: string;
+    state?: string;
+    city?: string;
+    zipCode?: string;
+    country?: string;
+    cardType?: CardType;
+    cardCategory?: CardCategory;
+    isDebit?: boolean;
+    isHSA?: boolean;
+    isBusiness?: boolean;
+    isSurchargeable?: boolean;
+    issuer?: CreditCardIssuer;
+}
+export interface Token extends Pick<CreditCard, 'nameOnCard' | 'expirationMonth' | 'expirationYear' | 'cardType' | 'cardCategory' | 'identifier'> {
+    token: string;
+    tokenContext: {
+        type: 'CreditCard' | string;
+        provider: string;
+        merchantId: string;
+        originatingId?: string;
+    };
+}
+export interface PayPalSetupTokenResponse {
+    id: string;
+}
+export interface PayPalIDTokenResponse {
+    idToken: string;
+    accessToken?: string;
+}

package/dist/model/PaymentMethodAPIError.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Authvia Error
+ */
+export declare class PaymentMethodAPIError extends Error {
+    code: string;
+    errors?: Array<any>;
+    status?: number;
+    id?: string;
+    /**
+     * Construct Error With Code
+     * @param code
+     * @param message
+     * @param errors
+     * @param status
+     * @param id
+     */
+    constructor(code: string, message: string, errors?: Array<any>, status?: number, id?: string);
+}