How to use the @creditkarma/thrift-server-core.TType function in @creditkarma/thrift-server-core

public static read(input: thrift.TProtocol): Endpoint {
        input.readStructBegin();
        let _args: any = {};
        while (true) {
            const ret: thrift.IThriftField = input.readFieldBegin();
            const fieldType: thrift.TType = ret.fieldType;
            const fieldId: number = ret.fieldId;
            if (fieldType === thrift.TType.STOP) {
                break;
            }
            switch (fieldId) {
                case 1:
                    if (fieldType === thrift.TType.I32) {
                        const value_1: number = input.readI32();
                        _args.ipv4 = value_1;
                    }
                    else {
                        input.skip(fieldType);
                    }
                    break;
                case 2:
                    if (fieldType === thrift.TType.I16) {
                        const value_2: number = input.readI16();
                        _args.port = value_2;

encode(args: IResponseHeaderArgs, output: thrift.TProtocol): void {
        const obj = {
            spans: args.spans,
            contexts: args.contexts
        };
        output.writeStructBegin("ResponseHeader");
        if (obj.spans != null) {
            output.writeFieldBegin("spans", thrift.TType.LIST, 1);
            output.writeListBegin(thrift.TType.STRUCT, obj.spans.length);
            obj.spans.forEach((value_79: ISpanArgs): void => {
                SpanCodec.encode(value_79, output);
            });
            output.writeListEnd();
            output.writeFieldEnd();
        }
        if (obj.contexts != null) {
            output.writeFieldBegin("contexts", thrift.TType.LIST, 2);
            output.writeListBegin(thrift.TType.STRUCT, obj.contexts.length);
            obj.contexts.forEach((value_80: IRequestContextArgs): void => {
                RequestContextCodec.encode(value_80, output);
            });
            output.writeListEnd();
            output.writeFieldEnd();
        }

const value_3: Array = new Array();
                        const metadata_1: thrift.IThriftList = input.readListBegin();
                        const size_1: number = metadata_1.size;
                        for (let i_1: number = 0; i_1 < size_1; i_1++) {
                            const value_4: Span.ISpan = Span.SpanCodec.decode(input);
                            value_3.push(value_4);
                        }
                        input.readListEnd();
                        _args.spans = value_3;
                    }
                    else {
                        input.skip(fieldType);
                    }
                    break;
                case 2:
                    if (fieldType === thrift.TType.LIST) {
                        const value_5: Array = new Array();
                        const metadata_2: thrift.IThriftList = input.readListBegin();
                        const size_2: number = metadata_2.size;
                        for (let i_2: number = 0; i_2 < size_2; i_2++) {
                            const value_6: RequestContext.IRequestContext = RequestContext.RequestContextCodec.decode(input);
                            value_5.push(value_6);
                        }
                        input.readListEnd();
                        _args.contexts = value_5;
                    }
                    else {
                        input.skip(fieldType);
                    }
                    break;
                default: {
                    input.skip(fieldType);

const fieldId: number = ret.fieldId;
            if (fieldType === thrift.TType.STOP) {
                break;
            }
            switch (fieldId) {
                case 1:
                    if (fieldType === thrift.TType.STRING) {
                        const value_1: string = input.readString();
                        _args.src = value_1;
                    }
                    else {
                        input.skip(fieldType);
                    }
                    break;
                case 2:
                    if (fieldType === thrift.TType.STRING) {
                        const value_2: string = input.readString();
                        _args.dst = value_2;
                    }
                    else {
                        input.skip(fieldType);
                    }
                    break;
                default: {
                    input.skip(fieldType);
                }
            }
            input.readFieldEnd();
        }
        input.readStructEnd();
        return {
            src: _args.src,

}
                    else {
                        input.skip(fieldType);
                    }
                    break;
                case 9:
                    if (fieldType === thrift.TType.STRING) {
                        const value_37: string = input.readString();
                        _args.dest = value_37;
                    }
                    else {
                        input.skip(fieldType);
                    }
                    break;
                case 10:
                    if (fieldType === thrift.TType.LIST) {
                        const value_38: Array = new Array();
                        const metadata_4: thrift.IThriftList = input.readListBegin();
                        const size_4: number = metadata_4.size;
                        for (let i_4: number = 0; i_4 < size_4; i_4++) {
                            const value_39: Delegation = Delegation.read(input);
                            value_38.push(value_39);
                        }
                        input.readListEnd();
                        _args.delegations = value_38;
                    }
                    else {
                        input.skip(fieldType);
                    }
                    break;
                case 11:
                    if (fieldType === thrift.TType.I64) {

decode(input: thrift.TProtocol): IResponseHeader {
        let _args: any = {};
        input.readStructBegin();
        while (true) {
            const ret: thrift.IThriftField = input.readFieldBegin();
            const fieldType: thrift.TType = ret.fieldType;
            const fieldId: number = ret.fieldId;
            if (fieldType === thrift.TType.STOP) {
                break;
            }
            switch (fieldId) {
                case 1:
                    if (fieldType === thrift.TType.LIST) {
                        const value_81: Array = new Array();
                        const metadata_5: thrift.IThriftList = input.readListBegin();
                        const size_5: number = metadata_5.size;
                        for (let i_5: number = 0; i_5 < size_5; i_5++) {
                            const value_82: ISpan = SpanCodec.decode(input);
                            value_81.push(value_82);
                        }
                        input.readListEnd();
                        _args.spans = value_81;
                    }
                    else {

decode(input: thrift.TProtocol): IUpgradeReply {
        input.readStructBegin();
        while (true) {
            const ret: thrift.IThriftField = input.readFieldBegin();
            const fieldType: thrift.TType = ret.fieldType;
            const fieldId: number = ret.fieldId;
            if (fieldType === thrift.TType.STOP) {
                break;
            }
            switch (fieldId) {
                default: {
                    input.skip(fieldType);
                }
            }
            input.readFieldEnd();
        }
        input.readStructEnd();
        return {};
    }
};

public write(output: thrift.TProtocol): void {
        output.writeStructBegin("ResponseHeader");
        if (this.spans != null) {
            output.writeFieldBegin("spans", thrift.TType.LIST, 1);
            output.writeListBegin(thrift.TType.STRUCT, this.spans.length);
            this.spans.forEach((value_41: Span): void => {
                value_41.write(output);
            });
            output.writeListEnd();
            output.writeFieldEnd();
        }
        if (this.contexts != null) {
            output.writeFieldBegin("contexts", thrift.TType.LIST, 2);
            output.writeListBegin(thrift.TType.STRUCT, this.contexts.length);
            this.contexts.forEach((value_42: RequestContext): void => {
                value_42.write(output);
            });
            output.writeListEnd();
            output.writeFieldEnd();
        }
        output.writeFieldStop();
        output.writeStructEnd();
        return;
    }
    public static read(input: thrift.TProtocol): ResponseHeader {

decode(input: thrift.TProtocol): IConnectionOptions {
        input.readStructBegin();
        while (true) {
            const ret: thrift.IThriftField = input.readFieldBegin();
            const fieldType: thrift.TType = ret.fieldType;
            const fieldId: number = ret.fieldId;
            if (fieldType === thrift.TType.STOP) {
                break;
            }
            switch (fieldId) {
                default: {
                    input.skip(fieldType);
                }
            }
            input.readFieldEnd();
        }
        input.readStructEnd();
        return {};
    }
};

parent_span_id: (typeof args.parent_span_id === "number" ? new thrift.Int64(args.parent_span_id) : typeof args.parent_span_id === "string" ? thrift.Int64.fromDecimalString(args.parent_span_id) : args.parent_span_id),
            sampled: args.sampled,
            client_id: args.client_id,
            flags: (typeof args.flags === "number" ? new thrift.Int64(args.flags) : typeof args.flags === "string" ? thrift.Int64.fromDecimalString(args.flags) : args.flags),
            contexts: args.contexts,
            dest: args.dest,
            delegations: args.delegations
        };
        output.writeStructBegin("RequestHeader");
        if (obj.trace_id != null) {
            output.writeFieldBegin("trace_id", thrift.TType.I64, 1);
            output.writeI64((typeof obj.trace_id === "number" ? new thrift.Int64(obj.trace_id) : typeof obj.trace_id === "string" ? thrift.Int64.fromDecimalString(obj.trace_id) : obj.trace_id));
            output.writeFieldEnd();
        }
        if (obj.span_id != null) {
            output.writeFieldBegin("span_id", thrift.TType.I64, 2);
            output.writeI64((typeof obj.span_id === "number" ? new thrift.Int64(obj.span_id) : typeof obj.span_id === "string" ? thrift.Int64.fromDecimalString(obj.span_id) : obj.span_id));
            output.writeFieldEnd();
        }
        if (obj.parent_span_id != null) {
            output.writeFieldBegin("parent_span_id", thrift.TType.I64, 3);
            output.writeI64((typeof obj.parent_span_id === "number" ? new thrift.Int64(obj.parent_span_id) : typeof obj.parent_span_id === "string" ? thrift.Int64.fromDecimalString(obj.parent_span_id) : obj.parent_span_id));
            output.writeFieldEnd();
        }
        if (obj.sampled != null) {
            output.writeFieldBegin("sampled", thrift.TType.BOOL, 5);
            output.writeBool(obj.sampled);
            output.writeFieldEnd();
        }
        if (obj.client_id != null) {
            output.writeFieldBegin("client_id", thrift.TType.STRUCT, 6);
            ClientId.ClientIdCodec.encode(obj.client_id, output);