@citizenplatform/core 1.0.3 → 1.0.4

package/dist/libs/shared/components/physicalDescription/model/HeightRangeDTO.d.ts

@@ -0,0 +1,42 @@
+import type { DefaultRulesType, StringValues } from "libs/shared/types/common-types";
+export declare const HeightRangeFields: () => {
+    readonly fromHeightFeet: "fromHeightFeet";
+    readonly fromHeightInch: "fromHeightInch";
+    readonly fromHeightCm: "heightFromCm";
+    readonly toHeightFeet: "toHeightFeet";
+    readonly toHeightInch: "toHeightInch";
+    readonly toHeightCm: "heightToCm";
+    readonly heightError: "heightError";
+};
+export type HeightRangeFieldsType = ReturnType<typeof HeightRangeFields>;
+type HeightRangeFieldsValueType = Exclude<StringValues<HeightRangeFieldsType>, "heightError">;
+export declare const HeightRangeDTO: (isRequired?: boolean) => {
+    fieldsName: {
+        readonly fromHeightFeet: "fromHeightFeet";
+        readonly fromHeightInch: "fromHeightInch";
+        readonly fromHeightCm: "heightFromCm";
+        readonly toHeightFeet: "toHeightFeet";
+        readonly toHeightInch: "toHeightInch";
+        readonly toHeightCm: "heightToCm";
+        readonly heightError: "heightError";
+    };
+    defaultsRules: Record<HeightRangeFieldsValueType, DefaultRulesType>;
+    submitJson: {
+        heightFromCm: string | number;
+        fromHeightInch: string | number;
+        fromHeightFeet: string | number;
+        heightToCm: string | number;
+        toHeightInch: string | number;
+        toHeightFeet: string | number;
+    };
+    dtoName: "heightRange";
+    displayJson: import("libs/shared/types/common-types").FieldObject;
+    isValidJson: import("libs/shared/types/common-types").FieldObject<boolean>;
+    fieldError: import("libs/shared/types/common-types").FieldObject<string>;
+    helperText: import("libs/shared/types/common-types").FieldObject<string | number>;
+    menuTextColor?: import("libs/shared/enums/common-enums").MenuTextColorEnum;
+    initialArgs?: unknown[];
+};
+export type HeightRangeDTOType = ReturnType<typeof HeightRangeDTO>;
+export {};
+//# sourceMappingURL=HeightRangeDTO.d.ts.map

package/dist/libs/shared/components/physicalDescription/model/HeightRangeDTO.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HeightRangeDTO.d.ts","sourceRoot":"","sources":["../../../../../../src/libs/shared/components/physicalDescription/model/HeightRangeDTO.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAO,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAI1F,eAAO,MAAM,iBAAiB;;;;;;;;CAW7B,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC;AACzE,KAAK,0BAA0B,GAAG,OAAO,CAAC,YAAY,CAAC,qBAAqB,CAAC,EAAG,aAAa,CAAC,CAAC;AAE/F,eAAO,MAAM,cAAc,GAAI,aAAY,OAAe;;;;;;;;;;;;sBAuC3B,MAAM,GAAG,MAAM;wBACb,MAAM,GAAG,MAAM;wBACf,MAAM,GAAG,MAAM;oBACnB,MAAM,GAAG,MAAM;sBACb,MAAM,GAAG,MAAM;sBACf,MAAM,GAAG,MAAM;;;;;;;;;CAU7C,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/dist/libs/shared/components/physicalDescription/model/IdentificationMarksDTO.d.ts

@@ -0,0 +1,57 @@
+import { FieldEnum } from "libs/shared/enums/common-enums";
+import type { FieldObject } from "libs/shared/types/common-types";
+export declare const IdentificationMarksFields: () => {
+    readonly identificationMark: "idMarksTypeCd";
+    readonly bodypart: "bodyPartLocCd";
+    readonly identityMarkList: "identityMarkList";
+};
+export type IdentificationMarksFieldsType = ReturnType<typeof IdentificationMarksFields>;
+export declare const IdentificationMarksDTO: (isRequired?: boolean) => {
+    fieldsName: {
+        readonly identificationMark: "idMarksTypeCd";
+        readonly bodypart: "bodyPartLocCd";
+        readonly identityMarkList: "identityMarkList";
+    };
+    defaultsRules: {
+        idMarksTypeCd: {
+            required: boolean;
+            type: FieldEnum;
+            label: string;
+        };
+        bodyPartLocCd: {
+            required: boolean;
+            type: FieldEnum;
+            label: string;
+        };
+    };
+    submitJson: FieldObject<string> & {
+        idMarksTypeCd: number;
+        bodyPartLocCd: number;
+    } & {
+        identityMarkList: ({
+            id: string | number;
+        } & (FieldObject<string> & {
+            idMarksTypeCd: number;
+            bodyPartLocCd: number;
+        }))[];
+    };
+    displayJson: FieldObject<string> & {
+        idMarksTypeCd: number;
+        bodyPartLocCd: number;
+    } & {
+        identityMarkList: ({
+            id: string | number;
+        } & (FieldObject<string> & {
+            idMarksTypeCd: number;
+            bodyPartLocCd: number;
+        }))[];
+    };
+    dtoName: "identificationMarks";
+    isValidJson: FieldObject<boolean>;
+    fieldError: FieldObject<string>;
+    helperText: FieldObject<string | number>;
+    menuTextColor?: import("libs/shared/enums/common-enums").MenuTextColorEnum;
+    initialArgs?: unknown[];
+};
+export type IdentificationMarksDTOType = ReturnType<typeof IdentificationMarksDTO>;
+//# sourceMappingURL=IdentificationMarksDTO.d.ts.map

package/dist/libs/shared/components/physicalDescription/model/IdentificationMarksDTO.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IdentificationMarksDTO.d.ts","sourceRoot":"","sources":["../../../../../../src/libs/shared/components/physicalDescription/model/IdentificationMarksDTO.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAC7E,OAAO,KAAK,EAAO,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAIvE,eAAO,MAAM,yBAAyB;;;;CAMrC,CAAC;AAEF,MAAM,MAAM,6BAA6B,GAAG,UAAU,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAEzF,eAAO,MAAM,sBAAsB,GAAI,aAAY,OAAe;;;;;;;;;;;;;;;;;;;uBAmB7B,MAAM;uBAChB,MAAM;;0BAIE,CAAC;YAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;SAAE;2BALtB,MAAM;2BAChB,MAAM;UAI4C,CAAC,EAAE;;;uBAL3C,MAAM;uBAChB,MAAM;;0BAIE,CAAC;YAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;SAAE;2BALtB,MAAM;2BAChB,MAAM;UAI4C,CAAC,EAAE;;;;;;;;CAe/E,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/libs/shared/components/physicalDescription/model/PhysicalCharacteristicsDTO.d.ts

@@ -0,0 +1,68 @@
+import { FieldEnum } from "libs/shared/enums/common-enums";
+import type { FieldObject } from "libs/shared/types/common-types";
+export declare const PhysicalCharacteristicsFields: () => {
+    readonly category: "phyFeatCategoryCd";
+    readonly charactersticsType: "phyFeatureMajCd";
+    readonly charactersticsSubType: "phyFeatureMinCd";
+    readonly physicalCharacteristicsList: "physicalFeatureList";
+};
+export type PhysicalCharacteristicsFieldsType = ReturnType<typeof PhysicalCharacteristicsFields>;
+export declare const PhysicalCharacteristicsDTO: (isRequired?: boolean) => {
+    fieldsName: {
+        readonly category: "phyFeatCategoryCd";
+        readonly charactersticsType: "phyFeatureMajCd";
+        readonly charactersticsSubType: "phyFeatureMinCd";
+        readonly physicalCharacteristicsList: "physicalFeatureList";
+    };
+    defaultsRules: {
+        phyFeatCategoryCd: {
+            type: FieldEnum;
+            required: boolean;
+            label: string;
+        };
+        phyFeatureMajCd: {
+            required: boolean;
+            type: FieldEnum;
+            label: string;
+        };
+        phyFeatureMinCd: {
+            required: boolean;
+            type: FieldEnum;
+            label: string;
+        };
+    };
+    submitJson: FieldObject<string> & {
+        phyFeatCategoryCd: number;
+        phyFeatureMajCd: number;
+        phyFeatureMinCd: number;
+    } & {
+        physicalFeatureList: ({
+            id: string | number;
+        } & (FieldObject<string> & {
+            phyFeatCategoryCd: number;
+            phyFeatureMajCd: number;
+            phyFeatureMinCd: number;
+        }))[];
+    };
+    displayJson: FieldObject<string> & {
+        phyFeatCategoryCd: number;
+        phyFeatureMajCd: number;
+        phyFeatureMinCd: number;
+    } & {
+        physicalFeatureList: ({
+            id: string | number;
+        } & (FieldObject<string> & {
+            phyFeatCategoryCd: number;
+            phyFeatureMajCd: number;
+            phyFeatureMinCd: number;
+        }))[];
+    };
+    dtoName: "physicalFeature";
+    isValidJson: FieldObject<boolean>;
+    fieldError: FieldObject<string>;
+    helperText: FieldObject<string | number>;
+    menuTextColor?: import("libs/shared/enums/common-enums").MenuTextColorEnum;
+    initialArgs?: unknown[];
+};
+export type PhysicalCharacteristicsDTOType = ReturnType<typeof PhysicalCharacteristicsDTO>;
+//# sourceMappingURL=PhysicalCharacteristicsDTO.d.ts.map

package/dist/libs/shared/components/physicalDescription/model/PhysicalCharacteristicsDTO.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhysicalCharacteristicsDTO.d.ts","sourceRoot":"","sources":["../../../../../../src/libs/shared/components/physicalDescription/model/PhysicalCharacteristicsDTO.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAC7E,OAAO,KAAK,EAAO,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAIvE,eAAO,MAAM,6BAA6B;;;;;CAOzC,CAAC;AAEF,MAAM,MAAM,iCAAiC,GAAG,UAAU,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAEjG,eAAO,MAAM,0BAA0B,GAAI,aAAY,OAAe;;;;;;;;;;;;;;;;;;;;;;;;;2BAoB3C,MAAM;yBACI,MAAM;yBACH,MAAM;;6BAIA,CAAC;YAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;SAAE;+BAN3C,MAAM;6BACI,MAAM;6BACH,MAAM;UAI2C,CAAC,EAAE;;;2BANjE,MAAM;yBACI,MAAM;yBACH,MAAM;;6BAIA,CAAC;YAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;SAAE;+BAN3C,MAAM;6BACI,MAAM;6BACH,MAAM;UAI2C,CAAC,EAAE;;;;;;;;CAe3F,CAAC;AAEF,MAAM,MAAM,8BAA8B,GAAG,UAAU,CAAC,OAAO,0BAA0B,CAAC,CAAC"}

package/dist/libs/shared/components/physicalDescription/model/PhysicalDescriptionDTO.d.ts

@@ -0,0 +1,305 @@
+import { FieldEnum } from "libs/shared/enums/common-enums";
+import type { FieldObject } from "libs/shared/types/common-types";
+import { VALIDATION_MIN_LENGTH_ENUM, VALIDATION_MAX_LENGTH_ENUM } from "libs/shared/enums/validation-enums";
+export declare const PhysicalDescriptionFields: (isRequired?: boolean, gridsRequired?: boolean) => {
+    bodyBuildType: string;
+    bodyComplexionType: string;
+    phyDescOtherInfo: string;
+    heightRange: {
+        fieldsName: {
+            readonly fromHeightFeet: "fromHeightFeet";
+            readonly fromHeightInch: "fromHeightInch";
+            readonly fromHeightCm: "heightFromCm";
+            readonly toHeightFeet: "toHeightFeet";
+            readonly toHeightInch: "toHeightInch";
+            readonly toHeightCm: "heightToCm";
+            readonly heightError: "heightError";
+        };
+        defaultsRules: Record<"fromHeightFeet" | "fromHeightInch" | "heightFromCm" | "toHeightFeet" | "toHeightInch" | "heightToCm", import("libs/shared/types/common-types").DefaultRulesType>;
+        submitJson: {
+            heightFromCm: string | number;
+            fromHeightInch: string | number;
+            fromHeightFeet: string | number;
+            heightToCm: string | number;
+            toHeightInch: string | number;
+            toHeightFeet: string | number;
+        };
+        dtoName: "heightRange";
+        displayJson: FieldObject;
+        isValidJson: FieldObject<boolean>;
+        fieldError: FieldObject<string>;
+        helperText: FieldObject<string | number>;
+        menuTextColor?: import("libs/shared/enums/common-enums").MenuTextColorEnum;
+        initialArgs?: unknown[];
+    };
+    identificationMarks: {
+        fieldsName: {
+            readonly identificationMark: "idMarksTypeCd";
+            readonly bodypart: "bodyPartLocCd";
+            readonly identityMarkList: "identityMarkList";
+        };
+        defaultsRules: {
+            idMarksTypeCd: {
+                required: boolean;
+                type: FieldEnum;
+                label: string;
+            };
+            bodyPartLocCd: {
+                required: boolean;
+                type: FieldEnum;
+                label: string;
+            };
+        };
+        submitJson: FieldObject<string> & {
+            idMarksTypeCd: number;
+            bodyPartLocCd: number;
+        } & {
+            identityMarkList: ({
+                id: string | number;
+            } & (FieldObject<string> & {
+                idMarksTypeCd: number;
+                bodyPartLocCd: number;
+            }))[];
+        };
+        displayJson: FieldObject<string> & {
+            idMarksTypeCd: number;
+            bodyPartLocCd: number;
+        } & {
+            identityMarkList: ({
+                id: string | number;
+            } & (FieldObject<string> & {
+                idMarksTypeCd: number;
+                bodyPartLocCd: number;
+            }))[];
+        };
+        dtoName: "identificationMarks";
+        isValidJson: FieldObject<boolean>;
+        fieldError: FieldObject<string>;
+        helperText: FieldObject<string | number>;
+        menuTextColor?: import("libs/shared/enums/common-enums").MenuTextColorEnum;
+        initialArgs?: unknown[];
+    };
+    physicalFeature: {
+        fieldsName: {
+            readonly category: "phyFeatCategoryCd";
+            readonly charactersticsType: "phyFeatureMajCd";
+            readonly charactersticsSubType: "phyFeatureMinCd";
+            readonly physicalCharacteristicsList: "physicalFeatureList";
+        };
+        defaultsRules: {
+            phyFeatCategoryCd: {
+                type: FieldEnum;
+                required: boolean;
+                label: string;
+            };
+            phyFeatureMajCd: {
+                required: boolean;
+                type: FieldEnum;
+                label: string;
+            };
+            phyFeatureMinCd: {
+                required: boolean;
+                type: FieldEnum;
+                label: string;
+            };
+        };
+        submitJson: FieldObject<string> & {
+            phyFeatCategoryCd: number;
+            phyFeatureMajCd: number;
+            phyFeatureMinCd: number;
+        } & {
+            physicalFeatureList: ({
+                id: string | number;
+            } & (FieldObject<string> & {
+                phyFeatCategoryCd: number;
+                phyFeatureMajCd: number;
+                phyFeatureMinCd: number;
+            }))[];
+        };
+        displayJson: FieldObject<string> & {
+            phyFeatCategoryCd: number;
+            phyFeatureMajCd: number;
+            phyFeatureMinCd: number;
+        } & {
+            physicalFeatureList: ({
+                id: string | number;
+            } & (FieldObject<string> & {
+                phyFeatCategoryCd: number;
+                phyFeatureMajCd: number;
+                phyFeatureMinCd: number;
+            }))[];
+        };
+        dtoName: "physicalFeature";
+        isValidJson: FieldObject<boolean>;
+        fieldError: FieldObject<string>;
+        helperText: FieldObject<string | number>;
+        menuTextColor?: import("libs/shared/enums/common-enums").MenuTextColorEnum;
+        initialArgs?: unknown[];
+    };
+};
+export type PhysicalDescriptionFieldsType = ReturnType<typeof PhysicalDescriptionFields>;
+export declare const PhysicalDescriptionDTO: (isRequired?: boolean, gridsRequired?: boolean) => {
+    fieldsName: {
+        bodyBuildType: string;
+        bodyComplexionType: string;
+        phyDescOtherInfo: string;
+        heightRange: {
+            fieldsName: {
+                readonly fromHeightFeet: "fromHeightFeet";
+                readonly fromHeightInch: "fromHeightInch";
+                readonly fromHeightCm: "heightFromCm";
+                readonly toHeightFeet: "toHeightFeet";
+                readonly toHeightInch: "toHeightInch";
+                readonly toHeightCm: "heightToCm";
+                readonly heightError: "heightError";
+            };
+            defaultsRules: Record<"fromHeightFeet" | "fromHeightInch" | "heightFromCm" | "toHeightFeet" | "toHeightInch" | "heightToCm", import("libs/shared/types/common-types").DefaultRulesType>;
+            submitJson: {
+                heightFromCm: string | number;
+                fromHeightInch: string | number;
+                fromHeightFeet: string | number;
+                heightToCm: string | number;
+                toHeightInch: string | number;
+                toHeightFeet: string | number;
+            };
+            dtoName: "heightRange";
+            displayJson: FieldObject;
+            isValidJson: FieldObject<boolean>;
+            fieldError: FieldObject<string>;
+            helperText: FieldObject<string | number>;
+            menuTextColor?: import("libs/shared/enums/common-enums").MenuTextColorEnum;
+            initialArgs?: unknown[];
+        };
+        identificationMarks: {
+            fieldsName: {
+                readonly identificationMark: "idMarksTypeCd";
+                readonly bodypart: "bodyPartLocCd";
+                readonly identityMarkList: "identityMarkList";
+            };
+            defaultsRules: {
+                idMarksTypeCd: {
+                    required: boolean;
+                    type: FieldEnum;
+                    label: string;
+                };
+                bodyPartLocCd: {
+                    required: boolean;
+                    type: FieldEnum;
+                    label: string;
+                };
+            };
+            submitJson: FieldObject<string> & {
+                idMarksTypeCd: number;
+                bodyPartLocCd: number;
+            } & {
+                identityMarkList: ({
+                    id: string | number;
+                } & (FieldObject<string> & {
+                    idMarksTypeCd: number;
+                    bodyPartLocCd: number;
+                }))[];
+            };
+            displayJson: FieldObject<string> & {
+                idMarksTypeCd: number;
+                bodyPartLocCd: number;
+            } & {
+                identityMarkList: ({
+                    id: string | number;
+                } & (FieldObject<string> & {
+                    idMarksTypeCd: number;
+                    bodyPartLocCd: number;
+                }))[];
+            };
+            dtoName: "identificationMarks";
+            isValidJson: FieldObject<boolean>;
+            fieldError: FieldObject<string>;
+            helperText: FieldObject<string | number>;
+            menuTextColor?: import("libs/shared/enums/common-enums").MenuTextColorEnum;
+            initialArgs?: unknown[];
+        };
+        physicalFeature: {
+            fieldsName: {
+                readonly category: "phyFeatCategoryCd";
+                readonly charactersticsType: "phyFeatureMajCd";
+                readonly charactersticsSubType: "phyFeatureMinCd";
+                readonly physicalCharacteristicsList: "physicalFeatureList";
+            };
+            defaultsRules: {
+                phyFeatCategoryCd: {
+                    type: FieldEnum;
+                    required: boolean;
+                    label: string;
+                };
+                phyFeatureMajCd: {
+                    required: boolean;
+                    type: FieldEnum;
+                    label: string;
+                };
+                phyFeatureMinCd: {
+                    required: boolean;
+                    type: FieldEnum;
+                    label: string;
+                };
+            };
+            submitJson: FieldObject<string> & {
+                phyFeatCategoryCd: number;
+                phyFeatureMajCd: number;
+                phyFeatureMinCd: number;
+            } & {
+                physicalFeatureList: ({
+                    id: string | number;
+                } & (FieldObject<string> & {
+                    phyFeatCategoryCd: number;
+                    phyFeatureMajCd: number;
+                    phyFeatureMinCd: number;
+                }))[];
+            };
+            displayJson: FieldObject<string> & {
+                phyFeatCategoryCd: number;
+                phyFeatureMajCd: number;
+                phyFeatureMinCd: number;
+            } & {
+                physicalFeatureList: ({
+                    id: string | number;
+                } & (FieldObject<string> & {
+                    phyFeatCategoryCd: number;
+                    phyFeatureMajCd: number;
+                    phyFeatureMinCd: number;
+                }))[];
+            };
+            dtoName: "physicalFeature";
+            isValidJson: FieldObject<boolean>;
+            fieldError: FieldObject<string>;
+            helperText: FieldObject<string | number>;
+            menuTextColor?: import("libs/shared/enums/common-enums").MenuTextColorEnum;
+            initialArgs?: unknown[];
+        };
+    };
+    defaultsRules: {
+        [x: string]: {
+            required: boolean;
+            type: FieldEnum;
+            label: string;
+            minLength?: undefined;
+            maxLength?: undefined;
+        } | {
+            required: boolean;
+            type: FieldEnum;
+            label: string;
+            minLength: VALIDATION_MIN_LENGTH_ENUM;
+            maxLength: VALIDATION_MAX_LENGTH_ENUM;
+        };
+    };
+    submitJson: FieldObject<string> & {
+        [x: string]: number;
+    };
+    dtoName: "physicalDescription";
+    displayJson: FieldObject;
+    isValidJson: FieldObject<boolean>;
+    fieldError: FieldObject<string>;
+    helperText: FieldObject<string | number>;
+    menuTextColor?: import("libs/shared/enums/common-enums").MenuTextColorEnum;
+    initialArgs?: unknown[];
+};
+export type PhysicalDescriptionDTOType = ReturnType<typeof PhysicalDescriptionDTO>;
+//# sourceMappingURL=PhysicalDescriptionDTO.d.ts.map

package/dist/libs/shared/components/physicalDescription/model/PhysicalDescriptionDTO.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhysicalDescriptionDTO.d.ts","sourceRoot":"","sources":["../../../../../../src/libs/shared/components/physicalDescription/model/PhysicalDescriptionDTO.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAK7E,OAAO,KAAK,EAAE,WAAW,EAAO,MAAM,gCAAgC,CAAC;AAEvE,OAAO,EAAE,0BAA0B,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAM5G,eAAO,MAAM,yBAAyB,GAAI,aAAY,OAAe,EAAE,gBAAe,OAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAUpG,CAAC;AAEF,MAAM,MAAM,6BAA6B,GAAG,UAAU,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAEzF,eAAO,MAAM,sBAAsB,GAAI,aAAY,OAAe,EAAE,gBAAe,OAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCjG,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/libs/shared/components/physicalDescription/physicalDescUtils.d.ts

@@ -0,0 +1,21 @@
+import type { PhysicalDescriptionDTOType } from "./model/PhysicalDescriptionDTO";
+export declare const convertToCm: (feet: string | number, inch: string | number) => string;
+export declare const handleHeightInput: (value: string, type: "feet" | "inch") => string;
+export declare function getPhysicalDescriptionData(physicalDescriptionDto: PhysicalDescriptionDTOType): {
+    heightFromCm: string | number;
+    heightToCm: string | number;
+    identityMarkList: ({
+        id: string | number;
+    } & import("../../types/common-types").FieldObject<string> & {
+        idMarksTypeCd: number;
+        bodyPartLocCd: number;
+    })[];
+    physicalFeatureList: ({
+        id: string | number;
+    } & import("../../types/common-types").FieldObject<string> & {
+        phyFeatCategoryCd: number;
+        phyFeatureMajCd: number;
+        phyFeatureMinCd: number;
+    })[];
+};
+//# sourceMappingURL=physicalDescUtils.d.ts.map

package/dist/libs/shared/components/physicalDescription/physicalDescUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"physicalDescUtils.d.ts","sourceRoot":"","sources":["../../../../../src/libs/shared/components/physicalDescription/physicalDescUtils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gCAAgC,CAAC;AAWjF,eAAO,MAAM,WAAW,GAAI,MAAM,MAAM,GAAG,MAAM,EAAE,MAAM,MAAM,GAAG,MAAM,WAKvE,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,OAAO,MAAM,EAAE,MAAM,MAAM,GAAG,MAAM,WAcrE,CAAC;AAEF,wBAAgB,0BAA0B,CAAC,sBAAsB,EAAE,0BAA0B;;;;;;;;;;;;;;;;EAe5F"}

package/dist/libs/shared/components/physicalDescription/physicalDescription.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+import type { physicalDescriptionProps } from "./definations/physicalDescriptionTypes";
+declare const _default: React.MemoExoticComponent<(props: physicalDescriptionProps) => React.JSX.Element>;
+export default _default;
+//# sourceMappingURL=physicalDescription.d.ts.map

package/dist/libs/shared/components/physicalDescription/physicalDescription.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"physicalDescription.d.ts","sourceRoot":"","sources":["../../../../../src/libs/shared/components/physicalDescription/physicalDescription.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,wCAAwC,CAAC;0DAanD,wBAAwB;AA8D5D,wBAA+C"}

package/dist/libs/shared/components/singleAddress/SingleAddress.d.ts

@@ -0,0 +1,7 @@
+import type { CommonProps } from "libs/shared/types/common-types";
+export interface SingleAddressProps extends CommonProps {
+    dtoName?: string;
+}
+declare const SingleAddress: (props: SingleAddressProps) => import("react").JSX.Element;
+export default SingleAddress;
+//# sourceMappingURL=SingleAddress.d.ts.map

package/dist/libs/shared/components/singleAddress/SingleAddress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SingleAddress.d.ts","sourceRoot":"","sources":["../../../../../src/libs/shared/components/singleAddress/SingleAddress.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAA0B,MAAM,gCAAgC,CAAC;AAQ1F,MAAM,WAAW,kBAAmB,SAAQ,WAAW;IACrD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,QAAA,MAAM,aAAa,GAAI,OAAO,kBAAkB,gCAiL/C,CAAC;AACF,eAAe,aAAa,CAAC"}

package/dist/libs/shared/components/singleAddress/singleAddressController.d.ts

@@ -0,0 +1,34 @@
+import type { MasterResponseDataType, StateDistrictPSDataType } from "../../types/common-types";
+import type { SingleAddressProps } from "./SingleAddress";
+export declare function useSingleAddressController(props: SingleAddressProps): {
+    singleAddressState: {
+        fieldsName: {
+            readonly houseNo: "addressLine1";
+            readonly streetName: "addressLine2";
+            readonly colony: "addressLine3";
+            readonly country: "countryCd";
+            readonly state: "stateId";
+            readonly district: "lgDistrictCd";
+            readonly policeStation: "psId";
+            readonly subDistrict: "subDistrictCd";
+            readonly village: "villageCd";
+            readonly pincode: "pincode";
+            readonly addressType: "addressTypeCd";
+            readonly other: "outsideIndiaAddr";
+        };
+        defaultsRules: Record<"psId" | "stateId" | "lgDistrictCd" | "subDistrictCd" | "villageCd" | "pincode" | "addressLine1" | "addressLine2" | "addressLine3" | "countryCd" | "outsideIndiaAddr", import("../../types/common-types").DefaultRulesType>;
+        submitJson: import("../../types/common-types").CommonAddressFieldsTypes;
+        displayJson: import("../../types/common-types").CommonAddressFieldsTypesDisplay;
+        dtoName: string;
+        isValidJson: import("../../types/common-types").FieldObject<boolean>;
+        fieldError: import("../../types/common-types").FieldObject<string>;
+        helperText: import("../../types/common-types").FieldObject<string | number>;
+        menuTextColor?: import("libs/shared/enums/common-enums").MenuTextColorEnum;
+        initialArgs?: unknown[];
+    };
+    onChangeTextInputField: (event: React.ChangeEvent<HTMLInputElement>) => void;
+    onChangeMaster: (event: React.BaseSyntheticEvent, data: MasterResponseDataType | StateDistrictPSDataType) => void;
+    parentSliceName: string;
+};
+export default useSingleAddressController;
+//# sourceMappingURL=singleAddressController.d.ts.map

package/dist/libs/shared/components/singleAddress/singleAddressController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"singleAddressController.d.ts","sourceRoot":"","sources":["../../../../../src/libs/shared/components/singleAddress/singleAddressController.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAG,sBAAsB,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AAUjG,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAE1D,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;oCAiD3B,KAAK,CAAC,WAAW,CAAC,gBAAgB,CAAC;4BAU3C,KAAK,CAAC,kBAAkB,QAAQ,sBAAsB,GAAG,uBAAuB;;EAkBhH;AAED,eAAe,0BAA0B,CAAC"}

package/dist/libs/shared/components/singleAddress/singleAddressDto.d.ts

@@ -0,0 +1,45 @@
+import type { CommonAddressFieldsTypes, CommonAddressFieldsTypesDisplay, DefaultRulesType, StringValues } from "libs/shared/types/common-types";
+export declare const SingleAddressFields: () => {
+    readonly houseNo: "addressLine1";
+    readonly streetName: "addressLine2";
+    readonly colony: "addressLine3";
+    readonly country: "countryCd";
+    readonly state: "stateId";
+    readonly district: "lgDistrictCd";
+    readonly policeStation: "psId";
+    readonly subDistrict: "subDistrictCd";
+    readonly village: "villageCd";
+    readonly pincode: "pincode";
+    readonly addressType: "addressTypeCd";
+    readonly other: "outsideIndiaAddr";
+};
+export type SingleAddressFieldsType = ReturnType<typeof SingleAddressFields>;
+type SingleAddressFieldsValueType = Exclude<StringValues<SingleAddressFieldsType>, "addressTypeCd" | "id" | "isCommAddr">;
+export declare const SingleAddressDTO: (isValidationRequired?: boolean, dtoName?: string) => {
+    fieldsName: {
+        readonly houseNo: "addressLine1";
+        readonly streetName: "addressLine2";
+        readonly colony: "addressLine3";
+        readonly country: "countryCd";
+        readonly state: "stateId";
+        readonly district: "lgDistrictCd";
+        readonly policeStation: "psId";
+        readonly subDistrict: "subDistrictCd";
+        readonly village: "villageCd";
+        readonly pincode: "pincode";
+        readonly addressType: "addressTypeCd";
+        readonly other: "outsideIndiaAddr";
+    };
+    defaultsRules: Record<SingleAddressFieldsValueType, DefaultRulesType>;
+    submitJson: CommonAddressFieldsTypes;
+    displayJson: CommonAddressFieldsTypesDisplay;
+    dtoName: string;
+    isValidJson: import("libs/shared/types/common-types").FieldObject<boolean>;
+    fieldError: import("libs/shared/types/common-types").FieldObject<string>;
+    helperText: import("libs/shared/types/common-types").FieldObject<string | number>;
+    menuTextColor?: import("libs/shared/enums/common-enums").MenuTextColorEnum;
+    initialArgs?: unknown[];
+};
+export type SingleAddressDTOType = ReturnType<typeof SingleAddressDTO>;
+export {};
+//# sourceMappingURL=singleAddressDto.d.ts.map

package/dist/libs/shared/components/singleAddress/singleAddressDto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"singleAddressDto.d.ts","sourceRoot":"","sources":["../../../../../src/libs/shared/components/singleAddress/singleAddressDto.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,wBAAwB,EAAE,+BAA+B,EAAE,gBAAgB,EAAO,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAGrJ,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;CAI/B,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAC7E,KAAK,4BAA4B,GAAG,OAAO,CAAC,YAAY,CAAC,uBAAuB,CAAC,EAAG,eAAe,GAAG,IAAI,GAAG,YAAY,CAAC,CAAC;AAE3H,eAAO,MAAM,gBAAgB,GAAI,uBAAsB,OAAc,EAAE,UAAS,MAAgC;;;;;;;;;;;;;;;;gBAkEvG,wBAAwB;iBAGb,+BAA+B;;;;;;;CAGlD,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC"}