@alis-build/ideate 1.945.974 → 1.945.975

package/alis/ideate/agent_card_pb.d.ts

@@ -0,0 +1,740 @@
+import * as jspb from 'google-protobuf'
+
+import * as google_api_annotations_pb from '@alis-build/google-common-protos/google/api/annotations_pb'; // proto import: "google/api/annotations.proto"
+import * as google_api_client_pb from '@alis-build/google-common-protos/google/api/client_pb'; // proto import: "google/api/client.proto"
+import * as google_api_field_behavior_pb from '@alis-build/google-common-protos/google/api/field_behavior_pb'; // proto import: "google/api/field_behavior.proto"
+import * as google_protobuf_empty_pb from 'google-protobuf/google/protobuf/empty_pb'; // proto import: "google/protobuf/empty.proto"
+import * as google_protobuf_struct_pb from 'google-protobuf/google/protobuf/struct_pb'; // proto import: "google/protobuf/struct.proto"
+import * as google_protobuf_timestamp_pb from 'google-protobuf/google/protobuf/timestamp_pb'; // proto import: "google/protobuf/timestamp.proto"
+
+
+export class AgentInterface extends jspb.Message {
+  getUrl(): string;
+  setUrl(value: string): AgentInterface;
+
+  getProtocolBinding(): string;
+  setProtocolBinding(value: string): AgentInterface;
+
+  getTenant(): string;
+  setTenant(value: string): AgentInterface;
+
+  getProtocolVersion(): string;
+  setProtocolVersion(value: string): AgentInterface;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): AgentInterface.AsObject;
+  static toObject(includeInstance: boolean, msg: AgentInterface): AgentInterface.AsObject;
+  static serializeBinaryToWriter(message: AgentInterface, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): AgentInterface;
+  static deserializeBinaryFromReader(message: AgentInterface, reader: jspb.BinaryReader): AgentInterface;
+}
+
+export namespace AgentInterface {
+  export type AsObject = {
+    url: string,
+    protocolBinding: string,
+    tenant: string,
+    protocolVersion: string,
+  }
+}
+
+export class AgentCard extends jspb.Message {
+  getName(): string;
+  setName(value: string): AgentCard;
+
+  getDescription(): string;
+  setDescription(value: string): AgentCard;
+
+  getSupportedInterfacesList(): Array<AgentInterface>;
+  setSupportedInterfacesList(value: Array<AgentInterface>): AgentCard;
+  clearSupportedInterfacesList(): AgentCard;
+  addSupportedInterfaces(value?: AgentInterface, index?: number): AgentInterface;
+
+  getProvider(): AgentProvider | undefined;
+  setProvider(value?: AgentProvider): AgentCard;
+  hasProvider(): boolean;
+  clearProvider(): AgentCard;
+
+  getVersion(): string;
+  setVersion(value: string): AgentCard;
+
+  getDocumentationUrl(): string;
+  setDocumentationUrl(value: string): AgentCard;
+  hasDocumentationUrl(): boolean;
+  clearDocumentationUrl(): AgentCard;
+
+  getCapabilities(): AgentCapabilities | undefined;
+  setCapabilities(value?: AgentCapabilities): AgentCard;
+  hasCapabilities(): boolean;
+  clearCapabilities(): AgentCard;
+
+  getSecuritySchemesMap(): jspb.Map<string, SecurityScheme>;
+  clearSecuritySchemesMap(): AgentCard;
+
+  getSecurityRequirementsList(): Array<SecurityRequirement>;
+  setSecurityRequirementsList(value: Array<SecurityRequirement>): AgentCard;
+  clearSecurityRequirementsList(): AgentCard;
+  addSecurityRequirements(value?: SecurityRequirement, index?: number): SecurityRequirement;
+
+  getDefaultInputModesList(): Array<string>;
+  setDefaultInputModesList(value: Array<string>): AgentCard;
+  clearDefaultInputModesList(): AgentCard;
+  addDefaultInputModes(value: string, index?: number): AgentCard;
+
+  getDefaultOutputModesList(): Array<string>;
+  setDefaultOutputModesList(value: Array<string>): AgentCard;
+  clearDefaultOutputModesList(): AgentCard;
+  addDefaultOutputModes(value: string, index?: number): AgentCard;
+
+  getSkillsList(): Array<AgentSkill>;
+  setSkillsList(value: Array<AgentSkill>): AgentCard;
+  clearSkillsList(): AgentCard;
+  addSkills(value?: AgentSkill, index?: number): AgentSkill;
+
+  getSignaturesList(): Array<AgentCardSignature>;
+  setSignaturesList(value: Array<AgentCardSignature>): AgentCard;
+  clearSignaturesList(): AgentCard;
+  addSignatures(value?: AgentCardSignature, index?: number): AgentCardSignature;
+
+  getIconUrl(): string;
+  setIconUrl(value: string): AgentCard;
+  hasIconUrl(): boolean;
+  clearIconUrl(): AgentCard;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): AgentCard.AsObject;
+  static toObject(includeInstance: boolean, msg: AgentCard): AgentCard.AsObject;
+  static serializeBinaryToWriter(message: AgentCard, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): AgentCard;
+  static deserializeBinaryFromReader(message: AgentCard, reader: jspb.BinaryReader): AgentCard;
+}
+
+export namespace AgentCard {
+  export type AsObject = {
+    name: string,
+    description: string,
+    supportedInterfacesList: Array<AgentInterface.AsObject>,
+    provider?: AgentProvider.AsObject,
+    version: string,
+    documentationUrl?: string,
+    capabilities?: AgentCapabilities.AsObject,
+    securitySchemesMap: Array<[string, SecurityScheme.AsObject]>,
+    securityRequirementsList: Array<SecurityRequirement.AsObject>,
+    defaultInputModesList: Array<string>,
+    defaultOutputModesList: Array<string>,
+    skillsList: Array<AgentSkill.AsObject>,
+    signaturesList: Array<AgentCardSignature.AsObject>,
+    iconUrl?: string,
+  }
+
+  export enum DocumentationUrlCase { 
+    _DOCUMENTATION_URL_NOT_SET = 0,
+    DOCUMENTATION_URL = 6,
+  }
+
+  export enum IconUrlCase { 
+    _ICON_URL_NOT_SET = 0,
+    ICON_URL = 18,
+  }
+}
+
+export class AgentProvider extends jspb.Message {
+  getUrl(): string;
+  setUrl(value: string): AgentProvider;
+
+  getOrganization(): string;
+  setOrganization(value: string): AgentProvider;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): AgentProvider.AsObject;
+  static toObject(includeInstance: boolean, msg: AgentProvider): AgentProvider.AsObject;
+  static serializeBinaryToWriter(message: AgentProvider, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): AgentProvider;
+  static deserializeBinaryFromReader(message: AgentProvider, reader: jspb.BinaryReader): AgentProvider;
+}
+
+export namespace AgentProvider {
+  export type AsObject = {
+    url: string,
+    organization: string,
+  }
+}
+
+export class AgentCapabilities extends jspb.Message {
+  getStreaming(): boolean;
+  setStreaming(value: boolean): AgentCapabilities;
+  hasStreaming(): boolean;
+  clearStreaming(): AgentCapabilities;
+
+  getPushNotifications(): boolean;
+  setPushNotifications(value: boolean): AgentCapabilities;
+  hasPushNotifications(): boolean;
+  clearPushNotifications(): AgentCapabilities;
+
+  getExtensionsList(): Array<AgentExtension>;
+  setExtensionsList(value: Array<AgentExtension>): AgentCapabilities;
+  clearExtensionsList(): AgentCapabilities;
+  addExtensions(value?: AgentExtension, index?: number): AgentExtension;
+
+  getExtendedAgentCard(): boolean;
+  setExtendedAgentCard(value: boolean): AgentCapabilities;
+  hasExtendedAgentCard(): boolean;
+  clearExtendedAgentCard(): AgentCapabilities;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): AgentCapabilities.AsObject;
+  static toObject(includeInstance: boolean, msg: AgentCapabilities): AgentCapabilities.AsObject;
+  static serializeBinaryToWriter(message: AgentCapabilities, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): AgentCapabilities;
+  static deserializeBinaryFromReader(message: AgentCapabilities, reader: jspb.BinaryReader): AgentCapabilities;
+}
+
+export namespace AgentCapabilities {
+  export type AsObject = {
+    streaming?: boolean,
+    pushNotifications?: boolean,
+    extensionsList: Array<AgentExtension.AsObject>,
+    extendedAgentCard?: boolean,
+  }
+
+  export enum StreamingCase { 
+    _STREAMING_NOT_SET = 0,
+    STREAMING = 1,
+  }
+
+  export enum PushNotificationsCase { 
+    _PUSH_NOTIFICATIONS_NOT_SET = 0,
+    PUSH_NOTIFICATIONS = 2,
+  }
+
+  export enum ExtendedAgentCardCase { 
+    _EXTENDED_AGENT_CARD_NOT_SET = 0,
+    EXTENDED_AGENT_CARD = 5,
+  }
+}
+
+export class AgentExtension extends jspb.Message {
+  getUri(): string;
+  setUri(value: string): AgentExtension;
+
+  getDescription(): string;
+  setDescription(value: string): AgentExtension;
+
+  getRequired(): boolean;
+  setRequired(value: boolean): AgentExtension;
+
+  getParams(): google_protobuf_struct_pb.Struct | undefined;
+  setParams(value?: google_protobuf_struct_pb.Struct): AgentExtension;
+  hasParams(): boolean;
+  clearParams(): AgentExtension;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): AgentExtension.AsObject;
+  static toObject(includeInstance: boolean, msg: AgentExtension): AgentExtension.AsObject;
+  static serializeBinaryToWriter(message: AgentExtension, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): AgentExtension;
+  static deserializeBinaryFromReader(message: AgentExtension, reader: jspb.BinaryReader): AgentExtension;
+}
+
+export namespace AgentExtension {
+  export type AsObject = {
+    uri: string,
+    description: string,
+    required: boolean,
+    params?: google_protobuf_struct_pb.Struct.AsObject,
+  }
+}
+
+export class AgentSkill extends jspb.Message {
+  getId(): string;
+  setId(value: string): AgentSkill;
+
+  getName(): string;
+  setName(value: string): AgentSkill;
+
+  getDescription(): string;
+  setDescription(value: string): AgentSkill;
+
+  getTagsList(): Array<string>;
+  setTagsList(value: Array<string>): AgentSkill;
+  clearTagsList(): AgentSkill;
+  addTags(value: string, index?: number): AgentSkill;
+
+  getExamplesList(): Array<string>;
+  setExamplesList(value: Array<string>): AgentSkill;
+  clearExamplesList(): AgentSkill;
+  addExamples(value: string, index?: number): AgentSkill;
+
+  getInputModesList(): Array<string>;
+  setInputModesList(value: Array<string>): AgentSkill;
+  clearInputModesList(): AgentSkill;
+  addInputModes(value: string, index?: number): AgentSkill;
+
+  getOutputModesList(): Array<string>;
+  setOutputModesList(value: Array<string>): AgentSkill;
+  clearOutputModesList(): AgentSkill;
+  addOutputModes(value: string, index?: number): AgentSkill;
+
+  getSecurityRequirementsList(): Array<SecurityRequirement>;
+  setSecurityRequirementsList(value: Array<SecurityRequirement>): AgentSkill;
+  clearSecurityRequirementsList(): AgentSkill;
+  addSecurityRequirements(value?: SecurityRequirement, index?: number): SecurityRequirement;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): AgentSkill.AsObject;
+  static toObject(includeInstance: boolean, msg: AgentSkill): AgentSkill.AsObject;
+  static serializeBinaryToWriter(message: AgentSkill, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): AgentSkill;
+  static deserializeBinaryFromReader(message: AgentSkill, reader: jspb.BinaryReader): AgentSkill;
+}
+
+export namespace AgentSkill {
+  export type AsObject = {
+    id: string,
+    name: string,
+    description: string,
+    tagsList: Array<string>,
+    examplesList: Array<string>,
+    inputModesList: Array<string>,
+    outputModesList: Array<string>,
+    securityRequirementsList: Array<SecurityRequirement.AsObject>,
+  }
+}
+
+export class AgentCardSignature extends jspb.Message {
+  getProtected(): string;
+  setProtected(value: string): AgentCardSignature;
+
+  getSignature(): string;
+  setSignature(value: string): AgentCardSignature;
+
+  getHeader(): google_protobuf_struct_pb.Struct | undefined;
+  setHeader(value?: google_protobuf_struct_pb.Struct): AgentCardSignature;
+  hasHeader(): boolean;
+  clearHeader(): AgentCardSignature;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): AgentCardSignature.AsObject;
+  static toObject(includeInstance: boolean, msg: AgentCardSignature): AgentCardSignature.AsObject;
+  static serializeBinaryToWriter(message: AgentCardSignature, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): AgentCardSignature;
+  static deserializeBinaryFromReader(message: AgentCardSignature, reader: jspb.BinaryReader): AgentCardSignature;
+}
+
+export namespace AgentCardSignature {
+  export type AsObject = {
+    pb_protected: string,
+    signature: string,
+    header?: google_protobuf_struct_pb.Struct.AsObject,
+  }
+}
+
+export class StringList extends jspb.Message {
+  getListList(): Array<string>;
+  setListList(value: Array<string>): StringList;
+  clearListList(): StringList;
+  addList(value: string, index?: number): StringList;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): StringList.AsObject;
+  static toObject(includeInstance: boolean, msg: StringList): StringList.AsObject;
+  static serializeBinaryToWriter(message: StringList, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): StringList;
+  static deserializeBinaryFromReader(message: StringList, reader: jspb.BinaryReader): StringList;
+}
+
+export namespace StringList {
+  export type AsObject = {
+    listList: Array<string>,
+  }
+}
+
+export class SecurityRequirement extends jspb.Message {
+  getSchemesMap(): jspb.Map<string, StringList>;
+  clearSchemesMap(): SecurityRequirement;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): SecurityRequirement.AsObject;
+  static toObject(includeInstance: boolean, msg: SecurityRequirement): SecurityRequirement.AsObject;
+  static serializeBinaryToWriter(message: SecurityRequirement, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): SecurityRequirement;
+  static deserializeBinaryFromReader(message: SecurityRequirement, reader: jspb.BinaryReader): SecurityRequirement;
+}
+
+export namespace SecurityRequirement {
+  export type AsObject = {
+    schemesMap: Array<[string, StringList.AsObject]>,
+  }
+}
+
+export class SecurityScheme extends jspb.Message {
+  getApiKeySecurityScheme(): APIKeySecurityScheme | undefined;
+  setApiKeySecurityScheme(value?: APIKeySecurityScheme): SecurityScheme;
+  hasApiKeySecurityScheme(): boolean;
+  clearApiKeySecurityScheme(): SecurityScheme;
+
+  getHttpAuthSecurityScheme(): HTTPAuthSecurityScheme | undefined;
+  setHttpAuthSecurityScheme(value?: HTTPAuthSecurityScheme): SecurityScheme;
+  hasHttpAuthSecurityScheme(): boolean;
+  clearHttpAuthSecurityScheme(): SecurityScheme;
+
+  getOauth2SecurityScheme(): OAuth2SecurityScheme | undefined;
+  setOauth2SecurityScheme(value?: OAuth2SecurityScheme): SecurityScheme;
+  hasOauth2SecurityScheme(): boolean;
+  clearOauth2SecurityScheme(): SecurityScheme;
+
+  getOpenIdConnectSecurityScheme(): OpenIdConnectSecurityScheme | undefined;
+  setOpenIdConnectSecurityScheme(value?: OpenIdConnectSecurityScheme): SecurityScheme;
+  hasOpenIdConnectSecurityScheme(): boolean;
+  clearOpenIdConnectSecurityScheme(): SecurityScheme;
+
+  getMtlsSecurityScheme(): MutualTlsSecurityScheme | undefined;
+  setMtlsSecurityScheme(value?: MutualTlsSecurityScheme): SecurityScheme;
+  hasMtlsSecurityScheme(): boolean;
+  clearMtlsSecurityScheme(): SecurityScheme;
+
+  getSchemeCase(): SecurityScheme.SchemeCase;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): SecurityScheme.AsObject;
+  static toObject(includeInstance: boolean, msg: SecurityScheme): SecurityScheme.AsObject;
+  static serializeBinaryToWriter(message: SecurityScheme, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): SecurityScheme;
+  static deserializeBinaryFromReader(message: SecurityScheme, reader: jspb.BinaryReader): SecurityScheme;
+}
+
+export namespace SecurityScheme {
+  export type AsObject = {
+    apiKeySecurityScheme?: APIKeySecurityScheme.AsObject,
+    httpAuthSecurityScheme?: HTTPAuthSecurityScheme.AsObject,
+    oauth2SecurityScheme?: OAuth2SecurityScheme.AsObject,
+    openIdConnectSecurityScheme?: OpenIdConnectSecurityScheme.AsObject,
+    mtlsSecurityScheme?: MutualTlsSecurityScheme.AsObject,
+  }
+
+  export enum SchemeCase { 
+    SCHEME_NOT_SET = 0,
+    API_KEY_SECURITY_SCHEME = 1,
+    HTTP_AUTH_SECURITY_SCHEME = 2,
+    OAUTH2_SECURITY_SCHEME = 3,
+    OPEN_ID_CONNECT_SECURITY_SCHEME = 4,
+    MTLS_SECURITY_SCHEME = 5,
+  }
+}
+
+export class APIKeySecurityScheme extends jspb.Message {
+  getDescription(): string;
+  setDescription(value: string): APIKeySecurityScheme;
+
+  getLocation(): string;
+  setLocation(value: string): APIKeySecurityScheme;
+
+  getName(): string;
+  setName(value: string): APIKeySecurityScheme;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): APIKeySecurityScheme.AsObject;
+  static toObject(includeInstance: boolean, msg: APIKeySecurityScheme): APIKeySecurityScheme.AsObject;
+  static serializeBinaryToWriter(message: APIKeySecurityScheme, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): APIKeySecurityScheme;
+  static deserializeBinaryFromReader(message: APIKeySecurityScheme, reader: jspb.BinaryReader): APIKeySecurityScheme;
+}
+
+export namespace APIKeySecurityScheme {
+  export type AsObject = {
+    description: string,
+    location: string,
+    name: string,
+  }
+}
+
+export class HTTPAuthSecurityScheme extends jspb.Message {
+  getDescription(): string;
+  setDescription(value: string): HTTPAuthSecurityScheme;
+
+  getScheme(): string;
+  setScheme(value: string): HTTPAuthSecurityScheme;
+
+  getBearerFormat(): string;
+  setBearerFormat(value: string): HTTPAuthSecurityScheme;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): HTTPAuthSecurityScheme.AsObject;
+  static toObject(includeInstance: boolean, msg: HTTPAuthSecurityScheme): HTTPAuthSecurityScheme.AsObject;
+  static serializeBinaryToWriter(message: HTTPAuthSecurityScheme, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): HTTPAuthSecurityScheme;
+  static deserializeBinaryFromReader(message: HTTPAuthSecurityScheme, reader: jspb.BinaryReader): HTTPAuthSecurityScheme;
+}
+
+export namespace HTTPAuthSecurityScheme {
+  export type AsObject = {
+    description: string,
+    scheme: string,
+    bearerFormat: string,
+  }
+}
+
+export class OAuth2SecurityScheme extends jspb.Message {
+  getDescription(): string;
+  setDescription(value: string): OAuth2SecurityScheme;
+
+  getFlows(): OAuthFlows | undefined;
+  setFlows(value?: OAuthFlows): OAuth2SecurityScheme;
+  hasFlows(): boolean;
+  clearFlows(): OAuth2SecurityScheme;
+
+  getOauth2MetadataUrl(): string;
+  setOauth2MetadataUrl(value: string): OAuth2SecurityScheme;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): OAuth2SecurityScheme.AsObject;
+  static toObject(includeInstance: boolean, msg: OAuth2SecurityScheme): OAuth2SecurityScheme.AsObject;
+  static serializeBinaryToWriter(message: OAuth2SecurityScheme, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): OAuth2SecurityScheme;
+  static deserializeBinaryFromReader(message: OAuth2SecurityScheme, reader: jspb.BinaryReader): OAuth2SecurityScheme;
+}
+
+export namespace OAuth2SecurityScheme {
+  export type AsObject = {
+    description: string,
+    flows?: OAuthFlows.AsObject,
+    oauth2MetadataUrl: string,
+  }
+}
+
+export class OpenIdConnectSecurityScheme extends jspb.Message {
+  getDescription(): string;
+  setDescription(value: string): OpenIdConnectSecurityScheme;
+
+  getOpenIdConnectUrl(): string;
+  setOpenIdConnectUrl(value: string): OpenIdConnectSecurityScheme;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): OpenIdConnectSecurityScheme.AsObject;
+  static toObject(includeInstance: boolean, msg: OpenIdConnectSecurityScheme): OpenIdConnectSecurityScheme.AsObject;
+  static serializeBinaryToWriter(message: OpenIdConnectSecurityScheme, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): OpenIdConnectSecurityScheme;
+  static deserializeBinaryFromReader(message: OpenIdConnectSecurityScheme, reader: jspb.BinaryReader): OpenIdConnectSecurityScheme;
+}
+
+export namespace OpenIdConnectSecurityScheme {
+  export type AsObject = {
+    description: string,
+    openIdConnectUrl: string,
+  }
+}
+
+export class MutualTlsSecurityScheme extends jspb.Message {
+  getDescription(): string;
+  setDescription(value: string): MutualTlsSecurityScheme;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): MutualTlsSecurityScheme.AsObject;
+  static toObject(includeInstance: boolean, msg: MutualTlsSecurityScheme): MutualTlsSecurityScheme.AsObject;
+  static serializeBinaryToWriter(message: MutualTlsSecurityScheme, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): MutualTlsSecurityScheme;
+  static deserializeBinaryFromReader(message: MutualTlsSecurityScheme, reader: jspb.BinaryReader): MutualTlsSecurityScheme;
+}
+
+export namespace MutualTlsSecurityScheme {
+  export type AsObject = {
+    description: string,
+  }
+}
+
+export class OAuthFlows extends jspb.Message {
+  getAuthorizationCode(): AuthorizationCodeOAuthFlow | undefined;
+  setAuthorizationCode(value?: AuthorizationCodeOAuthFlow): OAuthFlows;
+  hasAuthorizationCode(): boolean;
+  clearAuthorizationCode(): OAuthFlows;
+
+  getClientCredentials(): ClientCredentialsOAuthFlow | undefined;
+  setClientCredentials(value?: ClientCredentialsOAuthFlow): OAuthFlows;
+  hasClientCredentials(): boolean;
+  clearClientCredentials(): OAuthFlows;
+
+  getImplicit(): ImplicitOAuthFlow | undefined;
+  setImplicit(value?: ImplicitOAuthFlow): OAuthFlows;
+  hasImplicit(): boolean;
+  clearImplicit(): OAuthFlows;
+
+  getPassword(): PasswordOAuthFlow | undefined;
+  setPassword(value?: PasswordOAuthFlow): OAuthFlows;
+  hasPassword(): boolean;
+  clearPassword(): OAuthFlows;
+
+  getDeviceCode(): DeviceCodeOAuthFlow | undefined;
+  setDeviceCode(value?: DeviceCodeOAuthFlow): OAuthFlows;
+  hasDeviceCode(): boolean;
+  clearDeviceCode(): OAuthFlows;
+
+  getFlowCase(): OAuthFlows.FlowCase;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): OAuthFlows.AsObject;
+  static toObject(includeInstance: boolean, msg: OAuthFlows): OAuthFlows.AsObject;
+  static serializeBinaryToWriter(message: OAuthFlows, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): OAuthFlows;
+  static deserializeBinaryFromReader(message: OAuthFlows, reader: jspb.BinaryReader): OAuthFlows;
+}
+
+export namespace OAuthFlows {
+  export type AsObject = {
+    authorizationCode?: AuthorizationCodeOAuthFlow.AsObject,
+    clientCredentials?: ClientCredentialsOAuthFlow.AsObject,
+    implicit?: ImplicitOAuthFlow.AsObject,
+    password?: PasswordOAuthFlow.AsObject,
+    deviceCode?: DeviceCodeOAuthFlow.AsObject,
+  }
+
+  export enum FlowCase { 
+    FLOW_NOT_SET = 0,
+    AUTHORIZATION_CODE = 1,
+    CLIENT_CREDENTIALS = 2,
+    IMPLICIT = 3,
+    PASSWORD = 4,
+    DEVICE_CODE = 5,
+  }
+}
+
+export class AuthorizationCodeOAuthFlow extends jspb.Message {
+  getAuthorizationUrl(): string;
+  setAuthorizationUrl(value: string): AuthorizationCodeOAuthFlow;
+
+  getTokenUrl(): string;
+  setTokenUrl(value: string): AuthorizationCodeOAuthFlow;
+
+  getRefreshUrl(): string;
+  setRefreshUrl(value: string): AuthorizationCodeOAuthFlow;
+
+  getScopesMap(): jspb.Map<string, string>;
+  clearScopesMap(): AuthorizationCodeOAuthFlow;
+
+  getPkceRequired(): boolean;
+  setPkceRequired(value: boolean): AuthorizationCodeOAuthFlow;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): AuthorizationCodeOAuthFlow.AsObject;
+  static toObject(includeInstance: boolean, msg: AuthorizationCodeOAuthFlow): AuthorizationCodeOAuthFlow.AsObject;
+  static serializeBinaryToWriter(message: AuthorizationCodeOAuthFlow, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): AuthorizationCodeOAuthFlow;
+  static deserializeBinaryFromReader(message: AuthorizationCodeOAuthFlow, reader: jspb.BinaryReader): AuthorizationCodeOAuthFlow;
+}
+
+export namespace AuthorizationCodeOAuthFlow {
+  export type AsObject = {
+    authorizationUrl: string,
+    tokenUrl: string,
+    refreshUrl: string,
+    scopesMap: Array<[string, string]>,
+    pkceRequired: boolean,
+  }
+}
+
+export class ClientCredentialsOAuthFlow extends jspb.Message {
+  getTokenUrl(): string;
+  setTokenUrl(value: string): ClientCredentialsOAuthFlow;
+
+  getRefreshUrl(): string;
+  setRefreshUrl(value: string): ClientCredentialsOAuthFlow;
+
+  getScopesMap(): jspb.Map<string, string>;
+  clearScopesMap(): ClientCredentialsOAuthFlow;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ClientCredentialsOAuthFlow.AsObject;
+  static toObject(includeInstance: boolean, msg: ClientCredentialsOAuthFlow): ClientCredentialsOAuthFlow.AsObject;
+  static serializeBinaryToWriter(message: ClientCredentialsOAuthFlow, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ClientCredentialsOAuthFlow;
+  static deserializeBinaryFromReader(message: ClientCredentialsOAuthFlow, reader: jspb.BinaryReader): ClientCredentialsOAuthFlow;
+}
+
+export namespace ClientCredentialsOAuthFlow {
+  export type AsObject = {
+    tokenUrl: string,
+    refreshUrl: string,
+    scopesMap: Array<[string, string]>,
+  }
+}
+
+export class ImplicitOAuthFlow extends jspb.Message {
+  getAuthorizationUrl(): string;
+  setAuthorizationUrl(value: string): ImplicitOAuthFlow;
+
+  getRefreshUrl(): string;
+  setRefreshUrl(value: string): ImplicitOAuthFlow;
+
+  getScopesMap(): jspb.Map<string, string>;
+  clearScopesMap(): ImplicitOAuthFlow;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ImplicitOAuthFlow.AsObject;
+  static toObject(includeInstance: boolean, msg: ImplicitOAuthFlow): ImplicitOAuthFlow.AsObject;
+  static serializeBinaryToWriter(message: ImplicitOAuthFlow, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ImplicitOAuthFlow;
+  static deserializeBinaryFromReader(message: ImplicitOAuthFlow, reader: jspb.BinaryReader): ImplicitOAuthFlow;
+}
+
+export namespace ImplicitOAuthFlow {
+  export type AsObject = {
+    authorizationUrl: string,
+    refreshUrl: string,
+    scopesMap: Array<[string, string]>,
+  }
+}
+
+export class PasswordOAuthFlow extends jspb.Message {
+  getTokenUrl(): string;
+  setTokenUrl(value: string): PasswordOAuthFlow;
+
+  getRefreshUrl(): string;
+  setRefreshUrl(value: string): PasswordOAuthFlow;
+
+  getScopesMap(): jspb.Map<string, string>;
+  clearScopesMap(): PasswordOAuthFlow;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): PasswordOAuthFlow.AsObject;
+  static toObject(includeInstance: boolean, msg: PasswordOAuthFlow): PasswordOAuthFlow.AsObject;
+  static serializeBinaryToWriter(message: PasswordOAuthFlow, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): PasswordOAuthFlow;
+  static deserializeBinaryFromReader(message: PasswordOAuthFlow, reader: jspb.BinaryReader): PasswordOAuthFlow;
+}
+
+export namespace PasswordOAuthFlow {
+  export type AsObject = {
+    tokenUrl: string,
+    refreshUrl: string,
+    scopesMap: Array<[string, string]>,
+  }
+}
+
+export class DeviceCodeOAuthFlow extends jspb.Message {
+  getDeviceAuthorizationUrl(): string;
+  setDeviceAuthorizationUrl(value: string): DeviceCodeOAuthFlow;
+
+  getTokenUrl(): string;
+  setTokenUrl(value: string): DeviceCodeOAuthFlow;
+
+  getRefreshUrl(): string;
+  setRefreshUrl(value: string): DeviceCodeOAuthFlow;
+
+  getScopesMap(): jspb.Map<string, string>;
+  clearScopesMap(): DeviceCodeOAuthFlow;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): DeviceCodeOAuthFlow.AsObject;
+  static toObject(includeInstance: boolean, msg: DeviceCodeOAuthFlow): DeviceCodeOAuthFlow.AsObject;
+  static serializeBinaryToWriter(message: DeviceCodeOAuthFlow, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): DeviceCodeOAuthFlow;
+  static deserializeBinaryFromReader(message: DeviceCodeOAuthFlow, reader: jspb.BinaryReader): DeviceCodeOAuthFlow;
+}
+
+export namespace DeviceCodeOAuthFlow {
+  export type AsObject = {
+    deviceAuthorizationUrl: string,
+    tokenUrl: string,
+    refreshUrl: string,
+    scopesMap: Array<[string, string]>,
+  }
+}