@lightbend/akkaserverless-javascript-sdk/test/proto/akkaserverless/protocol/discovery_pb.d.ts

Akka Serverless JavaScript SDK

// package: akkaserverless.protocol
// file: akkaserverless/protocol/discovery.proto

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

import * as jspb from "google-protobuf";
import * as google_protobuf_descriptor_pb from "google-protobuf/google/protobuf/descriptor_pb";
import * as google_protobuf_empty_pb from "google-protobuf/google/protobuf/empty_pb";

export class Spec extends jspb.Message { 
    getProto(): Uint8Array | string;
    getProto_asU8(): Uint8Array;
    getProto_asB64(): string;
    setProto(value: Uint8Array | string): Spec;
    clearComponentsList(): void;
    getComponentsList(): Array<Component>;
    setComponentsList(value: Array<Component>): Spec;
    addComponents(value?: Component, index?: number): Component;

    hasServiceInfo(): boolean;
    clearServiceInfo(): void;
    getServiceInfo(): ServiceInfo | undefined;
    setServiceInfo(value?: ServiceInfo): Spec;

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

export namespace Spec {
    export type AsObject = {
        proto: Uint8Array | string,
        componentsList: Array<Component.AsObject>,
        serviceInfo?: ServiceInfo.AsObject,
    }
}

export class ServiceInfo extends jspb.Message { 
    getServiceName(): string;
    setServiceName(value: string): ServiceInfo;
    getServiceVersion(): string;
    setServiceVersion(value: string): ServiceInfo;
    getServiceRuntime(): string;
    setServiceRuntime(value: string): ServiceInfo;
    getSupportLibraryName(): string;
    setSupportLibraryName(value: string): ServiceInfo;
    getSupportLibraryVersion(): string;
    setSupportLibraryVersion(value: string): ServiceInfo;
    getProtocolMajorVersion(): number;
    setProtocolMajorVersion(value: number): ServiceInfo;
    getProtocolMinorVersion(): number;
    setProtocolMinorVersion(value: number): ServiceInfo;

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

export namespace ServiceInfo {
    export type AsObject = {
        serviceName: string,
        serviceVersion: string,
        serviceRuntime: string,
        supportLibraryName: string,
        supportLibraryVersion: string,
        protocolMajorVersion: number,
        protocolMinorVersion: number,
    }
}

export class Component extends jspb.Message { 
    getComponentType(): string;
    setComponentType(value: string): Component;
    getServiceName(): string;
    setServiceName(value: string): Component;

    hasEntity(): boolean;
    clearEntity(): void;
    getEntity(): EntitySettings | undefined;
    setEntity(value?: EntitySettings): Component;

    hasComponent(): boolean;
    clearComponent(): void;
    getComponent(): GenericComponentSettings | undefined;
    setComponent(value?: GenericComponentSettings): Component;

    getComponentSettingsCase(): Component.ComponentSettingsCase;

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

export namespace Component {
    export type AsObject = {
        componentType: string,
        serviceName: string,
        entity?: EntitySettings.AsObject,
        component?: GenericComponentSettings.AsObject,
    }

    export enum ComponentSettingsCase {
        COMPONENT_SETTINGS_NOT_SET = 0,
        ENTITY = 3,
        COMPONENT = 4,
    }

}

export class GenericComponentSettings extends jspb.Message { 
    clearForwardHeadersList(): void;
    getForwardHeadersList(): Array<string>;
    setForwardHeadersList(value: Array<string>): GenericComponentSettings;
    addForwardHeaders(value: string, index?: number): string;

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

export namespace GenericComponentSettings {
    export type AsObject = {
        forwardHeadersList: Array<string>,
    }
}

export class EntitySettings extends jspb.Message { 
    getEntityType(): string;
    setEntityType(value: string): EntitySettings;

    hasPassivationStrategy(): boolean;
    clearPassivationStrategy(): void;
    getPassivationStrategy(): PassivationStrategy | undefined;
    setPassivationStrategy(value?: PassivationStrategy): EntitySettings;
    clearForwardHeadersList(): void;
    getForwardHeadersList(): Array<string>;
    setForwardHeadersList(value: Array<string>): EntitySettings;
    addForwardHeaders(value: string, index?: number): string;

    hasReplicatedEntity(): boolean;
    clearReplicatedEntity(): void;
    getReplicatedEntity(): ReplicatedEntitySettings | undefined;
    setReplicatedEntity(value?: ReplicatedEntitySettings): EntitySettings;

    getSpecificSettingsCase(): EntitySettings.SpecificSettingsCase;

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

export namespace EntitySettings {
    export type AsObject = {
        entityType: string,
        passivationStrategy?: PassivationStrategy.AsObject,
        forwardHeadersList: Array<string>,
        replicatedEntity?: ReplicatedEntitySettings.AsObject,
    }

    export enum SpecificSettingsCase {
        SPECIFIC_SETTINGS_NOT_SET = 0,
        REPLICATED_ENTITY = 6,
    }

}

export class PassivationStrategy extends jspb.Message { 

    hasTimeout(): boolean;
    clearTimeout(): void;
    getTimeout(): TimeoutPassivationStrategy | undefined;
    setTimeout(value?: TimeoutPassivationStrategy): PassivationStrategy;

    getStrategyCase(): PassivationStrategy.StrategyCase;

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

export namespace PassivationStrategy {
    export type AsObject = {
        timeout?: TimeoutPassivationStrategy.AsObject,
    }

    export enum StrategyCase {
        STRATEGY_NOT_SET = 0,
        TIMEOUT = 1,
    }

}

export class TimeoutPassivationStrategy extends jspb.Message { 
    getTimeout(): number;
    setTimeout(value: number): TimeoutPassivationStrategy;

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

export namespace TimeoutPassivationStrategy {
    export type AsObject = {
        timeout: number,
    }
}

export class ReplicatedEntitySettings extends jspb.Message { 
    getWriteConsistency(): ReplicatedWriteConsistency;
    setWriteConsistency(value: ReplicatedWriteConsistency): ReplicatedEntitySettings;

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

export namespace ReplicatedEntitySettings {
    export type AsObject = {
        writeConsistency: ReplicatedWriteConsistency,
    }
}

export class UserFunctionError extends jspb.Message { 
    getMessage(): string;
    setMessage(value: string): UserFunctionError;
    getCode(): string;
    setCode(value: string): UserFunctionError;
    getDetail(): string;
    setDetail(value: string): UserFunctionError;
    clearSourceLocationsList(): void;
    getSourceLocationsList(): Array<UserFunctionError.SourceLocation>;
    setSourceLocationsList(value: Array<UserFunctionError.SourceLocation>): UserFunctionError;
    addSourceLocations(value?: UserFunctionError.SourceLocation, index?: number): UserFunctionError.SourceLocation;

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

export namespace UserFunctionError {
    export type AsObject = {
        message: string,
        code: string,
        detail: string,
        sourceLocationsList: Array<UserFunctionError.SourceLocation.AsObject>,
    }


    export class SourceLocation extends jspb.Message { 
        getFileName(): string;
        setFileName(value: string): SourceLocation;
        getStartLine(): number;
        setStartLine(value: number): SourceLocation;
        getStartCol(): number;
        setStartCol(value: number): SourceLocation;
        getEndLine(): number;
        setEndLine(value: number): SourceLocation;
        getEndCol(): number;
        setEndCol(value: number): SourceLocation;
        clearProtoPathList(): void;
        getProtoPathList(): Array<number>;
        setProtoPathList(value: Array<number>): SourceLocation;
        addProtoPath(value: number, index?: number): number;

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

    export namespace SourceLocation {
        export type AsObject = {
            fileName: string,
            startLine: number,
            startCol: number,
            endLine: number,
            endCol: number,
            protoPathList: Array<number>,
        }
    }

}

export class ProxyInfo extends jspb.Message { 
    getProtocolMajorVersion(): number;
    setProtocolMajorVersion(value: number): ProxyInfo;
    getProtocolMinorVersion(): number;
    setProtocolMinorVersion(value: number): ProxyInfo;
    getProxyName(): string;
    setProxyName(value: string): ProxyInfo;
    getProxyVersion(): string;
    setProxyVersion(value: string): ProxyInfo;
    clearSupportedEntityTypesList(): void;
    getSupportedEntityTypesList(): Array<string>;
    setSupportedEntityTypesList(value: Array<string>): ProxyInfo;
    addSupportedEntityTypes(value: string, index?: number): string;
    getDevMode(): boolean;
    setDevMode(value: boolean): ProxyInfo;
    getDeploymentName(): string;
    setDeploymentName(value: string): ProxyInfo;

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

export namespace ProxyInfo {
    export type AsObject = {
        protocolMajorVersion: number,
        protocolMinorVersion: number,
        proxyName: string,
        proxyVersion: string,
        supportedEntityTypesList: Array<string>,
        devMode: boolean,
        deploymentName: string,
    }
}

export enum ReplicatedWriteConsistency {
    REPLICATED_WRITE_CONSISTENCY_LOCAL_UNSPECIFIED = 0,
    REPLICATED_WRITE_CONSISTENCY_MAJORITY = 1,
    REPLICATED_WRITE_CONSISTENCY_ALL = 2,
}