// package: akkaserverless.component
// file: akkaserverless/component/component.proto

/* tslint:disable */
/* eslint-disable */

import * as jspb from "google-protobuf";
import * as google_protobuf_any_pb from "google-protobuf/google/protobuf/any_pb";
import * as google_protobuf_descriptor_pb from "google-protobuf/google/protobuf/descriptor_pb";

export class Metadata extends jspb.Message { 
    clearEntriesList(): void;
    getEntriesList(): Array<MetadataEntry>;
    setEntriesList(value: Array<MetadataEntry>): Metadata;
    addEntries(value?: MetadataEntry, index?: number): MetadataEntry;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): Metadata.AsObject;
    static toObject(includeInstance: boolean, msg: Metadata): Metadata.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: Metadata, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): Metadata;
    static deserializeBinaryFromReader(message: Metadata, reader: jspb.BinaryReader): Metadata;
}

export namespace Metadata {
    export type AsObject = {
        entriesList: Array<MetadataEntry.AsObject>,
    }
}

export class MetadataEntry extends jspb.Message { 
    getKey(): string;
    setKey(value: string): MetadataEntry;

    hasStringValue(): boolean;
    clearStringValue(): void;
    getStringValue(): string;
    setStringValue(value: string): MetadataEntry;

    hasBytesValue(): boolean;
    clearBytesValue(): void;
    getBytesValue(): Uint8Array | string;
    getBytesValue_asU8(): Uint8Array;
    getBytesValue_asB64(): string;
    setBytesValue(value: Uint8Array | string): MetadataEntry;

    getValueCase(): MetadataEntry.ValueCase;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): MetadataEntry.AsObject;
    static toObject(includeInstance: boolean, msg: MetadataEntry): MetadataEntry.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: MetadataEntry, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): MetadataEntry;
    static deserializeBinaryFromReader(message: MetadataEntry, reader: jspb.BinaryReader): MetadataEntry;
}

export namespace MetadataEntry {
    export type AsObject = {
        key: string,
        stringValue: string,
        bytesValue: Uint8Array | string,
    }

    export enum ValueCase {
        VALUE_NOT_SET = 0,
        STRING_VALUE = 2,
        BYTES_VALUE = 3,
    }

}

export class Reply extends jspb.Message { 

    hasPayload(): boolean;
    clearPayload(): void;
    getPayload(): google_protobuf_any_pb.Any | undefined;
    setPayload(value?: google_protobuf_any_pb.Any): Reply;

    hasMetadata(): boolean;
    clearMetadata(): void;
    getMetadata(): Metadata | undefined;
    setMetadata(value?: Metadata): Reply;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): Reply.AsObject;
    static toObject(includeInstance: boolean, msg: Reply): Reply.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: Reply, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): Reply;
    static deserializeBinaryFromReader(message: Reply, reader: jspb.BinaryReader): Reply;
}

export namespace Reply {
    export type AsObject = {
        payload?: google_protobuf_any_pb.Any.AsObject,
        metadata?: Metadata.AsObject,
    }
}

export class Forward extends jspb.Message { 
    getServiceName(): string;
    setServiceName(value: string): Forward;
    getCommandName(): string;
    setCommandName(value: string): Forward;

    hasPayload(): boolean;
    clearPayload(): void;
    getPayload(): google_protobuf_any_pb.Any | undefined;
    setPayload(value?: google_protobuf_any_pb.Any): Forward;

    hasMetadata(): boolean;
    clearMetadata(): void;
    getMetadata(): Metadata | undefined;
    setMetadata(value?: Metadata): Forward;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): Forward.AsObject;
    static toObject(includeInstance: boolean, msg: Forward): Forward.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: Forward, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): Forward;
    static deserializeBinaryFromReader(message: Forward, reader: jspb.BinaryReader): Forward;
}

export namespace Forward {
    export type AsObject = {
        serviceName: string,
        commandName: string,
        payload?: google_protobuf_any_pb.Any.AsObject,
        metadata?: Metadata.AsObject,
    }
}

export class ClientAction extends jspb.Message { 

    hasReply(): boolean;
    clearReply(): void;
    getReply(): Reply | undefined;
    setReply(value?: Reply): ClientAction;

    hasForward(): boolean;
    clearForward(): void;
    getForward(): Forward | undefined;
    setForward(value?: Forward): ClientAction;

    hasFailure(): boolean;
    clearFailure(): void;
    getFailure(): Failure | undefined;
    setFailure(value?: Failure): ClientAction;

    getActionCase(): ClientAction.ActionCase;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ClientAction.AsObject;
    static toObject(includeInstance: boolean, msg: ClientAction): ClientAction.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ClientAction, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ClientAction;
    static deserializeBinaryFromReader(message: ClientAction, reader: jspb.BinaryReader): ClientAction;
}

export namespace ClientAction {
    export type AsObject = {
        reply?: Reply.AsObject,
        forward?: Forward.AsObject,
        failure?: Failure.AsObject,
    }

    export enum ActionCase {
        ACTION_NOT_SET = 0,
        REPLY = 1,
        FORWARD = 2,
        FAILURE = 3,
    }

}

export class SideEffect extends jspb.Message { 
    getServiceName(): string;
    setServiceName(value: string): SideEffect;
    getCommandName(): string;
    setCommandName(value: string): SideEffect;

    hasPayload(): boolean;
    clearPayload(): void;
    getPayload(): google_protobuf_any_pb.Any | undefined;
    setPayload(value?: google_protobuf_any_pb.Any): SideEffect;
    getSynchronous(): boolean;
    setSynchronous(value: boolean): SideEffect;

    hasMetadata(): boolean;
    clearMetadata(): void;
    getMetadata(): Metadata | undefined;
    setMetadata(value?: Metadata): SideEffect;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): SideEffect.AsObject;
    static toObject(includeInstance: boolean, msg: SideEffect): SideEffect.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: SideEffect, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): SideEffect;
    static deserializeBinaryFromReader(message: SideEffect, reader: jspb.BinaryReader): SideEffect;
}

export namespace SideEffect {
    export type AsObject = {
        serviceName: string,
        commandName: string,
        payload?: google_protobuf_any_pb.Any.AsObject,
        synchronous: boolean,
        metadata?: Metadata.AsObject,
    }
}

export class StreamCancelled extends jspb.Message { 
    getComponentId(): string;
    setComponentId(value: string): StreamCancelled;
    getId(): number;
    setId(value: number): StreamCancelled;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): StreamCancelled.AsObject;
    static toObject(includeInstance: boolean, msg: StreamCancelled): StreamCancelled.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: StreamCancelled, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): StreamCancelled;
    static deserializeBinaryFromReader(message: StreamCancelled, reader: jspb.BinaryReader): StreamCancelled;
}

export namespace StreamCancelled {
    export type AsObject = {
        componentId: string,
        id: number,
    }
}

export class Failure extends jspb.Message { 
    getCommandId(): number;
    setCommandId(value: number): Failure;
    getDescription(): string;
    setDescription(value: string): Failure;
    getRestart(): boolean;
    setRestart(value: boolean): Failure;
    getGrpcStatusCode(): number;
    setGrpcStatusCode(value: number): Failure;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): Failure.AsObject;
    static toObject(includeInstance: boolean, msg: Failure): Failure.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: Failure, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): Failure;
    static deserializeBinaryFromReader(message: Failure, reader: jspb.BinaryReader): Failure;
}

export namespace Failure {
    export type AsObject = {
        commandId: number,
        description: string,
        restart: boolean,
        grpcStatusCode: number,
    }
}