How to use the clime.ExpectedError function in clime

async execute(options: CommandOptions) {
        let bytes;
        try {
            bytes = OptionsResolver(options,
                'bytes',
                () => { return ''; },
                'Enter a hexadecimal bytes list: ');
        } catch (err) {
            console.log(options);
            throw new ExpectedError('Enter a valid input');
        }

        // Transaction byte size data
        const sizeLength        = 8;
        const signatureLength   = 128;
        const publicKeyLength   = 64;
        const versionLength     = 4;
        const typeLength        = 4;
        const feeLength         = 16;
        const deadlineLength    = 16;

        // Transaction byte data positions
        const signatureOffset = sizeLength;
        const publicKeyOffset = signatureOffset + signatureLength;
        const versionOffset = publicKeyOffset + publicKeyLength;
        const typeOffset = versionOffset + versionLength;

async execute(options: CommandOptions) {
        await this.setupConfig();

        let numCosig;
        try {
            numCosig = OptionsResolver(options, 'numCosig', () => { return ''; },
                'Enter a maximum number of cosignatories: ');
            numCosig = parseInt(numCosig);
        } catch (err) {
            throw new ExpectedError('Enter a valid maximum number of cosignatories');
        }

        // add a block monitor
        this.monitorBlocks();
        return await this.createMultisigTransfer(numCosig);
    }

validate(value: string, context?: ValidationContext): void {
        if (value.length !== 64 || !/^[0-9a-fA-F]+$/.test(value)) {
            throw new ExpectedError('Public key should be a 64 characters hexadecimal string');
        }
    }
}

peerUrl = OptionsResolver(options,
                'peerUrl',
                () => { return ''; },
                'Enter a peerUrl: (Ex.: http://localhost:3000)');

            namespaceName = OptionsResolver(options,
                'namespaceName',
                () => { return ''; },
                'Enter a namespaceName: (Ex.: evias)');

            if (!namespaceName.length) {
                throw new Error("Namespace name is obligatory");
            }
        } catch (err) {
            console.log(options);
            throw new ExpectedError('Enter a valid input');
        }

        if (peerUrl.length) {
            this.endpointUrl = peerUrl;
        }

        const namespaceHttp = new NamespaceHttp(this.endpointUrl);

        let text = '';
        text += chalk.green('Peer:\t') + chalk.bold(this.endpointUrl) + '\n';
        text += '-'.repeat(20) + '\n\n';

        const namespaceId = new NamespaceId(namespaceName);
        const observer = namespaceHttp.getLinkedAddress(namespaceId).subscribe((apiResponses) => {

            let address = apiResponses as Address;

static validate(value: string) {
        const mosaicParts = value.split('::');
        let valid = true;
        try {
            if (isNaN(+mosaicParts[1])) {
                valid = false;
            }
            const ignored = new Mosaic(this.getMosaicId(mosaicParts[0]),
                UInt64.fromUint(+mosaicParts[1]));
        } catch (err) {
            valid = false;
        }
        if (!valid) {
            throw new ExpectedError('Mosaic should be in the format (mosaicId(hex)|@aliasName)::absoluteAmount,' +
                ' (Ex: sending 1 cat.currency, @cat.currency::1000000)');
        }
    }

validate(value: string, context?: ValidationContext): void {
        try {
             const ignored = new Password(value);
         } catch (error) {
              throw new ExpectedError('Password should have a minimum of 8 characters');
         }
     }
}

validate(value: number, context?: ValidationContext): void {
        if (value !== 0 && value !== 1) {
            throw new ExpectedError('The value must be 0 or 1');
        }
    }
}

validate(value: string, context?: ValidationContext): void {
        try {
            const ignored = new MosaicId(value);
        } catch (err) {
            throw new ExpectedError('Enter a mosaic id in hexadecimal format. Example: 941299B2B7E1291C');
        }
    }
}

validate(value: string, context?: ValidationContext): void {
        let valid = true;
        if (value === '0') {
            valid = false;
        }
        try {
            UInt64.fromNumericString(value);
        } catch (e) {
            valid = false;
        }
        if (!valid) {
            throw new ExpectedError('The block height must be a positive integer');
        }
    }
}

private readAccount(addressOrPub: string): Address
    {
        if (addressOrPub.length === 40) {
            return Address.createFromRawAddress(addressOrPub);
        }
        else if (addressOrPub.length === 64) {
            return Address.createFromPublicKey(addressOrPub, NetworkType.MIJIN_TEST);
        }

        throw new ExpectedError("parameter addressOrPub must be either of 40 or 64 characters.");
    }