diff --git a/arista/serviceaccount.v1/serviceaccount-changelog.yaml b/arista/serviceaccount.v1/serviceaccount-changelog.yaml new file mode 100644 index 00000000..3252c685 --- /dev/null +++ b/arista/serviceaccount.v1/serviceaccount-changelog.yaml @@ -0,0 +1,33 @@ +# Copyright (c) 2023 Arista Networks, Inc. All rights reserved. +# Use of this source code is governed by the Apache License 2.0 +# that can be found in the COPYING file. + +# Add a short description of each model change here. +# New entries go on top. + +Changes: + - date: 2023-12-06 + description: Update documentation and publish the API + version: 1.2.1 + cvaas: true + onprem: true + + - date: 2020-06-22 + description: Drop Status suffix from state + version: 1.2.0 + + - date: 2020-05-11 + description: Add model for accounts + version: 1.1.0 + + - date: 2020-05-06 + description: set fmp.require_set_key to false + version: 1.0.2 + + - date: 2020-04-10 + description: changed Go package name to a versionless one + version: 1.0.1 + + - date: 2020-04-10 + description: Initial revision + version: 1.0.0 diff --git a/arista/serviceaccount.v1/serviceaccount.proto b/arista/serviceaccount.v1/serviceaccount.proto new file mode 100644 index 00000000..eeed1314 --- /dev/null +++ b/arista/serviceaccount.v1/serviceaccount.proto @@ -0,0 +1,106 @@ +// Copyright (c) 2023 Arista Networks, Inc. All rights reserved. +// Use of this source code is governed by the Apache License 2.0 +// that can be found in the COPYING file. + +syntax = "proto3"; + +package arista.serviceaccount.v1; + +option go_package = "arista/resources/arista/serviceaccount.v1;serviceaccount"; + +import "google/protobuf/duration.proto"; +import "google/protobuf/timestamp.proto"; +import "google/protobuf/wrappers.proto"; + +import "fmp/extensions.proto"; +import "fmp/wrappers.proto"; + +// AccountKey contains the name of the service account. +message AccountKey { + option (fmp.model_key) = true; + // name is the unique identifier of the service account. + google.protobuf.StringValue name = 1; +} + +// AccountStatus determines whether an service account is enabled or disabled. +enum AccountStatus { + // ACCOUNT_STATUS_UNSPECIFIED indicates the service account status is unspecified. + ACCOUNT_STATUS_UNSPECIFIED = 0; + // ACCOUNT_STATUS_ENABLED indicates the service account is enabled. + ACCOUNT_STATUS_ENABLED = 1; + // ACCOUNT_STATUS_DISABLED indicates the service account is disabled. + ACCOUNT_STATUS_DISABLED = 2; +} + +// AccountConfig holds the configuration for a service account. +message AccountConfig { + option (fmp.model) = "rw"; + // key contains the name of the service account. + AccountKey key = 1; + // status determines if the service account is enabled or disabled. New service accounts are + // enabled by default. + AccountStatus status = 2; + // description is a comment describing the service account. + google.protobuf.StringValue description = 3; + // groups is a list of roles that the service account inherits permissions from. + fmp.RepeatedString groups = 4; +} + +// Account describes a service account. +message Account { + option (fmp.model) = "ro"; + // key uniquely identifies the service account. + AccountKey key = 1; + // status determines whether the service account is enabled or disabled. + AccountStatus status = 2; + // description is a comment describing the service account. + google.protobuf.StringValue description = 3; + // groups is a list of roles that the service account inherits permissions from. + fmp.RepeatedString groups = 4; + // created_by is the name of the entity that created the service account. + google.protobuf.StringValue created_by = 5; + // last_access is the time when the service account was last fetched. + google.protobuf.Timestamp last_access = 6; +} + +// TokenKey contains service account token ID. +message TokenKey { + option (fmp.model_key) = true; + // id is the unique identifier of the service account token. + google.protobuf.StringValue id = 1; +} + +// TokenConfig holds the configuration for a service account token. The token is a signed JWT which +// can be used as a credential for REST and WRPC endpoints. +message TokenConfig { + option (fmp.model) = "rw"; + option (fmp.require_set_key) = false; + // key uniquely identifies the service account token. + TokenKey key = 1; + // user is the name of the service account that the token is generated for. + google.protobuf.StringValue user = 2; + // description is a short name or comment used to identify the service account token. + google.protobuf.StringValue description = 3; + // valid_for determines the duration that the service account token will be valid for. + google.protobuf.Duration valid_for = 4; + // token is the JWT token generated for a service account token. + // It is only populated in Set response. + google.protobuf.StringValue token = 5; +} + +// Token describes a service account token. +message Token { + option (fmp.model) = "ro"; + // key uniquely identifies the service account token. + TokenKey key = 1; + // user is the name of the service account that the token is generated for. + google.protobuf.StringValue user = 2; + // description is a short name or comment used to identify the service account token. + google.protobuf.StringValue description = 3; + // valid_until is the time that the service account token will be valid until. + google.protobuf.Timestamp valid_until = 4; + // created_by is the name of the entity that created the service account token. + google.protobuf.StringValue created_by = 5; + // last_used is the time when the service account token was last used to authenticate. + google.protobuf.Timestamp last_used = 6; +} diff --git a/arista/serviceaccount.v1/services.gen.proto b/arista/serviceaccount.v1/services.gen.proto new file mode 100644 index 00000000..04cc66d5 --- /dev/null +++ b/arista/serviceaccount.v1/services.gen.proto @@ -0,0 +1,577 @@ +// Copyright (c) 2023 Arista Networks, Inc. All rights reserved. +// Use of this source code is governed by the Apache License 2.0 +// that can be found in the COPYING file. + +// +// Code generated by boomtown. DO NOT EDIT. +// + +syntax = "proto3"; + +package arista.serviceaccount.v1; +option go_package = "arista/resources/arista/serviceaccount.v1;serviceaccount"; + +import "arista/serviceaccount.v1/serviceaccount.proto"; +import "arista/time/time.proto"; +import "arista/subscriptions/subscriptions.proto"; +import "fmp/deletes.proto"; +import "google/protobuf/timestamp.proto"; +import "google/protobuf/wrappers.proto"; + +message MetaResponse { + // Time holds the timestamp of the last item included in the metadata calculation. + google.protobuf.Timestamp time = 1; + + // Operation indicates how the value in this response should be considered. + // Under non-subscribe requests, this value should always be INITIAL. In a subscription, + // once all initial data is streamed and the client begins to receive modification updates, + // you should not see INITIAL again. + arista.subscriptions.Operation type = 2; + + // Count is the number of items present under the conditions of the request. + google.protobuf.UInt32Value count = 3; +}; + +message AccountRequest { + // Key uniquely identifies a Account instance to retrieve. + // This value must be populated. + AccountKey key = 1; + + // Time indicates the time for which you are interested in the data. + // If no time is given, the server will use the time at which it makes the request. + google.protobuf.Timestamp time = 2; +}; + +message AccountResponse { + // Value is the value requested. + // This structure will be fully-populated as it exists in the datastore. If + // optional fields were not given at creation, these fields will be empty or + // set to default values. + Account value = 1; + + // Time carries the (UTC) timestamp of the last-modification of the + // Account instance in this response. + google.protobuf.Timestamp time = 2; +}; + +message AccountSomeRequest { + repeated AccountKey keys = 1; + + // Time indicates the time for which you are interested in the data. + // If no time is given, the server will use the time at which it makes the request. + google.protobuf.Timestamp time = 2; +}; + +message AccountSomeResponse { + // Value is the value requested. + // This structure will be fully-populated as it exists in the datastore. If + // optional fields were not given at creation, these fields will be empty or + // set to default values. + Account value = 1; + + // Error is an optional field. + // It should be filled when there is an error in the GetSome process. + google.protobuf.StringValue error = 2; + google.protobuf.Timestamp time = 3; +}; + +message AccountStreamRequest { + // PartialEqFilter provides a way to server-side filter a GetAll/Subscribe. + // This requires all provided fields to be equal to the response. + // + // While transparent to users, this field also allows services to optimize internal + // subscriptions if filter(s) are sufficiently specific. + repeated Account partial_eq_filter = 1; + + // TimeRange allows limiting response data to within a specified time window. + // If this field is populated, at least one of the two time fields are required. + // + // For GetAll, the fields start and end can be used as follows: + // + // * end: Returns the state of each Account at end. + // * Each Account response is fully-specified (all fields set). + // * start: Returns the state of each Account at start, followed by updates until now. + // * Each Account response at start is fully-specified, but updates may be partial. + // * start and end: Returns the state of each Account at start, followed by updates + // until end. + // * Each Account response at start is fully-specified, but updates until end may + // be partial. + // + // This field is not allowed in the Subscribe RPC. + arista.time.TimeBounds time = 3; +}; + +message AccountStreamResponse { + // Value is a value deemed relevant to the initiating request. + // This structure will always have its key-field populated. Which other fields are + // populated, and why, depends on the value of Operation and what triggered this notification. + Account value = 1; + + // Time holds the timestamp of this Account's last modification. + google.protobuf.Timestamp time = 2; + + // Operation indicates how the Account value in this response should be considered. + // Under non-subscribe requests, this value should always be INITIAL. In a subscription, + // once all initial data is streamed and the client begins to receive modification updates, + // you should not see INITIAL again. + arista.subscriptions.Operation type = 3; +}; + +service AccountService { + rpc GetOne (AccountRequest) returns (AccountResponse); + rpc GetSome (AccountSomeRequest) returns (stream AccountSomeResponse); + rpc GetAll (AccountStreamRequest) returns (stream AccountStreamResponse); + rpc Subscribe (AccountStreamRequest) returns (stream AccountStreamResponse); + rpc GetMeta (AccountStreamRequest) returns (MetaResponse); + rpc SubscribeMeta (AccountStreamRequest) returns (stream MetaResponse); +} + +message AccountConfigRequest { + // Key uniquely identifies a AccountConfig instance to retrieve. + // This value must be populated. + AccountKey key = 1; + + // Time indicates the time for which you are interested in the data. + // If no time is given, the server will use the time at which it makes the request. + google.protobuf.Timestamp time = 2; +}; + +message AccountConfigResponse { + // Value is the value requested. + // This structure will be fully-populated as it exists in the datastore. If + // optional fields were not given at creation, these fields will be empty or + // set to default values. + AccountConfig value = 1; + + // Time carries the (UTC) timestamp of the last-modification of the + // AccountConfig instance in this response. + google.protobuf.Timestamp time = 2; +}; + +message AccountConfigSomeRequest { + repeated AccountKey keys = 1; + + // Time indicates the time for which you are interested in the data. + // If no time is given, the server will use the time at which it makes the request. + google.protobuf.Timestamp time = 2; +}; + +message AccountConfigSomeResponse { + // Value is the value requested. + // This structure will be fully-populated as it exists in the datastore. If + // optional fields were not given at creation, these fields will be empty or + // set to default values. + AccountConfig value = 1; + + // Error is an optional field. + // It should be filled when there is an error in the GetSome process. + google.protobuf.StringValue error = 2; + google.protobuf.Timestamp time = 3; +}; + +message AccountConfigStreamRequest { + // PartialEqFilter provides a way to server-side filter a GetAll/Subscribe. + // This requires all provided fields to be equal to the response. + // + // While transparent to users, this field also allows services to optimize internal + // subscriptions if filter(s) are sufficiently specific. + repeated AccountConfig partial_eq_filter = 1; + + // TimeRange allows limiting response data to within a specified time window. + // If this field is populated, at least one of the two time fields are required. + // + // For GetAll, the fields start and end can be used as follows: + // + // * end: Returns the state of each AccountConfig at end. + // * Each AccountConfig response is fully-specified (all fields set). + // * start: Returns the state of each AccountConfig at start, followed by updates until now. + // * Each AccountConfig response at start is fully-specified, but updates may be partial. + // * start and end: Returns the state of each AccountConfig at start, followed by updates + // until end. + // * Each AccountConfig response at start is fully-specified, but updates until end may + // be partial. + // + // This field is not allowed in the Subscribe RPC. + arista.time.TimeBounds time = 3; +}; + +message AccountConfigStreamResponse { + // Value is a value deemed relevant to the initiating request. + // This structure will always have its key-field populated. Which other fields are + // populated, and why, depends on the value of Operation and what triggered this notification. + AccountConfig value = 1; + + // Time holds the timestamp of this AccountConfig's last modification. + google.protobuf.Timestamp time = 2; + + // Operation indicates how the AccountConfig value in this response should be considered. + // Under non-subscribe requests, this value should always be INITIAL. In a subscription, + // once all initial data is streamed and the client begins to receive modification updates, + // you should not see INITIAL again. + arista.subscriptions.Operation type = 3; +}; + +message AccountConfigSetRequest { + // AccountConfig carries the value to set into the datastore. + // See the documentation on the AccountConfig struct for which fields are required. + AccountConfig value = 1; +}; + +message AccountConfigSetResponse { + // Value carries all the values given in the AccountConfigSetRequest as well + // as any server-generated values. + AccountConfig value = 1; + + // Time indicates the (UTC) timestamp at which the system recognizes the + // creation. The only guarantees made about this timestamp are: + // + // - it is after the time the request was received + // - a time-ranged query with StartTime==CreatedAt will include this instance. + // + google.protobuf.Timestamp time = 2; +}; + +message AccountConfigSetSomeRequest { + // value contains a list of AccountConfig values to write. + // It is possible to provide more values than can fit within either: + // - the maxiumum send size of the client + // - the maximum receive size of the server + // If this error occurs you must reduce the number of values sent. + // See gRPC "maximum message size" documentation for more information. + repeated AccountConfig values = 1; +}; + +message AccountConfigSetSomeResponse { + AccountKey key = 1; + string error = 2; +}; + +message AccountConfigDeleteRequest { + // Key indicates which AccountConfig instance to remove. + // This field must always be set. + AccountKey key = 1; +}; + +message AccountConfigDeleteResponse { + // Key echoes back the key of the deleted AccountConfig instance. + AccountKey key = 1; + + // Time indicates the (UTC) timestamp at which the system recognizes the + // deletion. The only guarantees made about this timestamp are: + // + // - it is after the time the request was received + // - a time-ranged query with StartTime==DeletedAt will not include this instance. + // + google.protobuf.Timestamp time = 2; +}; + +message AccountConfigDeleteSomeRequest { + // key contains a list of AccountConfig keys to delete + repeated AccountKey keys = 1; +}; + +// AccountConfigDeleteSomeResponse is only sent when there is an error. +message AccountConfigDeleteSomeResponse { + AccountKey key = 1; + string error = 2; +}; + +message AccountConfigDeleteAllRequest { +}; + +message AccountConfigDeleteAllResponse { + // This describes the class of delete error. + fmp.DeleteError type = 1; + // This indicates the error message from the delete failure. + google.protobuf.StringValue error = 2; + // This is the key of the AccountConfig instance that failed to be deleted. + AccountKey key = 3; + // Time indicates the (UTC) timestamp when the key was being deleted. + google.protobuf.Timestamp time = 4; +}; + +service AccountConfigService { + rpc GetOne (AccountConfigRequest) returns (AccountConfigResponse); + rpc GetSome (AccountConfigSomeRequest) returns (stream AccountConfigSomeResponse); + rpc GetAll (AccountConfigStreamRequest) returns (stream AccountConfigStreamResponse); + rpc Subscribe (AccountConfigStreamRequest) returns (stream AccountConfigStreamResponse); + rpc GetMeta (AccountConfigStreamRequest) returns (MetaResponse); + rpc SubscribeMeta (AccountConfigStreamRequest) returns (stream MetaResponse); + rpc Set (AccountConfigSetRequest) returns (AccountConfigSetResponse); + rpc SetSome (AccountConfigSetSomeRequest) returns (stream AccountConfigSetSomeResponse); + rpc Delete (AccountConfigDeleteRequest) returns (AccountConfigDeleteResponse); + rpc DeleteSome (AccountConfigDeleteSomeRequest) returns (stream AccountConfigDeleteSomeResponse); + rpc DeleteAll (AccountConfigDeleteAllRequest) returns (stream AccountConfigDeleteAllResponse); +} + +message TokenRequest { + // Key uniquely identifies a Token instance to retrieve. + // This value must be populated. + TokenKey key = 1; + + // Time indicates the time for which you are interested in the data. + // If no time is given, the server will use the time at which it makes the request. + google.protobuf.Timestamp time = 2; +}; + +message TokenResponse { + // Value is the value requested. + // This structure will be fully-populated as it exists in the datastore. If + // optional fields were not given at creation, these fields will be empty or + // set to default values. + Token value = 1; + + // Time carries the (UTC) timestamp of the last-modification of the + // Token instance in this response. + google.protobuf.Timestamp time = 2; +}; + +message TokenSomeRequest { + repeated TokenKey keys = 1; + + // Time indicates the time for which you are interested in the data. + // If no time is given, the server will use the time at which it makes the request. + google.protobuf.Timestamp time = 2; +}; + +message TokenSomeResponse { + // Value is the value requested. + // This structure will be fully-populated as it exists in the datastore. If + // optional fields were not given at creation, these fields will be empty or + // set to default values. + Token value = 1; + + // Error is an optional field. + // It should be filled when there is an error in the GetSome process. + google.protobuf.StringValue error = 2; + google.protobuf.Timestamp time = 3; +}; + +message TokenStreamRequest { + // PartialEqFilter provides a way to server-side filter a GetAll/Subscribe. + // This requires all provided fields to be equal to the response. + // + // While transparent to users, this field also allows services to optimize internal + // subscriptions if filter(s) are sufficiently specific. + repeated Token partial_eq_filter = 1; + + // TimeRange allows limiting response data to within a specified time window. + // If this field is populated, at least one of the two time fields are required. + // + // For GetAll, the fields start and end can be used as follows: + // + // * end: Returns the state of each Token at end. + // * Each Token response is fully-specified (all fields set). + // * start: Returns the state of each Token at start, followed by updates until now. + // * Each Token response at start is fully-specified, but updates may be partial. + // * start and end: Returns the state of each Token at start, followed by updates + // until end. + // * Each Token response at start is fully-specified, but updates until end may + // be partial. + // + // This field is not allowed in the Subscribe RPC. + arista.time.TimeBounds time = 3; +}; + +message TokenStreamResponse { + // Value is a value deemed relevant to the initiating request. + // This structure will always have its key-field populated. Which other fields are + // populated, and why, depends on the value of Operation and what triggered this notification. + Token value = 1; + + // Time holds the timestamp of this Token's last modification. + google.protobuf.Timestamp time = 2; + + // Operation indicates how the Token value in this response should be considered. + // Under non-subscribe requests, this value should always be INITIAL. In a subscription, + // once all initial data is streamed and the client begins to receive modification updates, + // you should not see INITIAL again. + arista.subscriptions.Operation type = 3; +}; + +service TokenService { + rpc GetOne (TokenRequest) returns (TokenResponse); + rpc GetSome (TokenSomeRequest) returns (stream TokenSomeResponse); + rpc GetAll (TokenStreamRequest) returns (stream TokenStreamResponse); + rpc Subscribe (TokenStreamRequest) returns (stream TokenStreamResponse); + rpc GetMeta (TokenStreamRequest) returns (MetaResponse); + rpc SubscribeMeta (TokenStreamRequest) returns (stream MetaResponse); +} + +message TokenConfigRequest { + // Key uniquely identifies a TokenConfig instance to retrieve. + // This value must be populated. + TokenKey key = 1; + + // Time indicates the time for which you are interested in the data. + // If no time is given, the server will use the time at which it makes the request. + google.protobuf.Timestamp time = 2; +}; + +message TokenConfigResponse { + // Value is the value requested. + // This structure will be fully-populated as it exists in the datastore. If + // optional fields were not given at creation, these fields will be empty or + // set to default values. + TokenConfig value = 1; + + // Time carries the (UTC) timestamp of the last-modification of the + // TokenConfig instance in this response. + google.protobuf.Timestamp time = 2; +}; + +message TokenConfigSomeRequest { + repeated TokenKey keys = 1; + + // Time indicates the time for which you are interested in the data. + // If no time is given, the server will use the time at which it makes the request. + google.protobuf.Timestamp time = 2; +}; + +message TokenConfigSomeResponse { + // Value is the value requested. + // This structure will be fully-populated as it exists in the datastore. If + // optional fields were not given at creation, these fields will be empty or + // set to default values. + TokenConfig value = 1; + + // Error is an optional field. + // It should be filled when there is an error in the GetSome process. + google.protobuf.StringValue error = 2; + google.protobuf.Timestamp time = 3; +}; + +message TokenConfigStreamRequest { + // PartialEqFilter provides a way to server-side filter a GetAll/Subscribe. + // This requires all provided fields to be equal to the response. + // + // While transparent to users, this field also allows services to optimize internal + // subscriptions if filter(s) are sufficiently specific. + repeated TokenConfig partial_eq_filter = 1; + + // TimeRange allows limiting response data to within a specified time window. + // If this field is populated, at least one of the two time fields are required. + // + // For GetAll, the fields start and end can be used as follows: + // + // * end: Returns the state of each TokenConfig at end. + // * Each TokenConfig response is fully-specified (all fields set). + // * start: Returns the state of each TokenConfig at start, followed by updates until now. + // * Each TokenConfig response at start is fully-specified, but updates may be partial. + // * start and end: Returns the state of each TokenConfig at start, followed by updates + // until end. + // * Each TokenConfig response at start is fully-specified, but updates until end may + // be partial. + // + // This field is not allowed in the Subscribe RPC. + arista.time.TimeBounds time = 3; +}; + +message TokenConfigStreamResponse { + // Value is a value deemed relevant to the initiating request. + // This structure will always have its key-field populated. Which other fields are + // populated, and why, depends on the value of Operation and what triggered this notification. + TokenConfig value = 1; + + // Time holds the timestamp of this TokenConfig's last modification. + google.protobuf.Timestamp time = 2; + + // Operation indicates how the TokenConfig value in this response should be considered. + // Under non-subscribe requests, this value should always be INITIAL. In a subscription, + // once all initial data is streamed and the client begins to receive modification updates, + // you should not see INITIAL again. + arista.subscriptions.Operation type = 3; +}; + +message TokenConfigSetRequest { + // TokenConfig carries the value to set into the datastore. + // See the documentation on the TokenConfig struct for which fields are required. + TokenConfig value = 1; +}; + +message TokenConfigSetResponse { + // Value carries all the values given in the TokenConfigSetRequest as well + // as any server-generated values. + TokenConfig value = 1; + + // Time indicates the (UTC) timestamp at which the system recognizes the + // creation. The only guarantees made about this timestamp are: + // + // - it is after the time the request was received + // - a time-ranged query with StartTime==CreatedAt will include this instance. + // + google.protobuf.Timestamp time = 2; +}; + +message TokenConfigSetSomeRequest { + // value contains a list of TokenConfig values to write. + // It is possible to provide more values than can fit within either: + // - the maxiumum send size of the client + // - the maximum receive size of the server + // If this error occurs you must reduce the number of values sent. + // See gRPC "maximum message size" documentation for more information. + repeated TokenConfig values = 1; +}; + +message TokenConfigSetSomeResponse { + TokenKey key = 1; + string error = 2; +}; + +message TokenConfigDeleteRequest { + // Key indicates which TokenConfig instance to remove. + // This field must always be set. + TokenKey key = 1; +}; + +message TokenConfigDeleteResponse { + // Key echoes back the key of the deleted TokenConfig instance. + TokenKey key = 1; + + // Time indicates the (UTC) timestamp at which the system recognizes the + // deletion. The only guarantees made about this timestamp are: + // + // - it is after the time the request was received + // - a time-ranged query with StartTime==DeletedAt will not include this instance. + // + google.protobuf.Timestamp time = 2; +}; + +message TokenConfigDeleteSomeRequest { + // key contains a list of TokenConfig keys to delete + repeated TokenKey keys = 1; +}; + +// TokenConfigDeleteSomeResponse is only sent when there is an error. +message TokenConfigDeleteSomeResponse { + TokenKey key = 1; + string error = 2; +}; + +message TokenConfigDeleteAllRequest { +}; + +message TokenConfigDeleteAllResponse { + // This describes the class of delete error. + fmp.DeleteError type = 1; + // This indicates the error message from the delete failure. + google.protobuf.StringValue error = 2; + // This is the key of the TokenConfig instance that failed to be deleted. + TokenKey key = 3; + // Time indicates the (UTC) timestamp when the key was being deleted. + google.protobuf.Timestamp time = 4; +}; + +service TokenConfigService { + rpc GetOne (TokenConfigRequest) returns (TokenConfigResponse); + rpc GetSome (TokenConfigSomeRequest) returns (stream TokenConfigSomeResponse); + rpc GetAll (TokenConfigStreamRequest) returns (stream TokenConfigStreamResponse); + rpc Subscribe (TokenConfigStreamRequest) returns (stream TokenConfigStreamResponse); + rpc GetMeta (TokenConfigStreamRequest) returns (MetaResponse); + rpc SubscribeMeta (TokenConfigStreamRequest) returns (stream MetaResponse); + rpc Set (TokenConfigSetRequest) returns (TokenConfigSetResponse); + rpc SetSome (TokenConfigSetSomeRequest) returns (stream TokenConfigSetSomeResponse); + rpc Delete (TokenConfigDeleteRequest) returns (TokenConfigDeleteResponse); + rpc DeleteSome (TokenConfigDeleteSomeRequest) returns (stream TokenConfigDeleteSomeResponse); + rpc DeleteAll (TokenConfigDeleteAllRequest) returns (stream TokenConfigDeleteAllResponse); +} diff --git a/arista/serviceaccount.v1/services.gen.swagger.json b/arista/serviceaccount.v1/services.gen.swagger.json new file mode 100644 index 00000000..752b1ae6 --- /dev/null +++ b/arista/serviceaccount.v1/services.gen.swagger.json @@ -0,0 +1,2745 @@ +{ + "swagger": "2.0", + "info": { + "title": "arista.serviceaccount.v1 Resources", + "version": "CV_RESOURCE_VER_DEV", + "license": { + "name": "Apache License 2.0", + "url": "https://github.com/aristanetworks/cloudvision-apis/blob/trunk/COPYING" + } + }, + "tags": [ + { + "name": "AccountService" + }, + { + "name": "AccountConfigService" + }, + { + "name": "TokenService" + }, + { + "name": "TokenConfigService" + } + ], + "schemes": [ + "https" + ], + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": { + "/api/resources/serviceaccount/v1/Account": { + "get": { + "operationId": "AccountService_GetOne", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "key.name", + "description": "name is the unique identifier of the service account.", + "in": "query", + "required": true, + "type": "string" + }, + { + "name": "time", + "description": "Time indicates the time for which you are interested in the data.\nIf no time is given, the server will use the time at which it makes the request.", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + } + ], + "tags": [ + "AccountService" + ] + } + }, + "/api/resources/serviceaccount/v1/Account/all": { + "get": { + "operationId": "AccountService_GetAll", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountStreamResponse" + }, + "error": { + "$ref": "#/definitions/google.rpc.Status" + } + }, + "title": "Stream result of arista.serviceaccount.v1.AccountStreamResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "time.start", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + }, + { + "name": "time.end", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + } + ], + "tags": [ + "AccountService" + ] + }, + "post": { + "operationId": "AccountService_GetAll2", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountStreamResponse" + }, + "error": { + "$ref": "#/definitions/google.rpc.Status" + } + }, + "title": "Stream result of arista.serviceaccount.v1.AccountStreamResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountStreamRequest" + } + } + ], + "tags": [ + "AccountService" + ] + } + }, + "/api/resources/serviceaccount/v1/Account/getsome": { + "post": { + "operationId": "AccountService_GetSome", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountSomeResponse" + }, + "error": { + "$ref": "#/definitions/google.rpc.Status" + } + }, + "title": "Stream result of arista.serviceaccount.v1.AccountSomeResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "keys", + "in": "body", + "required": true, + "schema": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/arista.serviceaccount.v1.AccountKey" + } + } + }, + { + "name": "time", + "description": "Time indicates the time for which you are interested in the data.\nIf no time is given, the server will use the time at which it makes the request.", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + } + ], + "tags": [ + "AccountService" + ] + } + }, + "/api/resources/serviceaccount/v1/Account/metadata": { + "get": { + "operationId": "AccountService_GetMeta", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/arista.serviceaccount.v1.MetaResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "time.start", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + }, + { + "name": "time.end", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + } + ], + "tags": [ + "AccountService" + ] + }, + "post": { + "operationId": "AccountService_GetMeta2", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/arista.serviceaccount.v1.MetaResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountStreamRequest" + } + } + ], + "tags": [ + "AccountService" + ] + } + }, + "/api/resources/serviceaccount/v1/Account/watch": { + "get": { + "operationId": "AccountService_Subscribe", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountStreamResponse" + }, + "error": { + "$ref": "#/definitions/google.rpc.Status" + } + }, + "title": "Stream result of arista.serviceaccount.v1.AccountStreamResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "time.start", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + }, + { + "name": "time.end", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + } + ], + "tags": [ + "AccountService" + ] + }, + "post": { + "operationId": "AccountService_Subscribe2", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountStreamResponse" + }, + "error": { + "$ref": "#/definitions/google.rpc.Status" + } + }, + "title": "Stream result of arista.serviceaccount.v1.AccountStreamResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountStreamRequest" + } + } + ], + "tags": [ + "AccountService" + ] + } + }, + "/api/resources/serviceaccount/v1/Account/watchmetadata": { + "get": { + "operationId": "AccountService_SubscribeMeta", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/arista.serviceaccount.v1.MetaResponse" + }, + "error": { + "$ref": "#/definitions/google.rpc.Status" + } + }, + "title": "Stream result of arista.serviceaccount.v1.MetaResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "time.start", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + }, + { + "name": "time.end", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + } + ], + "tags": [ + "AccountService" + ] + }, + "post": { + "operationId": "AccountService_SubscribeMeta2", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/arista.serviceaccount.v1.MetaResponse" + }, + "error": { + "$ref": "#/definitions/google.rpc.Status" + } + }, + "title": "Stream result of arista.serviceaccount.v1.MetaResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountStreamRequest" + } + } + ], + "tags": [ + "AccountService" + ] + } + }, + "/api/resources/serviceaccount/v1/AccountConfig": { + "get": { + "operationId": "AccountConfigService_GetOne", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountConfigResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "key.name", + "description": "name is the unique identifier of the service account.", + "in": "query", + "required": true, + "type": "string" + }, + { + "name": "time", + "description": "Time indicates the time for which you are interested in the data.\nIf no time is given, the server will use the time at which it makes the request.", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + } + ], + "tags": [ + "AccountConfigService" + ] + }, + "delete": { + "operationId": "AccountConfigService_Delete", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountConfigDeleteResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "key.name", + "description": "name is the unique identifier of the service account.", + "in": "query", + "required": true, + "type": "string" + } + ], + "tags": [ + "AccountConfigService" + ] + }, + "post": { + "operationId": "AccountConfigService_Set", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountConfigSetResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "value", + "description": "AccountConfig carries the value to set into the datastore.\nSee the documentation on the AccountConfig struct for which fields are required.", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountConfig" + } + } + ], + "tags": [ + "AccountConfigService" + ] + } + }, + "/api/resources/serviceaccount/v1/AccountConfig/all": { + "get": { + "operationId": "AccountConfigService_GetAll", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountConfigStreamResponse" + }, + "error": { + "$ref": "#/definitions/google.rpc.Status" + } + }, + "title": "Stream result of arista.serviceaccount.v1.AccountConfigStreamResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "time.start", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + }, + { + "name": "time.end", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + } + ], + "tags": [ + "AccountConfigService" + ] + }, + "delete": { + "operationId": "AccountConfigService_DeleteAll", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountConfigDeleteAllResponse" + }, + "error": { + "$ref": "#/definitions/google.rpc.Status" + } + }, + "title": "Stream result of arista.serviceaccount.v1.AccountConfigDeleteAllResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "tags": [ + "AccountConfigService" + ] + }, + "post": { + "operationId": "AccountConfigService_GetAll2", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountConfigStreamResponse" + }, + "error": { + "$ref": "#/definitions/google.rpc.Status" + } + }, + "title": "Stream result of arista.serviceaccount.v1.AccountConfigStreamResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountConfigStreamRequest" + } + } + ], + "tags": [ + "AccountConfigService" + ] + } + }, + "/api/resources/serviceaccount/v1/AccountConfig/deletesome": { + "post": { + "operationId": "AccountConfigService_DeleteSome", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountConfigDeleteSomeResponse" + }, + "error": { + "$ref": "#/definitions/google.rpc.Status" + } + }, + "title": "Stream result of arista.serviceaccount.v1.AccountConfigDeleteSomeResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "keys", + "description": "key contains a list of AccountConfig keys to delete", + "in": "body", + "required": true, + "schema": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/arista.serviceaccount.v1.AccountKey" + } + } + } + ], + "tags": [ + "AccountConfigService" + ] + } + }, + "/api/resources/serviceaccount/v1/AccountConfig/getsome": { + "post": { + "operationId": "AccountConfigService_GetSome", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountConfigSomeResponse" + }, + "error": { + "$ref": "#/definitions/google.rpc.Status" + } + }, + "title": "Stream result of arista.serviceaccount.v1.AccountConfigSomeResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "keys", + "in": "body", + "required": true, + "schema": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/arista.serviceaccount.v1.AccountKey" + } + } + }, + { + "name": "time", + "description": "Time indicates the time for which you are interested in the data.\nIf no time is given, the server will use the time at which it makes the request.", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + } + ], + "tags": [ + "AccountConfigService" + ] + } + }, + "/api/resources/serviceaccount/v1/AccountConfig/metadata": { + "get": { + "operationId": "AccountConfigService_GetMeta", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/arista.serviceaccount.v1.MetaResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "time.start", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + }, + { + "name": "time.end", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + } + ], + "tags": [ + "AccountConfigService" + ] + }, + "post": { + "operationId": "AccountConfigService_GetMeta2", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/arista.serviceaccount.v1.MetaResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountConfigStreamRequest" + } + } + ], + "tags": [ + "AccountConfigService" + ] + } + }, + "/api/resources/serviceaccount/v1/AccountConfig/some": { + "post": { + "operationId": "AccountConfigService_SetSome", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountConfigSetSomeResponse" + }, + "error": { + "$ref": "#/definitions/google.rpc.Status" + } + }, + "title": "Stream result of arista.serviceaccount.v1.AccountConfigSetSomeResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "values", + "description": "value contains a list of AccountConfig values to write.\nIt is possible to provide more values than can fit within either:\n - the maxiumum send size of the client\n - the maximum receive size of the server\nIf this error occurs you must reduce the number of values sent.\nSee gRPC \"maximum message size\" documentation for more information.", + "in": "body", + "required": true, + "schema": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/arista.serviceaccount.v1.AccountConfig" + } + } + } + ], + "tags": [ + "AccountConfigService" + ] + } + }, + "/api/resources/serviceaccount/v1/AccountConfig/watch": { + "get": { + "operationId": "AccountConfigService_Subscribe", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountConfigStreamResponse" + }, + "error": { + "$ref": "#/definitions/google.rpc.Status" + } + }, + "title": "Stream result of arista.serviceaccount.v1.AccountConfigStreamResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "time.start", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + }, + { + "name": "time.end", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + } + ], + "tags": [ + "AccountConfigService" + ] + }, + "post": { + "operationId": "AccountConfigService_Subscribe2", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountConfigStreamResponse" + }, + "error": { + "$ref": "#/definitions/google.rpc.Status" + } + }, + "title": "Stream result of arista.serviceaccount.v1.AccountConfigStreamResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountConfigStreamRequest" + } + } + ], + "tags": [ + "AccountConfigService" + ] + } + }, + "/api/resources/serviceaccount/v1/AccountConfig/watchmetadata": { + "get": { + "operationId": "AccountConfigService_SubscribeMeta", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/arista.serviceaccount.v1.MetaResponse" + }, + "error": { + "$ref": "#/definitions/google.rpc.Status" + } + }, + "title": "Stream result of arista.serviceaccount.v1.MetaResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "time.start", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + }, + { + "name": "time.end", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + } + ], + "tags": [ + "AccountConfigService" + ] + }, + "post": { + "operationId": "AccountConfigService_SubscribeMeta2", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/arista.serviceaccount.v1.MetaResponse" + }, + "error": { + "$ref": "#/definitions/google.rpc.Status" + } + }, + "title": "Stream result of arista.serviceaccount.v1.MetaResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountConfigStreamRequest" + } + } + ], + "tags": [ + "AccountConfigService" + ] + } + }, + "/api/resources/serviceaccount/v1/Token": { + "get": { + "operationId": "TokenService_GetOne", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "key.id", + "description": "id is the unique identifier of the service account token.", + "in": "query", + "required": true, + "type": "string" + }, + { + "name": "time", + "description": "Time indicates the time for which you are interested in the data.\nIf no time is given, the server will use the time at which it makes the request.", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + } + ], + "tags": [ + "TokenService" + ] + } + }, + "/api/resources/serviceaccount/v1/Token/all": { + "get": { + "operationId": "TokenService_GetAll", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenStreamResponse" + }, + "error": { + "$ref": "#/definitions/google.rpc.Status" + } + }, + "title": "Stream result of arista.serviceaccount.v1.TokenStreamResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "time.start", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + }, + { + "name": "time.end", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + } + ], + "tags": [ + "TokenService" + ] + }, + "post": { + "operationId": "TokenService_GetAll2", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenStreamResponse" + }, + "error": { + "$ref": "#/definitions/google.rpc.Status" + } + }, + "title": "Stream result of arista.serviceaccount.v1.TokenStreamResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenStreamRequest" + } + } + ], + "tags": [ + "TokenService" + ] + } + }, + "/api/resources/serviceaccount/v1/Token/getsome": { + "post": { + "operationId": "TokenService_GetSome", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenSomeResponse" + }, + "error": { + "$ref": "#/definitions/google.rpc.Status" + } + }, + "title": "Stream result of arista.serviceaccount.v1.TokenSomeResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "keys", + "in": "body", + "required": true, + "schema": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/arista.serviceaccount.v1.TokenKey" + } + } + }, + { + "name": "time", + "description": "Time indicates the time for which you are interested in the data.\nIf no time is given, the server will use the time at which it makes the request.", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + } + ], + "tags": [ + "TokenService" + ] + } + }, + "/api/resources/serviceaccount/v1/Token/metadata": { + "get": { + "operationId": "TokenService_GetMeta", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/arista.serviceaccount.v1.MetaResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "time.start", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + }, + { + "name": "time.end", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + } + ], + "tags": [ + "TokenService" + ] + }, + "post": { + "operationId": "TokenService_GetMeta2", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/arista.serviceaccount.v1.MetaResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenStreamRequest" + } + } + ], + "tags": [ + "TokenService" + ] + } + }, + "/api/resources/serviceaccount/v1/Token/watch": { + "get": { + "operationId": "TokenService_Subscribe", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenStreamResponse" + }, + "error": { + "$ref": "#/definitions/google.rpc.Status" + } + }, + "title": "Stream result of arista.serviceaccount.v1.TokenStreamResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "time.start", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + }, + { + "name": "time.end", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + } + ], + "tags": [ + "TokenService" + ] + }, + "post": { + "operationId": "TokenService_Subscribe2", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenStreamResponse" + }, + "error": { + "$ref": "#/definitions/google.rpc.Status" + } + }, + "title": "Stream result of arista.serviceaccount.v1.TokenStreamResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenStreamRequest" + } + } + ], + "tags": [ + "TokenService" + ] + } + }, + "/api/resources/serviceaccount/v1/Token/watchmetadata": { + "get": { + "operationId": "TokenService_SubscribeMeta", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/arista.serviceaccount.v1.MetaResponse" + }, + "error": { + "$ref": "#/definitions/google.rpc.Status" + } + }, + "title": "Stream result of arista.serviceaccount.v1.MetaResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "time.start", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + }, + { + "name": "time.end", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + } + ], + "tags": [ + "TokenService" + ] + }, + "post": { + "operationId": "TokenService_SubscribeMeta2", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/arista.serviceaccount.v1.MetaResponse" + }, + "error": { + "$ref": "#/definitions/google.rpc.Status" + } + }, + "title": "Stream result of arista.serviceaccount.v1.MetaResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenStreamRequest" + } + } + ], + "tags": [ + "TokenService" + ] + } + }, + "/api/resources/serviceaccount/v1/TokenConfig": { + "get": { + "operationId": "TokenConfigService_GetOne", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenConfigResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "key.id", + "description": "id is the unique identifier of the service account token.", + "in": "query", + "required": true, + "type": "string" + }, + { + "name": "time", + "description": "Time indicates the time for which you are interested in the data.\nIf no time is given, the server will use the time at which it makes the request.", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + } + ], + "tags": [ + "TokenConfigService" + ] + }, + "delete": { + "operationId": "TokenConfigService_Delete", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenConfigDeleteResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "key.id", + "description": "id is the unique identifier of the service account token.", + "in": "query", + "required": true, + "type": "string" + } + ], + "tags": [ + "TokenConfigService" + ] + }, + "post": { + "operationId": "TokenConfigService_Set", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenConfigSetResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "value", + "description": "TokenConfig carries the value to set into the datastore.\nSee the documentation on the TokenConfig struct for which fields are required.", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenConfig" + } + } + ], + "tags": [ + "TokenConfigService" + ] + } + }, + "/api/resources/serviceaccount/v1/TokenConfig/all": { + "get": { + "operationId": "TokenConfigService_GetAll", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenConfigStreamResponse" + }, + "error": { + "$ref": "#/definitions/google.rpc.Status" + } + }, + "title": "Stream result of arista.serviceaccount.v1.TokenConfigStreamResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "time.start", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + }, + { + "name": "time.end", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + } + ], + "tags": [ + "TokenConfigService" + ] + }, + "delete": { + "operationId": "TokenConfigService_DeleteAll", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenConfigDeleteAllResponse" + }, + "error": { + "$ref": "#/definitions/google.rpc.Status" + } + }, + "title": "Stream result of arista.serviceaccount.v1.TokenConfigDeleteAllResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "tags": [ + "TokenConfigService" + ] + }, + "post": { + "operationId": "TokenConfigService_GetAll2", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenConfigStreamResponse" + }, + "error": { + "$ref": "#/definitions/google.rpc.Status" + } + }, + "title": "Stream result of arista.serviceaccount.v1.TokenConfigStreamResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenConfigStreamRequest" + } + } + ], + "tags": [ + "TokenConfigService" + ] + } + }, + "/api/resources/serviceaccount/v1/TokenConfig/deletesome": { + "post": { + "operationId": "TokenConfigService_DeleteSome", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenConfigDeleteSomeResponse" + }, + "error": { + "$ref": "#/definitions/google.rpc.Status" + } + }, + "title": "Stream result of arista.serviceaccount.v1.TokenConfigDeleteSomeResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "keys", + "description": "key contains a list of TokenConfig keys to delete", + "in": "body", + "required": true, + "schema": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/arista.serviceaccount.v1.TokenKey" + } + } + } + ], + "tags": [ + "TokenConfigService" + ] + } + }, + "/api/resources/serviceaccount/v1/TokenConfig/getsome": { + "post": { + "operationId": "TokenConfigService_GetSome", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenConfigSomeResponse" + }, + "error": { + "$ref": "#/definitions/google.rpc.Status" + } + }, + "title": "Stream result of arista.serviceaccount.v1.TokenConfigSomeResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "keys", + "in": "body", + "required": true, + "schema": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/arista.serviceaccount.v1.TokenKey" + } + } + }, + { + "name": "time", + "description": "Time indicates the time for which you are interested in the data.\nIf no time is given, the server will use the time at which it makes the request.", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + } + ], + "tags": [ + "TokenConfigService" + ] + } + }, + "/api/resources/serviceaccount/v1/TokenConfig/metadata": { + "get": { + "operationId": "TokenConfigService_GetMeta", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/arista.serviceaccount.v1.MetaResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "time.start", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + }, + { + "name": "time.end", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + } + ], + "tags": [ + "TokenConfigService" + ] + }, + "post": { + "operationId": "TokenConfigService_GetMeta2", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/arista.serviceaccount.v1.MetaResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenConfigStreamRequest" + } + } + ], + "tags": [ + "TokenConfigService" + ] + } + }, + "/api/resources/serviceaccount/v1/TokenConfig/some": { + "post": { + "operationId": "TokenConfigService_SetSome", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenConfigSetSomeResponse" + }, + "error": { + "$ref": "#/definitions/google.rpc.Status" + } + }, + "title": "Stream result of arista.serviceaccount.v1.TokenConfigSetSomeResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "values", + "description": "value contains a list of TokenConfig values to write.\nIt is possible to provide more values than can fit within either:\n - the maxiumum send size of the client\n - the maximum receive size of the server\nIf this error occurs you must reduce the number of values sent.\nSee gRPC \"maximum message size\" documentation for more information.", + "in": "body", + "required": true, + "schema": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/arista.serviceaccount.v1.TokenConfig" + } + } + } + ], + "tags": [ + "TokenConfigService" + ] + } + }, + "/api/resources/serviceaccount/v1/TokenConfig/watch": { + "get": { + "operationId": "TokenConfigService_Subscribe", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenConfigStreamResponse" + }, + "error": { + "$ref": "#/definitions/google.rpc.Status" + } + }, + "title": "Stream result of arista.serviceaccount.v1.TokenConfigStreamResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "time.start", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + }, + { + "name": "time.end", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + } + ], + "tags": [ + "TokenConfigService" + ] + }, + "post": { + "operationId": "TokenConfigService_Subscribe2", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenConfigStreamResponse" + }, + "error": { + "$ref": "#/definitions/google.rpc.Status" + } + }, + "title": "Stream result of arista.serviceaccount.v1.TokenConfigStreamResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenConfigStreamRequest" + } + } + ], + "tags": [ + "TokenConfigService" + ] + } + }, + "/api/resources/serviceaccount/v1/TokenConfig/watchmetadata": { + "get": { + "operationId": "TokenConfigService_SubscribeMeta", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/arista.serviceaccount.v1.MetaResponse" + }, + "error": { + "$ref": "#/definitions/google.rpc.Status" + } + }, + "title": "Stream result of arista.serviceaccount.v1.MetaResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "time.start", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + }, + { + "name": "time.end", + "in": "query", + "required": false, + "type": "string", + "format": "date-time" + } + ], + "tags": [ + "TokenConfigService" + ] + }, + "post": { + "operationId": "TokenConfigService_SubscribeMeta2", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/arista.serviceaccount.v1.MetaResponse" + }, + "error": { + "$ref": "#/definitions/google.rpc.Status" + } + }, + "title": "Stream result of arista.serviceaccount.v1.MetaResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/google.rpc.Status" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenConfigStreamRequest" + } + } + ], + "tags": [ + "TokenConfigService" + ] + } + } + }, + "definitions": { + "arista.serviceaccount.v1.Account": { + "type": "object", + "properties": { + "key": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountKey", + "description": "key uniquely identifies the service account." + }, + "status": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountStatus", + "description": "status determines whether the service account is enabled or disabled." + }, + "description": { + "type": "string", + "description": "description is a comment describing the service account." + }, + "groups": { + "$ref": "#/definitions/fmp.RepeatedString", + "description": "groups is a list of roles that the service account inherits permissions from." + }, + "createdBy": { + "type": "string", + "description": "created_by is the name of the entity that created the service account." + }, + "lastAccess": { + "type": "string", + "format": "date-time", + "description": "last_access is the time when the service account was last fetched." + } + }, + "description": "Account describes a service account." + }, + "arista.serviceaccount.v1.AccountConfig": { + "type": "object", + "properties": { + "key": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountKey", + "description": "key contains the name of the service account." + }, + "status": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountStatus", + "description": "status determines if the service account is enabled or disabled. New service accounts are\nenabled by default." + }, + "description": { + "type": "string", + "description": "description is a comment describing the service account." + }, + "groups": { + "$ref": "#/definitions/fmp.RepeatedString", + "description": "groups is a list of roles that the service account inherits permissions from." + } + }, + "description": "AccountConfig holds the configuration for a service account." + }, + "arista.serviceaccount.v1.AccountConfigDeleteAllResponse": { + "type": "object", + "properties": { + "type": { + "$ref": "#/definitions/fmp.DeleteError", + "description": "This describes the class of delete error." + }, + "error": { + "type": "string", + "description": "This indicates the error message from the delete failure." + }, + "key": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountKey", + "description": "This is the key of the AccountConfig instance that failed to be deleted." + }, + "time": { + "type": "string", + "format": "date-time", + "description": "Time indicates the (UTC) timestamp when the key was being deleted." + } + } + }, + "arista.serviceaccount.v1.AccountConfigDeleteResponse": { + "type": "object", + "properties": { + "key": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountKey", + "description": "Key echoes back the key of the deleted AccountConfig instance." + }, + "time": { + "type": "string", + "format": "date-time", + "description": "- it is after the time the request was received\n - a time-ranged query with StartTime==DeletedAt will not include this instance.", + "title": "Time indicates the (UTC) timestamp at which the system recognizes the\ndeletion. The only guarantees made about this timestamp are:" + } + } + }, + "arista.serviceaccount.v1.AccountConfigDeleteSomeResponse": { + "type": "object", + "properties": { + "key": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountKey" + }, + "error": { + "type": "string" + } + }, + "description": "AccountConfigDeleteSomeResponse is only sent when there is an error." + }, + "arista.serviceaccount.v1.AccountConfigResponse": { + "type": "object", + "properties": { + "value": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountConfig", + "description": "Value is the value requested.\nThis structure will be fully-populated as it exists in the datastore. If\noptional fields were not given at creation, these fields will be empty or\nset to default values." + }, + "time": { + "type": "string", + "format": "date-time", + "description": "Time carries the (UTC) timestamp of the last-modification of the\nAccountConfig instance in this response." + } + } + }, + "arista.serviceaccount.v1.AccountConfigSetResponse": { + "type": "object", + "properties": { + "value": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountConfig", + "description": "Value carries all the values given in the AccountConfigSetRequest as well\nas any server-generated values." + }, + "time": { + "type": "string", + "format": "date-time", + "description": "- it is after the time the request was received\n - a time-ranged query with StartTime==CreatedAt will include this instance.", + "title": "Time indicates the (UTC) timestamp at which the system recognizes the\ncreation. The only guarantees made about this timestamp are:" + } + } + }, + "arista.serviceaccount.v1.AccountConfigSetSomeResponse": { + "type": "object", + "properties": { + "key": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountKey" + }, + "error": { + "type": "string" + } + } + }, + "arista.serviceaccount.v1.AccountConfigSomeResponse": { + "type": "object", + "properties": { + "value": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountConfig", + "description": "Value is the value requested.\nThis structure will be fully-populated as it exists in the datastore. If\noptional fields were not given at creation, these fields will be empty or\nset to default values." + }, + "error": { + "type": "string", + "description": "Error is an optional field.\nIt should be filled when there is an error in the GetSome process." + }, + "time": { + "type": "string", + "format": "date-time" + } + } + }, + "arista.serviceaccount.v1.AccountConfigStreamRequest": { + "type": "object", + "properties": { + "partialEqFilter": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/arista.serviceaccount.v1.AccountConfig" + }, + "description": "PartialEqFilter provides a way to server-side filter a GetAll/Subscribe.\nThis requires all provided fields to be equal to the response.\n\nWhile transparent to users, this field also allows services to optimize internal\nsubscriptions if filter(s) are sufficiently specific." + }, + "time": { + "$ref": "#/definitions/arista.time.TimeBounds", + "description": "TimeRange allows limiting response data to within a specified time window.\nIf this field is populated, at least one of the two time fields are required.\n\nFor GetAll, the fields start and end can be used as follows:\n\n * end: Returns the state of each AccountConfig at end.\n * Each AccountConfig response is fully-specified (all fields set).\n * start: Returns the state of each AccountConfig at start, followed by updates until now.\n * Each AccountConfig response at start is fully-specified, but updates may be partial.\n * start and end: Returns the state of each AccountConfig at start, followed by updates\n until end.\n * Each AccountConfig response at start is fully-specified, but updates until end may\n be partial.\n\nThis field is not allowed in the Subscribe RPC." + } + } + }, + "arista.serviceaccount.v1.AccountConfigStreamResponse": { + "type": "object", + "properties": { + "value": { + "$ref": "#/definitions/arista.serviceaccount.v1.AccountConfig", + "description": "Value is a value deemed relevant to the initiating request.\nThis structure will always have its key-field populated. Which other fields are\npopulated, and why, depends on the value of Operation and what triggered this notification." + }, + "time": { + "type": "string", + "format": "date-time", + "description": "Time holds the timestamp of this AccountConfig's last modification." + }, + "type": { + "$ref": "#/definitions/arista.subscriptions.Operation", + "description": "Operation indicates how the AccountConfig value in this response should be considered.\nUnder non-subscribe requests, this value should always be INITIAL. In a subscription,\nonce all initial data is streamed and the client begins to receive modification updates,\nyou should not see INITIAL again." + } + } + }, + "arista.serviceaccount.v1.AccountKey": { + "type": "object", + "properties": { + "name": { + "type": "string", + "description": "name is the unique identifier of the service account." + } + }, + "description": "AccountKey contains the name of the service account.", + "required": [ + "name" + ] + }, + "arista.serviceaccount.v1.AccountResponse": { + "type": "object", + "properties": { + "value": { + "$ref": "#/definitions/arista.serviceaccount.v1.Account", + "description": "Value is the value requested.\nThis structure will be fully-populated as it exists in the datastore. If\noptional fields were not given at creation, these fields will be empty or\nset to default values." + }, + "time": { + "type": "string", + "format": "date-time", + "description": "Time carries the (UTC) timestamp of the last-modification of the\nAccount instance in this response." + } + } + }, + "arista.serviceaccount.v1.AccountSomeResponse": { + "type": "object", + "properties": { + "value": { + "$ref": "#/definitions/arista.serviceaccount.v1.Account", + "description": "Value is the value requested.\nThis structure will be fully-populated as it exists in the datastore. If\noptional fields were not given at creation, these fields will be empty or\nset to default values." + }, + "error": { + "type": "string", + "description": "Error is an optional field.\nIt should be filled when there is an error in the GetSome process." + }, + "time": { + "type": "string", + "format": "date-time" + } + } + }, + "arista.serviceaccount.v1.AccountStatus": { + "type": "string", + "enum": [ + "ACCOUNT_STATUS_UNSPECIFIED", + "ACCOUNT_STATUS_ENABLED", + "ACCOUNT_STATUS_DISABLED" + ], + "default": "ACCOUNT_STATUS_UNSPECIFIED", + "description": "AccountStatus determines whether an service account is enabled or disabled.\n\n - ACCOUNT_STATUS_UNSPECIFIED: ACCOUNT_STATUS_UNSPECIFIED indicates the service account status is unspecified.\n - ACCOUNT_STATUS_ENABLED: ACCOUNT_STATUS_ENABLED indicates the service account is enabled.\n - ACCOUNT_STATUS_DISABLED: ACCOUNT_STATUS_DISABLED indicates the service account is disabled." + }, + "arista.serviceaccount.v1.AccountStreamRequest": { + "type": "object", + "properties": { + "partialEqFilter": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/arista.serviceaccount.v1.Account" + }, + "description": "PartialEqFilter provides a way to server-side filter a GetAll/Subscribe.\nThis requires all provided fields to be equal to the response.\n\nWhile transparent to users, this field also allows services to optimize internal\nsubscriptions if filter(s) are sufficiently specific." + }, + "time": { + "$ref": "#/definitions/arista.time.TimeBounds", + "description": "TimeRange allows limiting response data to within a specified time window.\nIf this field is populated, at least one of the two time fields are required.\n\nFor GetAll, the fields start and end can be used as follows:\n\n * end: Returns the state of each Account at end.\n * Each Account response is fully-specified (all fields set).\n * start: Returns the state of each Account at start, followed by updates until now.\n * Each Account response at start is fully-specified, but updates may be partial.\n * start and end: Returns the state of each Account at start, followed by updates\n until end.\n * Each Account response at start is fully-specified, but updates until end may\n be partial.\n\nThis field is not allowed in the Subscribe RPC." + } + } + }, + "arista.serviceaccount.v1.AccountStreamResponse": { + "type": "object", + "properties": { + "value": { + "$ref": "#/definitions/arista.serviceaccount.v1.Account", + "description": "Value is a value deemed relevant to the initiating request.\nThis structure will always have its key-field populated. Which other fields are\npopulated, and why, depends on the value of Operation and what triggered this notification." + }, + "time": { + "type": "string", + "format": "date-time", + "description": "Time holds the timestamp of this Account's last modification." + }, + "type": { + "$ref": "#/definitions/arista.subscriptions.Operation", + "description": "Operation indicates how the Account value in this response should be considered.\nUnder non-subscribe requests, this value should always be INITIAL. In a subscription,\nonce all initial data is streamed and the client begins to receive modification updates,\nyou should not see INITIAL again." + } + } + }, + "arista.serviceaccount.v1.MetaResponse": { + "type": "object", + "properties": { + "time": { + "type": "string", + "format": "date-time", + "description": "Time holds the timestamp of the last item included in the metadata calculation." + }, + "type": { + "$ref": "#/definitions/arista.subscriptions.Operation", + "description": "Operation indicates how the value in this response should be considered.\nUnder non-subscribe requests, this value should always be INITIAL. In a subscription,\nonce all initial data is streamed and the client begins to receive modification updates,\nyou should not see INITIAL again." + }, + "count": { + "type": "integer", + "format": "int64", + "description": "Count is the number of items present under the conditions of the request." + } + } + }, + "arista.serviceaccount.v1.Token": { + "type": "object", + "properties": { + "key": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenKey", + "description": "key uniquely identifies the service account token." + }, + "user": { + "type": "string", + "description": "user is the name of the service account that the token is generated for." + }, + "description": { + "type": "string", + "description": "description is a short name or comment used to identify the service account token." + }, + "validUntil": { + "type": "string", + "format": "date-time", + "description": "valid_until is the time that the service account token will be valid until." + }, + "createdBy": { + "type": "string", + "description": "created_by is the name of the entity that created the service account token." + }, + "lastUsed": { + "type": "string", + "format": "date-time", + "description": "last_used is the time when the service account token was last used to authenticate." + } + }, + "description": "Token describes a service account token." + }, + "arista.serviceaccount.v1.TokenConfig": { + "type": "object", + "properties": { + "key": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenKey", + "description": "key uniquely identifies the service account token." + }, + "user": { + "type": "string", + "description": "user is the name of the service account that the token is generated for." + }, + "description": { + "type": "string", + "description": "description is a short name or comment used to identify the service account token." + }, + "validFor": { + "type": "string", + "description": "valid_for determines the duration that the service account token will be valid for." + }, + "token": { + "type": "string", + "description": "token is the JWT token generated for a service account token.\nIt is only populated in Set response." + } + }, + "description": "TokenConfig holds the configuration for a service account token. The token is a signed JWT which\ncan be used as a credential for REST and WRPC endpoints." + }, + "arista.serviceaccount.v1.TokenConfigDeleteAllResponse": { + "type": "object", + "properties": { + "type": { + "$ref": "#/definitions/fmp.DeleteError", + "description": "This describes the class of delete error." + }, + "error": { + "type": "string", + "description": "This indicates the error message from the delete failure." + }, + "key": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenKey", + "description": "This is the key of the TokenConfig instance that failed to be deleted." + }, + "time": { + "type": "string", + "format": "date-time", + "description": "Time indicates the (UTC) timestamp when the key was being deleted." + } + } + }, + "arista.serviceaccount.v1.TokenConfigDeleteResponse": { + "type": "object", + "properties": { + "key": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenKey", + "description": "Key echoes back the key of the deleted TokenConfig instance." + }, + "time": { + "type": "string", + "format": "date-time", + "description": "- it is after the time the request was received\n - a time-ranged query with StartTime==DeletedAt will not include this instance.", + "title": "Time indicates the (UTC) timestamp at which the system recognizes the\ndeletion. The only guarantees made about this timestamp are:" + } + } + }, + "arista.serviceaccount.v1.TokenConfigDeleteSomeResponse": { + "type": "object", + "properties": { + "key": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenKey" + }, + "error": { + "type": "string" + } + }, + "description": "TokenConfigDeleteSomeResponse is only sent when there is an error." + }, + "arista.serviceaccount.v1.TokenConfigResponse": { + "type": "object", + "properties": { + "value": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenConfig", + "description": "Value is the value requested.\nThis structure will be fully-populated as it exists in the datastore. If\noptional fields were not given at creation, these fields will be empty or\nset to default values." + }, + "time": { + "type": "string", + "format": "date-time", + "description": "Time carries the (UTC) timestamp of the last-modification of the\nTokenConfig instance in this response." + } + } + }, + "arista.serviceaccount.v1.TokenConfigSetResponse": { + "type": "object", + "properties": { + "value": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenConfig", + "description": "Value carries all the values given in the TokenConfigSetRequest as well\nas any server-generated values." + }, + "time": { + "type": "string", + "format": "date-time", + "description": "- it is after the time the request was received\n - a time-ranged query with StartTime==CreatedAt will include this instance.", + "title": "Time indicates the (UTC) timestamp at which the system recognizes the\ncreation. The only guarantees made about this timestamp are:" + } + } + }, + "arista.serviceaccount.v1.TokenConfigSetSomeResponse": { + "type": "object", + "properties": { + "key": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenKey" + }, + "error": { + "type": "string" + } + } + }, + "arista.serviceaccount.v1.TokenConfigSomeResponse": { + "type": "object", + "properties": { + "value": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenConfig", + "description": "Value is the value requested.\nThis structure will be fully-populated as it exists in the datastore. If\noptional fields were not given at creation, these fields will be empty or\nset to default values." + }, + "error": { + "type": "string", + "description": "Error is an optional field.\nIt should be filled when there is an error in the GetSome process." + }, + "time": { + "type": "string", + "format": "date-time" + } + } + }, + "arista.serviceaccount.v1.TokenConfigStreamRequest": { + "type": "object", + "properties": { + "partialEqFilter": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/arista.serviceaccount.v1.TokenConfig" + }, + "description": "PartialEqFilter provides a way to server-side filter a GetAll/Subscribe.\nThis requires all provided fields to be equal to the response.\n\nWhile transparent to users, this field also allows services to optimize internal\nsubscriptions if filter(s) are sufficiently specific." + }, + "time": { + "$ref": "#/definitions/arista.time.TimeBounds", + "description": "TimeRange allows limiting response data to within a specified time window.\nIf this field is populated, at least one of the two time fields are required.\n\nFor GetAll, the fields start and end can be used as follows:\n\n * end: Returns the state of each TokenConfig at end.\n * Each TokenConfig response is fully-specified (all fields set).\n * start: Returns the state of each TokenConfig at start, followed by updates until now.\n * Each TokenConfig response at start is fully-specified, but updates may be partial.\n * start and end: Returns the state of each TokenConfig at start, followed by updates\n until end.\n * Each TokenConfig response at start is fully-specified, but updates until end may\n be partial.\n\nThis field is not allowed in the Subscribe RPC." + } + } + }, + "arista.serviceaccount.v1.TokenConfigStreamResponse": { + "type": "object", + "properties": { + "value": { + "$ref": "#/definitions/arista.serviceaccount.v1.TokenConfig", + "description": "Value is a value deemed relevant to the initiating request.\nThis structure will always have its key-field populated. Which other fields are\npopulated, and why, depends on the value of Operation and what triggered this notification." + }, + "time": { + "type": "string", + "format": "date-time", + "description": "Time holds the timestamp of this TokenConfig's last modification." + }, + "type": { + "$ref": "#/definitions/arista.subscriptions.Operation", + "description": "Operation indicates how the TokenConfig value in this response should be considered.\nUnder non-subscribe requests, this value should always be INITIAL. In a subscription,\nonce all initial data is streamed and the client begins to receive modification updates,\nyou should not see INITIAL again." + } + } + }, + "arista.serviceaccount.v1.TokenKey": { + "type": "object", + "properties": { + "id": { + "type": "string", + "description": "id is the unique identifier of the service account token." + } + }, + "description": "TokenKey contains service account token ID.", + "required": [ + "id" + ] + }, + "arista.serviceaccount.v1.TokenResponse": { + "type": "object", + "properties": { + "value": { + "$ref": "#/definitions/arista.serviceaccount.v1.Token", + "description": "Value is the value requested.\nThis structure will be fully-populated as it exists in the datastore. If\noptional fields were not given at creation, these fields will be empty or\nset to default values." + }, + "time": { + "type": "string", + "format": "date-time", + "description": "Time carries the (UTC) timestamp of the last-modification of the\nToken instance in this response." + } + } + }, + "arista.serviceaccount.v1.TokenSomeResponse": { + "type": "object", + "properties": { + "value": { + "$ref": "#/definitions/arista.serviceaccount.v1.Token", + "description": "Value is the value requested.\nThis structure will be fully-populated as it exists in the datastore. If\noptional fields were not given at creation, these fields will be empty or\nset to default values." + }, + "error": { + "type": "string", + "description": "Error is an optional field.\nIt should be filled when there is an error in the GetSome process." + }, + "time": { + "type": "string", + "format": "date-time" + } + } + }, + "arista.serviceaccount.v1.TokenStreamRequest": { + "type": "object", + "properties": { + "partialEqFilter": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/arista.serviceaccount.v1.Token" + }, + "description": "PartialEqFilter provides a way to server-side filter a GetAll/Subscribe.\nThis requires all provided fields to be equal to the response.\n\nWhile transparent to users, this field also allows services to optimize internal\nsubscriptions if filter(s) are sufficiently specific." + }, + "time": { + "$ref": "#/definitions/arista.time.TimeBounds", + "description": "TimeRange allows limiting response data to within a specified time window.\nIf this field is populated, at least one of the two time fields are required.\n\nFor GetAll, the fields start and end can be used as follows:\n\n * end: Returns the state of each Token at end.\n * Each Token response is fully-specified (all fields set).\n * start: Returns the state of each Token at start, followed by updates until now.\n * Each Token response at start is fully-specified, but updates may be partial.\n * start and end: Returns the state of each Token at start, followed by updates\n until end.\n * Each Token response at start is fully-specified, but updates until end may\n be partial.\n\nThis field is not allowed in the Subscribe RPC." + } + } + }, + "arista.serviceaccount.v1.TokenStreamResponse": { + "type": "object", + "properties": { + "value": { + "$ref": "#/definitions/arista.serviceaccount.v1.Token", + "description": "Value is a value deemed relevant to the initiating request.\nThis structure will always have its key-field populated. Which other fields are\npopulated, and why, depends on the value of Operation and what triggered this notification." + }, + "time": { + "type": "string", + "format": "date-time", + "description": "Time holds the timestamp of this Token's last modification." + }, + "type": { + "$ref": "#/definitions/arista.subscriptions.Operation", + "description": "Operation indicates how the Token value in this response should be considered.\nUnder non-subscribe requests, this value should always be INITIAL. In a subscription,\nonce all initial data is streamed and the client begins to receive modification updates,\nyou should not see INITIAL again." + } + } + }, + "arista.subscriptions.Operation": { + "type": "string", + "enum": [ + "UNSPECIFIED", + "INITIAL", + "INITIAL_SYNC_COMPLETE", + "UPDATED", + "DELETED" + ], + "default": "UNSPECIFIED", + "description": " - INITIAL: INITIAL indicates the associated notification is that of the\ncurrent state and a fully-specified Resource is provided.\n - INITIAL_SYNC_COMPLETE: INITIAL_SYNC_COMPLETE indicates all existing-state has been\nstreamed to the client. This status will be sent in an\notherwise-empty message and no subsequent INITIAL messages\nshould be expected.\n - UPDATED: UPDATED indicates the associated notification carries\nmodification to the last-streamed state. This indicates\nthe contained Resource may be a partial diff, though, it\nmay contain a fully-specified Resource.\n - DELETED: DETLETED indicates the associated notification carries\na deletion. The Resource's key will always be set in this case,\nbut no other fields should be expected." + }, + "arista.time.TimeBounds": { + "type": "object", + "properties": { + "start": { + "type": "string", + "format": "date-time" + }, + "end": { + "type": "string", + "format": "date-time" + } + } + }, + "fmp.DeleteError": { + "type": "string", + "enum": [ + "DELETE_ERROR_UNSPECIFIED", + "DELETE_ERROR_UNAUTHORIZED", + "DELETE_ERROR_INTERNAL", + "DELETE_ERROR_UNDELETABLE_KEY" + ], + "default": "DELETE_ERROR_UNSPECIFIED", + "description": "DeleteError defines the set of delete error types.\n\n - DELETE_ERROR_UNSPECIFIED: DELETE_ERROR_UNSPECIFIED indicates that the delete error\nis not specified.\n - DELETE_ERROR_UNAUTHORIZED: DELETE_ERROR_UNAUTHORIZED indicates that the user is not authorized\nto perform the specified delete.\n - DELETE_ERROR_INTERNAL: DELETE_ERROR_INTERNAL indicates that the server encountered an\nunrecoverable error on the specified delete.\n - DELETE_ERROR_UNDELETABLE_KEY: DELETE_ERROR_UNDELETABLE_KEY indicates that the specified error is\nnot allowed by the service." + }, + "fmp.RepeatedString": { + "type": "object", + "properties": { + "values": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The repeated string values." + } + }, + "description": "Wrapper message for `repeated string`." + }, + "google.protobuf.Any": { + "type": "object", + "properties": { + "@type": { + "type": "string" + } + }, + "additionalProperties": {} + }, + "google.rpc.Status": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/google.protobuf.Any" + } + } + } + } + }, + "securityDefinitions": { + "apiToken": { + "type": "apiKey", + "name": "access_token", + "in": "header" + } + }, + "security": [ + { + "apiToken": [] + } + ], + "externalDocs": { + "description": "More on CloudVision Resource APIs", + "url": "https://aristanetworks.github.io/cloudvision-apis" + } +}