diff --git a/lib/src/platform/authorization/v2/authorization_pb.ts b/lib/src/platform/authorization/v2/authorization_pb.ts new file mode 100644 index 000000000..d5f54e076 --- /dev/null +++ b/lib/src/platform/authorization/v2/authorization_pb.ts @@ -0,0 +1,494 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.js" +// @generated from file authorization/v2/authorization.proto (package authorization.v2, syntax proto3) +/* eslint-disable */ + +import type { GenEnum, GenFile, GenMessage, GenService } from "@bufbuild/protobuf/codegenv1"; +import { enumDesc, fileDesc, messageDesc, serviceDesc } from "@bufbuild/protobuf/codegenv1"; +import { file_buf_validate_validate } from "../../buf/validate/validate_pb.js"; +import type { EntityChain, Token } from "../../entity/entity_pb.js"; +import { file_entity_entity } from "../../entity/entity_pb.js"; +import { file_google_protobuf_wrappers } from "@bufbuild/protobuf/wkt"; +import type { Action } from "../../policy/objects_pb.js"; +import { file_policy_objects } from "../../policy/objects_pb.js"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file authorization/v2/authorization.proto. + */ +export const file_authorization_v2_authorization: GenFile = /*@__PURE__*/ + fileDesc("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", [file_buf_validate_validate, file_entity_entity, file_google_protobuf_wrappers, file_policy_objects]); + +/** + * The EntityIdentifier specifies the actor in an entitlement or decision request - the PE, NPE, or PE+NPE being authorized. + * The abstraction houses the distinct entity types, PE and/or NPE combinations, or a registered resource value + * being treated as an entity in entitlement/authorization decisioning. + * + * @generated from message authorization.v2.EntityIdentifier + */ +export type EntityIdentifier = Message<"authorization.v2.EntityIdentifier"> & { + /** + * @generated from oneof authorization.v2.EntityIdentifier.identifier + */ + identifier: { + /** + * chain of one or more entities and at most 10 + * + * @generated from field: entity.EntityChain entity_chain = 1; + */ + value: EntityChain; + case: "entityChain"; + } | { + /** + * fully qualified name of the registered resource value stored in platform policy, where in + * this case the resource acts as and represents a single entity for authorization/entitlement decisioning + * + * @generated from field: string registered_resource_value_fqn = 2; + */ + value: string; + case: "registeredResourceValueFqn"; + } | { + /** + * access token (JWT), which is used to create an entity chain (comprising one or more entities) + * + * @generated from field: entity.Token token = 3; + */ + value: Token; + case: "token"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message authorization.v2.EntityIdentifier. + * Use `create(EntityIdentifierSchema)` to create a new message. + */ +export const EntityIdentifierSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_authorization_v2_authorization, 0); + +/** + * Entitlements for a given entity, mapping each attribute value FQN to any entitled actions[] + * + * @generated from message authorization.v2.EntityEntitlements + */ +export type EntityEntitlements = Message<"authorization.v2.EntityEntitlements"> & { + /** + * ephemeral id for tracking between request and response + * + * @generated from field: string ephemeral_id = 1; + */ + ephemeralId: string; + + /** + * @generated from field: map actions_per_attribute_value_fqn = 2; + */ + actionsPerAttributeValueFqn: { [key: string]: EntityEntitlements_ActionsList }; +}; + +/** + * Describes the message authorization.v2.EntityEntitlements. + * Use `create(EntityEntitlementsSchema)` to create a new message. + */ +export const EntityEntitlementsSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_authorization_v2_authorization, 1); + +/** + * @generated from message authorization.v2.EntityEntitlements.ActionsList + */ +export type EntityEntitlements_ActionsList = Message<"authorization.v2.EntityEntitlements.ActionsList"> & { + /** + * @generated from field: repeated policy.Action actions = 1; + */ + actions: Action[]; +}; + +/** + * Describes the message authorization.v2.EntityEntitlements.ActionsList. + * Use `create(EntityEntitlements_ActionsListSchema)` to create a new message. + */ +export const EntityEntitlements_ActionsListSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_authorization_v2_authorization, 1, 0); + +/** + * Either a set of attribute values (such as those on a TDF) or a registered resource value + * + * @generated from message authorization.v2.Resource + */ +export type Resource = Message<"authorization.v2.Resource"> & { + /** + * ephemeral id for tracking between request and response + * + * @generated from field: string ephemeral_id = 1; + */ + ephemeralId: string; + + /** + * @generated from oneof authorization.v2.Resource.resource + */ + resource: { + /** + * a set of attribute value FQNs, such as those on a TDF, between 1 and 20 in count + * + * @generated from field: authorization.v2.Resource.AttributeValues attribute_values = 2; + */ + value: Resource_AttributeValues; + case: "attributeValues"; + } | { + /** + * fully qualified name of the registered resource value stored in platform policy + * + * @generated from field: string registered_resource_value_fqn = 3; + */ + value: string; + case: "registeredResourceValueFqn"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message authorization.v2.Resource. + * Use `create(ResourceSchema)` to create a new message. + */ +export const ResourceSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_authorization_v2_authorization, 2); + +/** + * @generated from message authorization.v2.Resource.AttributeValues + */ +export type Resource_AttributeValues = Message<"authorization.v2.Resource.AttributeValues"> & { + /** + * @generated from field: repeated string fqns = 1; + */ + fqns: string[]; +}; + +/** + * Describes the message authorization.v2.Resource.AttributeValues. + * Use `create(Resource_AttributeValuesSchema)` to create a new message. + */ +export const Resource_AttributeValuesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_authorization_v2_authorization, 2, 0); + +/** + * @generated from message authorization.v2.ResourceDecision + */ +export type ResourceDecision = Message<"authorization.v2.ResourceDecision"> & { + /** + * ephemeral id for tracking between request and response + * + * @generated from field: string ephemeral_resource_id = 1; + */ + ephemeralResourceId: string; + + /** + * decision result + * + * @generated from field: authorization.v2.Decision decision = 2; + */ + decision: Decision; + + /** + * obligations (fully qualified values) the PEP is required to fulfill on the given resource + * i.e. https:///obl//value/ + * + * @generated from field: repeated string required_obligations = 3; + */ + requiredObligations: string[]; +}; + +/** + * Describes the message authorization.v2.ResourceDecision. + * Use `create(ResourceDecisionSchema)` to create a new message. + */ +export const ResourceDecisionSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_authorization_v2_authorization, 3); + +/** + * Can the identified entity/entities access? + * 1. one entity reference (actor) + * 2. one action + * 3. one resource + * + * If entitled, checks obligation policy: fulfillable obligations must satisfy all triggered. + * + * @generated from message authorization.v2.GetDecisionRequest + */ +export type GetDecisionRequest = Message<"authorization.v2.GetDecisionRequest"> & { + /** + * an entity must be identified for authorization decisioning + * + * @generated from field: authorization.v2.EntityIdentifier entity_identifier = 1; + */ + entityIdentifier?: EntityIdentifier; + + /** + * name on action is required + * + * @generated from field: policy.Action action = 2; + */ + action?: Action; + + /** + * @generated from field: authorization.v2.Resource resource = 3; + */ + resource?: Resource; + + /** + * obligations (fully qualified values) the requester is capable of fulfilling + * i.e. https:///obl//value/ + * + * @generated from field: repeated string fulfillable_obligation_fqns = 4; + */ + fulfillableObligationFqns: string[]; +}; + +/** + * Describes the message authorization.v2.GetDecisionRequest. + * Use `create(GetDecisionRequestSchema)` to create a new message. + */ +export const GetDecisionRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_authorization_v2_authorization, 4); + +/** + * @generated from message authorization.v2.GetDecisionResponse + */ +export type GetDecisionResponse = Message<"authorization.v2.GetDecisionResponse"> & { + /** + * decision on the resource + * + * @generated from field: authorization.v2.ResourceDecision decision = 1; + */ + decision?: ResourceDecision; +}; + +/** + * Describes the message authorization.v2.GetDecisionResponse. + * Use `create(GetDecisionResponseSchema)` to create a new message. + */ +export const GetDecisionResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_authorization_v2_authorization, 5); + +/** + * Can the identified entity/entities access? + * 1. one entity reference (actor) + * 2. one action + * 3. multiple resources + * + * If entitled, checks obligation policy: fulfillable obligations must satisfy all triggered. + * + * Note: this is a more performant bulk request for multiple resource decisions, up to 1000 per request + * + * @generated from message authorization.v2.GetDecisionMultiResourceRequest + */ +export type GetDecisionMultiResourceRequest = Message<"authorization.v2.GetDecisionMultiResourceRequest"> & { + /** + * an entity must be identified for authorization decisioning + * + * @generated from field: authorization.v2.EntityIdentifier entity_identifier = 1; + */ + entityIdentifier?: EntityIdentifier; + + /** + * name on action is required + * + * @generated from field: policy.Action action = 2; + */ + action?: Action; + + /** + * @generated from field: repeated authorization.v2.Resource resources = 3; + */ + resources: Resource[]; + + /** + * obligations (fully qualified values) the requester is capable of fulfilling + * i.e. https:///obl//value/ + * + * @generated from field: repeated string fulfillable_obligation_fqns = 4; + */ + fulfillableObligationFqns: string[]; +}; + +/** + * Describes the message authorization.v2.GetDecisionMultiResourceRequest. + * Use `create(GetDecisionMultiResourceRequestSchema)` to create a new message. + */ +export const GetDecisionMultiResourceRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_authorization_v2_authorization, 6); + +/** + * @generated from message authorization.v2.GetDecisionMultiResourceResponse + */ +export type GetDecisionMultiResourceResponse = Message<"authorization.v2.GetDecisionMultiResourceResponse"> & { + /** + * convenience flag indicating global resource decisions result (permit/deny) + * + * @generated from field: google.protobuf.BoolValue all_permitted = 1; + */ + allPermitted?: boolean; + + /** + * individual resource decisions + * + * @generated from field: repeated authorization.v2.ResourceDecision resource_decisions = 2; + */ + resourceDecisions: ResourceDecision[]; +}; + +/** + * Describes the message authorization.v2.GetDecisionMultiResourceResponse. + * Use `create(GetDecisionMultiResourceResponseSchema)` to create a new message. + */ +export const GetDecisionMultiResourceResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_authorization_v2_authorization, 7); + +/** + * Is access allowed? + * 1. Multiplexing of a Decision request + * This is a more performant bulk request for complex decisioning (i.e. multiple entity chains or actions on + * multiple resources) + * + * @generated from message authorization.v2.GetDecisionBulkRequest + */ +export type GetDecisionBulkRequest = Message<"authorization.v2.GetDecisionBulkRequest"> & { + /** + * @generated from field: repeated authorization.v2.GetDecisionMultiResourceRequest decision_requests = 1; + */ + decisionRequests: GetDecisionMultiResourceRequest[]; +}; + +/** + * Describes the message authorization.v2.GetDecisionBulkRequest. + * Use `create(GetDecisionBulkRequestSchema)` to create a new message. + */ +export const GetDecisionBulkRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_authorization_v2_authorization, 8); + +/** + * @generated from message authorization.v2.GetDecisionBulkResponse + */ +export type GetDecisionBulkResponse = Message<"authorization.v2.GetDecisionBulkResponse"> & { + /** + * @generated from field: repeated authorization.v2.GetDecisionMultiResourceResponse decision_responses = 1; + */ + decisionResponses: GetDecisionMultiResourceResponse[]; +}; + +/** + * Describes the message authorization.v2.GetDecisionBulkResponse. + * Use `create(GetDecisionBulkResponseSchema)` to create a new message. + */ +export const GetDecisionBulkResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_authorization_v2_authorization, 9); + +/** + * What is permitted to the identified entity/entities (actor), broken down as permitted actions on attribute value FQNs? + * + * Note: the v1 API parameter 'scope' has been dropped, and it is recommended to use + * GetDecision if the resource is known + * + * @generated from message authorization.v2.GetEntitlementsRequest + */ +export type GetEntitlementsRequest = Message<"authorization.v2.GetEntitlementsRequest"> & { + /** + * an entity must be identified for entitlement decisioning + * + * @generated from field: authorization.v2.EntityIdentifier entity_identifier = 1; + */ + entityIdentifier?: EntityIdentifier; + + /** + * optional parameter to return all entitled values for attribute definitions with hierarchy rules, propagating + * down the hierarchical values instead of returning solely the value that is directly entitled + * + * @generated from field: optional bool with_comprehensive_hierarchy = 2; + */ + withComprehensiveHierarchy?: boolean; +}; + +/** + * Describes the message authorization.v2.GetEntitlementsRequest. + * Use `create(GetEntitlementsRequestSchema)` to create a new message. + */ +export const GetEntitlementsRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_authorization_v2_authorization, 10); + +/** + * @generated from message authorization.v2.GetEntitlementsResponse + */ +export type GetEntitlementsResponse = Message<"authorization.v2.GetEntitlementsResponse"> & { + /** + * @generated from field: repeated authorization.v2.EntityEntitlements entitlements = 1; + */ + entitlements: EntityEntitlements[]; +}; + +/** + * Describes the message authorization.v2.GetEntitlementsResponse. + * Use `create(GetEntitlementsResponseSchema)` to create a new message. + */ +export const GetEntitlementsResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_authorization_v2_authorization, 11); + +/** + * @generated from enum authorization.v2.Decision + */ +export enum Decision { + /** + * @generated from enum value: DECISION_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * @generated from enum value: DECISION_DENY = 1; + */ + DENY = 1, + + /** + * @generated from enum value: DECISION_PERMIT = 2; + */ + PERMIT = 2, +} + +/** + * Describes the enum authorization.v2.Decision. + */ +export const DecisionSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_authorization_v2_authorization, 0); + +/** + * @generated from service authorization.v2.AuthorizationService + */ +export const AuthorizationService: GenService<{ + /** + * @generated from rpc authorization.v2.AuthorizationService.GetDecision + */ + getDecision: { + methodKind: "unary"; + input: typeof GetDecisionRequestSchema; + output: typeof GetDecisionResponseSchema; + }, + /** + * @generated from rpc authorization.v2.AuthorizationService.GetDecisionMultiResource + */ + getDecisionMultiResource: { + methodKind: "unary"; + input: typeof GetDecisionMultiResourceRequestSchema; + output: typeof GetDecisionMultiResourceResponseSchema; + }, + /** + * @generated from rpc authorization.v2.AuthorizationService.GetDecisionBulk + */ + getDecisionBulk: { + methodKind: "unary"; + input: typeof GetDecisionBulkRequestSchema; + output: typeof GetDecisionBulkResponseSchema; + }, + /** + * @generated from rpc authorization.v2.AuthorizationService.GetEntitlements + */ + getEntitlements: { + methodKind: "unary"; + input: typeof GetEntitlementsRequestSchema; + output: typeof GetEntitlementsResponseSchema; + }, +}> = /*@__PURE__*/ + serviceDesc(file_authorization_v2_authorization, 0); + diff --git a/lib/src/platform/buf/validate/validate_pb.ts b/lib/src/platform/buf/validate/validate_pb.ts index 507ae5bec..9e60e655e 100644 --- a/lib/src/platform/buf/validate/validate_pb.ts +++ b/lib/src/platform/buf/validate/validate_pb.ts @@ -1,4 +1,4 @@ -// Copyright 2023 Buf Technologies, Inc. +// Copyright 2023-2025 Buf Technologies, Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -26,13 +26,13 @@ import type { Message } from "@bufbuild/protobuf"; * Describes the file buf/validate/validate.proto. */ export const file_buf_validate_validate: GenFile = /*@__PURE__*/ - fileDesc("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", [file_google_protobuf_descriptor, file_google_protobuf_duration, file_google_protobuf_timestamp]); + fileDesc("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", [file_google_protobuf_descriptor, file_google_protobuf_duration, file_google_protobuf_timestamp]); /** - * `Constraint` represents a validation rule written in the Common Expression - * Language (CEL) syntax. Each Constraint includes a unique identifier, an + * `Rule` represents a validation rule written in the Common Expression + * Language (CEL) syntax. Each Rule includes a unique identifier, an * optional error message, and the CEL expression to evaluate. For more - * information on CEL, [see our documentation](https://github.com/bufbuild/protovalidate/blob/main/docs/cel.md). + * information, [see our documentation](https://buf.build/docs/protovalidate/schemas/custom-rules/). * * ```proto * message Foo { @@ -45,11 +45,11 @@ export const file_buf_validate_validate: GenFile = /*@__PURE__*/ * } * ``` * - * @generated from message buf.validate.Constraint + * @generated from message buf.validate.Rule */ -export type Constraint = Message<"buf.validate.Constraint"> & { +export type Rule = Message<"buf.validate.Rule"> & { /** - * `id` is a string that serves as a machine-readable name for this Constraint. + * `id` is a string that serves as a machine-readable name for this Rule. * It should be unique within its scope, which could be either a message or a field. * * @generated from field: optional string id = 1; @@ -58,7 +58,7 @@ export type Constraint = Message<"buf.validate.Constraint"> & { /** * `message` is an optional field that provides a human-readable error message - * for this Constraint when the CEL expression evaluates to false. If a + * for this Rule when the CEL expression evaluates to false. If a * non-empty message is provided, any strings resulting from the CEL * expression evaluation are ignored. * @@ -78,75 +78,127 @@ export type Constraint = Message<"buf.validate.Constraint"> & { }; /** - * Describes the message buf.validate.Constraint. - * Use `create(ConstraintSchema)` to create a new message. + * Describes the message buf.validate.Rule. + * Use `create(RuleSchema)` to create a new message. */ -export const ConstraintSchema: GenMessage = /*@__PURE__*/ +export const RuleSchema: GenMessage = /*@__PURE__*/ messageDesc(file_buf_validate_validate, 0); /** - * MessageConstraints represents validation rules that are applied to the entire message. - * It includes disabling options and a list of Constraint messages representing Common Expression Language (CEL) validation rules. + * MessageRules represents validation rules that are applied to the entire message. + * It includes disabling options and a list of Rule messages representing Common Expression Language (CEL) validation rules. * - * @generated from message buf.validate.MessageConstraints + * @generated from message buf.validate.MessageRules */ -export type MessageConstraints = Message<"buf.validate.MessageConstraints"> & { +export type MessageRules = Message<"buf.validate.MessageRules"> & { /** - * `disabled` is a boolean flag that, when set to true, nullifies any validation rules for this message. - * This includes any fields within the message that would otherwise support validation. + * `cel` is a repeated field of type Rule. Each Rule specifies a validation rule to be applied to this message. + * These rules are written in Common Expression Language (CEL) syntax. For more information, + * [see our documentation](https://buf.build/docs/protovalidate/schemas/custom-rules/). + * * * ```proto * message MyMessage { - * // validation will be bypassed for this message - * option (buf.validate.message).disabled = true; + * // The field `foo` must be greater than 42. + * option (buf.validate.message).cel = { + * id: "my_message.value", + * message: "value must be greater than 42", + * expression: "this.foo > 42", + * }; + * optional int32 foo = 1; * } * ``` * - * @generated from field: optional bool disabled = 1; + * @generated from field: repeated buf.validate.Rule cel = 3; */ - disabled: boolean; + cel: Rule[]; /** - * `cel` is a repeated field of type Constraint. Each Constraint specifies a validation rule to be applied to this message. - * These constraints are written in Common Expression Language (CEL) syntax. For more information on - * CEL, [see our documentation](https://github.com/bufbuild/protovalidate/blob/main/docs/cel.md). + * `oneof` is a repeated field of type MessageOneofRule that specifies a list of fields + * of which at most one can be present. If `required` is also specified, then exactly one + * of the specified fields _must_ be present. + * + * This will enforce oneof-like constraints with a few features not provided by + * actual Protobuf oneof declarations: + * 1. Repeated and map fields are allowed in this validation. In a Protobuf oneof, + * only scalar fields are allowed. + * 2. Fields with implicit presence are allowed. In a Protobuf oneof, all member + * fields have explicit presence. This means that, for the purpose of determining + * how many fields are set, explicitly setting such a field to its zero value is + * effectively the same as not setting it at all. + * 3. This will always generate validation errors for a message unmarshalled from + * serialized data that sets more than one field. With a Protobuf oneof, when + * multiple fields are present in the serialized form, earlier values are usually + * silently ignored when unmarshalling, with only the last field being set when + * unmarshalling completes. * + * Note that adding a field to a `oneof` will also set the IGNORE_IF_ZERO_VALUE on the fields. This means + * only the field that is set will be validated and the unset fields are not validated according to the field rules. + * This behavior can be overridden by setting `ignore` against a field. * * ```proto * message MyMessage { - * // The field `foo` must be greater than 42. - * option (buf.validate.message).cel = { - * id: "my_message.value", - * message: "value must be greater than 42", - * expression: "this.foo > 42", - * }; - * optional int32 foo = 1; + * // Only one of `field1` or `field2` _can_ be present in this message. + * option (buf.validate.message).oneof = { fields: ["field1", "field2"] }; + * // Exactly one of `field3` or `field4` _must_ be present in this message. + * option (buf.validate.message).oneof = { fields: ["field3", "field4"], required: true }; + * string field1 = 1; + * bytes field2 = 2; + * bool field3 = 3; + * int32 field4 = 4; * } * ``` * - * @generated from field: repeated buf.validate.Constraint cel = 3; + * @generated from field: repeated buf.validate.MessageOneofRule oneof = 4; */ - cel: Constraint[]; + oneof: MessageOneofRule[]; }; /** - * Describes the message buf.validate.MessageConstraints. - * Use `create(MessageConstraintsSchema)` to create a new message. + * Describes the message buf.validate.MessageRules. + * Use `create(MessageRulesSchema)` to create a new message. */ -export const MessageConstraintsSchema: GenMessage = /*@__PURE__*/ +export const MessageRulesSchema: GenMessage = /*@__PURE__*/ messageDesc(file_buf_validate_validate, 1); /** - * The `OneofConstraints` message type enables you to manage constraints for + * @generated from message buf.validate.MessageOneofRule + */ +export type MessageOneofRule = Message<"buf.validate.MessageOneofRule"> & { + /** + * A list of field names to include in the oneof. All field names must be + * defined in the message. At least one field must be specified, and + * duplicates are not permitted. + * + * @generated from field: repeated string fields = 1; + */ + fields: string[]; + + /** + * If true, one of the fields specified _must_ be set. + * + * @generated from field: optional bool required = 2; + */ + required: boolean; +}; + +/** + * Describes the message buf.validate.MessageOneofRule. + * Use `create(MessageOneofRuleSchema)` to create a new message. + */ +export const MessageOneofRuleSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 2); + +/** + * The `OneofRules` message type enables you to manage rules for * oneof fields in your protobuf messages. * - * @generated from message buf.validate.OneofConstraints + * @generated from message buf.validate.OneofRules */ -export type OneofConstraints = Message<"buf.validate.OneofConstraints"> & { +export type OneofRules = Message<"buf.validate.OneofRules"> & { /** - * If `required` is true, exactly one field of the oneof must be present. A - * validation error is returned if no fields in the oneof are present. The - * field itself may still be a default value; further constraints + * If `required` is true, exactly one field of the oneof must be set. A + * validation error is returned if no fields in the oneof are set. Further rules * should be placed on the fields themselves to ensure they are valid values, * such as `min_len` or `gt`. * @@ -168,23 +220,23 @@ export type OneofConstraints = Message<"buf.validate.OneofConstraints"> & { }; /** - * Describes the message buf.validate.OneofConstraints. - * Use `create(OneofConstraintsSchema)` to create a new message. + * Describes the message buf.validate.OneofRules. + * Use `create(OneofRulesSchema)` to create a new message. */ -export const OneofConstraintsSchema: GenMessage = /*@__PURE__*/ - messageDesc(file_buf_validate_validate, 2); +export const OneofRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 3); /** - * FieldConstraints encapsulates the rules for each type of field. Depending on + * FieldRules encapsulates the rules for each type of field. Depending on * the field, the correct set should be used to ensure proper validations. * - * @generated from message buf.validate.FieldConstraints + * @generated from message buf.validate.FieldRules */ -export type FieldConstraints = Message<"buf.validate.FieldConstraints"> & { +export type FieldRules = Message<"buf.validate.FieldRules"> & { /** * `cel` is a repeated field used to represent a textual expression - * in the Common Expression Language (CEL) syntax. For more information on - * CEL, [see our documentation](https://github.com/bufbuild/protovalidate/blob/main/docs/cel.md). + * in the Common Expression Language (CEL) syntax. For more information, + * [see our documentation](https://buf.build/docs/protovalidate/schemas/custom-rules/). * * ```proto * message MyMessage { @@ -197,44 +249,76 @@ export type FieldConstraints = Message<"buf.validate.FieldConstraints"> & { * } * ``` * - * @generated from field: repeated buf.validate.Constraint cel = 23; + * @generated from field: repeated buf.validate.Rule cel = 23; */ - cel: Constraint[]; + cel: Rule[]; /** - * If `required` is true, the field must be populated. A populated field can be - * described as "serialized in the wire format," which includes: + * If `required` is true, the field must be set. A validation error is returned + * if the field is not set. + * + * ```proto + * syntax="proto3"; * - * - the following "nullable" fields must be explicitly set to be considered populated: - * - singular message fields (whose fields may be unpopulated/default values) - * - member fields of a oneof (may be their default value) - * - proto3 optional fields (may be their default value) - * - proto2 scalar fields (both optional and required) - * - proto3 scalar fields must be non-zero to be considered populated - * - repeated and map fields must be non-empty to be considered populated + * message FieldsWithPresence { + * // Requires any string to be set, including the empty string. + * optional string link = 1 [ + * (buf.validate.field).required = true + * ]; + * // Requires true or false to be set. + * optional bool disabled = 2 [ + * (buf.validate.field).required = true + * ]; + * // Requires a message to be set, including the empty message. + * SomeMessage msg = 4 [ + * (buf.validate.field).required = true + * ]; + * } + * ``` + * + * All fields in the example above track presence. By default, Protovalidate + * ignores rules on those fields if no value is set. `required` ensures that + * the fields are set and valid. + * + * Fields that don't track presence are always validated by Protovalidate, + * whether they are set or not. It is not necessary to add `required`: * * ```proto - * message MyMessage { - * // The field `value` must be set to a non-null value. - * optional MyOtherMessage value = 1 [(buf.validate.field).required = true]; + * syntax="proto3"; + * + * message FieldsWithoutPresence { + * // `string.email` always applies, even to an empty string. + * string link = 1 [ + * (buf.validate.field).string.email = true + * ]; + * // `repeated.min_items` always applies, even to an empty list. + * repeated string labels = 4 [ + * (buf.validate.field).repeated.min_items = 1 + * ]; * } * ``` * + * To learn which fields track presence, see the + * [Field Presence cheat sheet](https://protobuf.dev/programming-guides/field_presence/#cheat). + * + * Note: While field rules can be applied to repeated items, map keys, and map + * values, the elements are always considered to be set. Consequently, + * specifying `repeated.items.required` is redundant. + * * @generated from field: optional bool required = 25; */ required: boolean; /** - * Skip validation on the field if its value matches the specified criteria. - * See Ignore enum for details. + * Ignore validation rules on the field if its value matches the specified + * criteria. See the `Ignore` enum for details. * * ```proto * message UpdateRequest { - * // The uri rule only applies if the field is populated and not an empty - * // string. - * optional string url = 1 [ - * (buf.validate.field).ignore = IGNORE_IF_DEFAULT_VALUE, - * (buf.validate.field).string.uri = true, + * // The uri rule only applies if the field is not an empty string. + * string url = 1 [ + * (buf.validate.field).ignore = IGNORE_IF_ZERO_VALUE, + * (buf.validate.field).string.uri = true * ]; * } * ``` @@ -244,7 +328,7 @@ export type FieldConstraints = Message<"buf.validate.FieldConstraints"> & { ignore: Ignore; /** - * @generated from oneof buf.validate.FieldConstraints.type + * @generated from oneof buf.validate.FieldRules.type */ type: { /** @@ -382,23 +466,23 @@ export type FieldConstraints = Message<"buf.validate.FieldConstraints"> & { }; /** - * Describes the message buf.validate.FieldConstraints. - * Use `create(FieldConstraintsSchema)` to create a new message. + * Describes the message buf.validate.FieldRules. + * Use `create(FieldRulesSchema)` to create a new message. */ -export const FieldConstraintsSchema: GenMessage = /*@__PURE__*/ - messageDesc(file_buf_validate_validate, 3); +export const FieldRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 4); /** - * PredefinedConstraints are custom constraints that can be re-used with + * PredefinedRules are custom rules that can be re-used with * multiple fields. * - * @generated from message buf.validate.PredefinedConstraints + * @generated from message buf.validate.PredefinedRules */ -export type PredefinedConstraints = Message<"buf.validate.PredefinedConstraints"> & { +export type PredefinedRules = Message<"buf.validate.PredefinedRules"> & { /** * `cel` is a repeated field used to represent a textual expression - * in the Common Expression Language (CEL) syntax. For more information on - * CEL, [see our documentation](https://github.com/bufbuild/protovalidate/blob/main/docs/cel.md). + * in the Common Expression Language (CEL) syntax. For more information, + * [see our documentation](https://buf.build/docs/protovalidate/schemas/predefined-rules/). * * ```proto * message MyMessage { @@ -411,20 +495,20 @@ export type PredefinedConstraints = Message<"buf.validate.PredefinedConstraints" * } * ``` * - * @generated from field: repeated buf.validate.Constraint cel = 1; + * @generated from field: repeated buf.validate.Rule cel = 1; */ - cel: Constraint[]; + cel: Rule[]; }; /** - * Describes the message buf.validate.PredefinedConstraints. - * Use `create(PredefinedConstraintsSchema)` to create a new message. + * Describes the message buf.validate.PredefinedRules. + * Use `create(PredefinedRulesSchema)` to create a new message. */ -export const PredefinedConstraintsSchema: GenMessage = /*@__PURE__*/ - messageDesc(file_buf_validate_validate, 4); +export const PredefinedRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_buf_validate_validate, 5); /** - * FloatRules describes the constraints applied to `float` values. These + * FloatRules describes the rules applied to `float` values. These * rules may also be applied to the `google.protobuf.FloatValue` Well-Known-Type. * * @generated from message buf.validate.FloatRules @@ -547,7 +631,7 @@ export type FloatRules = Message<"buf.validate.FloatRules"> & { * ```proto * message MyFloat { * // value must be in list [1.0, 2.0, 3.0] - * repeated float value = 1 (buf.validate.field).float = { in: [1.0, 2.0, 3.0] }; + * float value = 1 [(buf.validate.field).float = { in: [1.0, 2.0, 3.0] }]; * } * ``` * @@ -563,7 +647,7 @@ export type FloatRules = Message<"buf.validate.FloatRules"> & { * ```proto * message MyFloat { * // value must not be in list [1.0, 2.0, 3.0] - * repeated float value = 1 (buf.validate.field).float = { not_in: [1.0, 2.0, 3.0] }; + * float value = 1 [(buf.validate.field).float = { not_in: [1.0, 2.0, 3.0] }]; * } * ``` * @@ -581,14 +665,14 @@ export type FloatRules = Message<"buf.validate.FloatRules"> & { /** * `example` specifies values that the field may have. These values SHOULD - * conform to other constraints. `example` values will not impact validation + * conform to other rules. `example` values will not impact validation * but may be used as helpful guidance on how to populate the given field. * * ```proto * message MyFloat { * float value = 1 [ * (buf.validate.field).float.example = 1.0, - * (buf.validate.field).float.example = "Infinity" + * (buf.validate.field).float.example = inf * ]; * } * ``` @@ -603,10 +687,10 @@ export type FloatRules = Message<"buf.validate.FloatRules"> & { * Use `create(FloatRulesSchema)` to create a new message. */ export const FloatRulesSchema: GenMessage = /*@__PURE__*/ - messageDesc(file_buf_validate_validate, 5); + messageDesc(file_buf_validate_validate, 6); /** - * DoubleRules describes the constraints applied to `double` values. These + * DoubleRules describes the rules applied to `double` values. These * rules may also be applied to the `google.protobuf.DoubleValue` Well-Known-Type. * * @generated from message buf.validate.DoubleRules @@ -729,7 +813,7 @@ export type DoubleRules = Message<"buf.validate.DoubleRules"> & { * ```proto * message MyDouble { * // value must be in list [1.0, 2.0, 3.0] - * repeated double value = 1 (buf.validate.field).double = { in: [1.0, 2.0, 3.0] }; + * double value = 1 [(buf.validate.field).double = { in: [1.0, 2.0, 3.0] }]; * } * ``` * @@ -745,7 +829,7 @@ export type DoubleRules = Message<"buf.validate.DoubleRules"> & { * ```proto * message MyDouble { * // value must not be in list [1.0, 2.0, 3.0] - * repeated double value = 1 (buf.validate.field).double = { not_in: [1.0, 2.0, 3.0] }; + * double value = 1 [(buf.validate.field).double = { not_in: [1.0, 2.0, 3.0] }]; * } * ``` * @@ -763,14 +847,14 @@ export type DoubleRules = Message<"buf.validate.DoubleRules"> & { /** * `example` specifies values that the field may have. These values SHOULD - * conform to other constraints. `example` values will not impact validation + * conform to other rules. `example` values will not impact validation * but may be used as helpful guidance on how to populate the given field. * * ```proto * message MyDouble { * double value = 1 [ * (buf.validate.field).double.example = 1.0, - * (buf.validate.field).double.example = "Infinity" + * (buf.validate.field).double.example = inf * ]; * } * ``` @@ -785,10 +869,10 @@ export type DoubleRules = Message<"buf.validate.DoubleRules"> & { * Use `create(DoubleRulesSchema)` to create a new message. */ export const DoubleRulesSchema: GenMessage = /*@__PURE__*/ - messageDesc(file_buf_validate_validate, 6); + messageDesc(file_buf_validate_validate, 7); /** - * Int32Rules describes the constraints applied to `int32` values. These + * Int32Rules describes the rules applied to `int32` values. These * rules may also be applied to the `google.protobuf.Int32Value` Well-Known-Type. * * @generated from message buf.validate.Int32Rules @@ -911,7 +995,7 @@ export type Int32Rules = Message<"buf.validate.Int32Rules"> & { * ```proto * message MyInt32 { * // value must be in list [1, 2, 3] - * repeated int32 value = 1 (buf.validate.field).int32 = { in: [1, 2, 3] }; + * int32 value = 1 [(buf.validate.field).int32 = { in: [1, 2, 3] }]; * } * ``` * @@ -927,7 +1011,7 @@ export type Int32Rules = Message<"buf.validate.Int32Rules"> & { * ```proto * message MyInt32 { * // value must not be in list [1, 2, 3] - * repeated int32 value = 1 (buf.validate.field).int32 = { not_in: [1, 2, 3] }; + * int32 value = 1 [(buf.validate.field).int32 = { not_in: [1, 2, 3] }]; * } * ``` * @@ -937,7 +1021,7 @@ export type Int32Rules = Message<"buf.validate.Int32Rules"> & { /** * `example` specifies values that the field may have. These values SHOULD - * conform to other constraints. `example` values will not impact validation + * conform to other rules. `example` values will not impact validation * but may be used as helpful guidance on how to populate the given field. * * ```proto @@ -959,10 +1043,10 @@ export type Int32Rules = Message<"buf.validate.Int32Rules"> & { * Use `create(Int32RulesSchema)` to create a new message. */ export const Int32RulesSchema: GenMessage = /*@__PURE__*/ - messageDesc(file_buf_validate_validate, 7); + messageDesc(file_buf_validate_validate, 8); /** - * Int64Rules describes the constraints applied to `int64` values. These + * Int64Rules describes the rules applied to `int64` values. These * rules may also be applied to the `google.protobuf.Int64Value` Well-Known-Type. * * @generated from message buf.validate.Int64Rules @@ -1085,7 +1169,7 @@ export type Int64Rules = Message<"buf.validate.Int64Rules"> & { * ```proto * message MyInt64 { * // value must be in list [1, 2, 3] - * repeated int64 value = 1 (buf.validate.field).int64 = { in: [1, 2, 3] }; + * int64 value = 1 [(buf.validate.field).int64 = { in: [1, 2, 3] }]; * } * ``` * @@ -1101,7 +1185,7 @@ export type Int64Rules = Message<"buf.validate.Int64Rules"> & { * ```proto * message MyInt64 { * // value must not be in list [1, 2, 3] - * repeated int64 value = 1 (buf.validate.field).int64 = { not_in: [1, 2, 3] }; + * int64 value = 1 [(buf.validate.field).int64 = { not_in: [1, 2, 3] }]; * } * ``` * @@ -1111,7 +1195,7 @@ export type Int64Rules = Message<"buf.validate.Int64Rules"> & { /** * `example` specifies values that the field may have. These values SHOULD - * conform to other constraints. `example` values will not impact validation + * conform to other rules. `example` values will not impact validation * but may be used as helpful guidance on how to populate the given field. * * ```proto @@ -1133,10 +1217,10 @@ export type Int64Rules = Message<"buf.validate.Int64Rules"> & { * Use `create(Int64RulesSchema)` to create a new message. */ export const Int64RulesSchema: GenMessage = /*@__PURE__*/ - messageDesc(file_buf_validate_validate, 8); + messageDesc(file_buf_validate_validate, 9); /** - * UInt32Rules describes the constraints applied to `uint32` values. These + * UInt32Rules describes the rules applied to `uint32` values. These * rules may also be applied to the `google.protobuf.UInt32Value` Well-Known-Type. * * @generated from message buf.validate.UInt32Rules @@ -1259,7 +1343,7 @@ export type UInt32Rules = Message<"buf.validate.UInt32Rules"> & { * ```proto * message MyUInt32 { * // value must be in list [1, 2, 3] - * repeated uint32 value = 1 (buf.validate.field).uint32 = { in: [1, 2, 3] }; + * uint32 value = 1 [(buf.validate.field).uint32 = { in: [1, 2, 3] }]; * } * ``` * @@ -1275,7 +1359,7 @@ export type UInt32Rules = Message<"buf.validate.UInt32Rules"> & { * ```proto * message MyUInt32 { * // value must not be in list [1, 2, 3] - * repeated uint32 value = 1 (buf.validate.field).uint32 = { not_in: [1, 2, 3] }; + * uint32 value = 1 [(buf.validate.field).uint32 = { not_in: [1, 2, 3] }]; * } * ``` * @@ -1285,7 +1369,7 @@ export type UInt32Rules = Message<"buf.validate.UInt32Rules"> & { /** * `example` specifies values that the field may have. These values SHOULD - * conform to other constraints. `example` values will not impact validation + * conform to other rules. `example` values will not impact validation * but may be used as helpful guidance on how to populate the given field. * * ```proto @@ -1307,10 +1391,10 @@ export type UInt32Rules = Message<"buf.validate.UInt32Rules"> & { * Use `create(UInt32RulesSchema)` to create a new message. */ export const UInt32RulesSchema: GenMessage = /*@__PURE__*/ - messageDesc(file_buf_validate_validate, 9); + messageDesc(file_buf_validate_validate, 10); /** - * UInt64Rules describes the constraints applied to `uint64` values. These + * UInt64Rules describes the rules applied to `uint64` values. These * rules may also be applied to the `google.protobuf.UInt64Value` Well-Known-Type. * * @generated from message buf.validate.UInt64Rules @@ -1433,7 +1517,7 @@ export type UInt64Rules = Message<"buf.validate.UInt64Rules"> & { * ```proto * message MyUInt64 { * // value must be in list [1, 2, 3] - * repeated uint64 value = 1 (buf.validate.field).uint64 = { in: [1, 2, 3] }; + * uint64 value = 1 [(buf.validate.field).uint64 = { in: [1, 2, 3] }]; * } * ``` * @@ -1449,7 +1533,7 @@ export type UInt64Rules = Message<"buf.validate.UInt64Rules"> & { * ```proto * message MyUInt64 { * // value must not be in list [1, 2, 3] - * repeated uint64 value = 1 (buf.validate.field).uint64 = { not_in: [1, 2, 3] }; + * uint64 value = 1 [(buf.validate.field).uint64 = { not_in: [1, 2, 3] }]; * } * ``` * @@ -1459,7 +1543,7 @@ export type UInt64Rules = Message<"buf.validate.UInt64Rules"> & { /** * `example` specifies values that the field may have. These values SHOULD - * conform to other constraints. `example` values will not impact validation + * conform to other rules. `example` values will not impact validation * but may be used as helpful guidance on how to populate the given field. * * ```proto @@ -1481,10 +1565,10 @@ export type UInt64Rules = Message<"buf.validate.UInt64Rules"> & { * Use `create(UInt64RulesSchema)` to create a new message. */ export const UInt64RulesSchema: GenMessage = /*@__PURE__*/ - messageDesc(file_buf_validate_validate, 10); + messageDesc(file_buf_validate_validate, 11); /** - * SInt32Rules describes the constraints applied to `sint32` values. + * SInt32Rules describes the rules applied to `sint32` values. * * @generated from message buf.validate.SInt32Rules */ @@ -1606,7 +1690,7 @@ export type SInt32Rules = Message<"buf.validate.SInt32Rules"> & { * ```proto * message MySInt32 { * // value must be in list [1, 2, 3] - * repeated sint32 value = 1 (buf.validate.field).sint32 = { in: [1, 2, 3] }; + * sint32 value = 1 [(buf.validate.field).sint32 = { in: [1, 2, 3] }]; * } * ``` * @@ -1622,7 +1706,7 @@ export type SInt32Rules = Message<"buf.validate.SInt32Rules"> & { * ```proto * message MySInt32 { * // value must not be in list [1, 2, 3] - * repeated sint32 value = 1 (buf.validate.field).sint32 = { not_in: [1, 2, 3] }; + * sint32 value = 1 [(buf.validate.field).sint32 = { not_in: [1, 2, 3] }]; * } * ``` * @@ -1632,7 +1716,7 @@ export type SInt32Rules = Message<"buf.validate.SInt32Rules"> & { /** * `example` specifies values that the field may have. These values SHOULD - * conform to other constraints. `example` values will not impact validation + * conform to other rules. `example` values will not impact validation * but may be used as helpful guidance on how to populate the given field. * * ```proto @@ -1654,10 +1738,10 @@ export type SInt32Rules = Message<"buf.validate.SInt32Rules"> & { * Use `create(SInt32RulesSchema)` to create a new message. */ export const SInt32RulesSchema: GenMessage = /*@__PURE__*/ - messageDesc(file_buf_validate_validate, 11); + messageDesc(file_buf_validate_validate, 12); /** - * SInt64Rules describes the constraints applied to `sint64` values. + * SInt64Rules describes the rules applied to `sint64` values. * * @generated from message buf.validate.SInt64Rules */ @@ -1779,7 +1863,7 @@ export type SInt64Rules = Message<"buf.validate.SInt64Rules"> & { * ```proto * message MySInt64 { * // value must be in list [1, 2, 3] - * repeated sint64 value = 1 (buf.validate.field).sint64 = { in: [1, 2, 3] }; + * sint64 value = 1 [(buf.validate.field).sint64 = { in: [1, 2, 3] }]; * } * ``` * @@ -1795,7 +1879,7 @@ export type SInt64Rules = Message<"buf.validate.SInt64Rules"> & { * ```proto * message MySInt64 { * // value must not be in list [1, 2, 3] - * repeated sint64 value = 1 (buf.validate.field).sint64 = { not_in: [1, 2, 3] }; + * sint64 value = 1 [(buf.validate.field).sint64 = { not_in: [1, 2, 3] }]; * } * ``` * @@ -1805,7 +1889,7 @@ export type SInt64Rules = Message<"buf.validate.SInt64Rules"> & { /** * `example` specifies values that the field may have. These values SHOULD - * conform to other constraints. `example` values will not impact validation + * conform to other rules. `example` values will not impact validation * but may be used as helpful guidance on how to populate the given field. * * ```proto @@ -1827,10 +1911,10 @@ export type SInt64Rules = Message<"buf.validate.SInt64Rules"> & { * Use `create(SInt64RulesSchema)` to create a new message. */ export const SInt64RulesSchema: GenMessage = /*@__PURE__*/ - messageDesc(file_buf_validate_validate, 12); + messageDesc(file_buf_validate_validate, 13); /** - * Fixed32Rules describes the constraints applied to `fixed32` values. + * Fixed32Rules describes the rules applied to `fixed32` values. * * @generated from message buf.validate.Fixed32Rules */ @@ -1952,7 +2036,7 @@ export type Fixed32Rules = Message<"buf.validate.Fixed32Rules"> & { * ```proto * message MyFixed32 { * // value must be in list [1, 2, 3] - * repeated fixed32 value = 1 (buf.validate.field).fixed32 = { in: [1, 2, 3] }; + * fixed32 value = 1 [(buf.validate.field).fixed32 = { in: [1, 2, 3] }]; * } * ``` * @@ -1968,7 +2052,7 @@ export type Fixed32Rules = Message<"buf.validate.Fixed32Rules"> & { * ```proto * message MyFixed32 { * // value must not be in list [1, 2, 3] - * repeated fixed32 value = 1 (buf.validate.field).fixed32 = { not_in: [1, 2, 3] }; + * fixed32 value = 1 [(buf.validate.field).fixed32 = { not_in: [1, 2, 3] }]; * } * ``` * @@ -1978,7 +2062,7 @@ export type Fixed32Rules = Message<"buf.validate.Fixed32Rules"> & { /** * `example` specifies values that the field may have. These values SHOULD - * conform to other constraints. `example` values will not impact validation + * conform to other rules. `example` values will not impact validation * but may be used as helpful guidance on how to populate the given field. * * ```proto @@ -2000,10 +2084,10 @@ export type Fixed32Rules = Message<"buf.validate.Fixed32Rules"> & { * Use `create(Fixed32RulesSchema)` to create a new message. */ export const Fixed32RulesSchema: GenMessage = /*@__PURE__*/ - messageDesc(file_buf_validate_validate, 13); + messageDesc(file_buf_validate_validate, 14); /** - * Fixed64Rules describes the constraints applied to `fixed64` values. + * Fixed64Rules describes the rules applied to `fixed64` values. * * @generated from message buf.validate.Fixed64Rules */ @@ -2125,7 +2209,7 @@ export type Fixed64Rules = Message<"buf.validate.Fixed64Rules"> & { * ```proto * message MyFixed64 { * // value must be in list [1, 2, 3] - * repeated fixed64 value = 1 (buf.validate.field).fixed64 = { in: [1, 2, 3] }; + * fixed64 value = 1 [(buf.validate.field).fixed64 = { in: [1, 2, 3] }]; * } * ``` * @@ -2141,7 +2225,7 @@ export type Fixed64Rules = Message<"buf.validate.Fixed64Rules"> & { * ```proto * message MyFixed64 { * // value must not be in list [1, 2, 3] - * repeated fixed64 value = 1 (buf.validate.field).fixed64 = { not_in: [1, 2, 3] }; + * fixed64 value = 1 [(buf.validate.field).fixed64 = { not_in: [1, 2, 3] }]; * } * ``` * @@ -2151,7 +2235,7 @@ export type Fixed64Rules = Message<"buf.validate.Fixed64Rules"> & { /** * `example` specifies values that the field may have. These values SHOULD - * conform to other constraints. `example` values will not impact validation + * conform to other rules. `example` values will not impact validation * but may be used as helpful guidance on how to populate the given field. * * ```proto @@ -2173,10 +2257,10 @@ export type Fixed64Rules = Message<"buf.validate.Fixed64Rules"> & { * Use `create(Fixed64RulesSchema)` to create a new message. */ export const Fixed64RulesSchema: GenMessage = /*@__PURE__*/ - messageDesc(file_buf_validate_validate, 14); + messageDesc(file_buf_validate_validate, 15); /** - * SFixed32Rules describes the constraints applied to `fixed32` values. + * SFixed32Rules describes the rules applied to `fixed32` values. * * @generated from message buf.validate.SFixed32Rules */ @@ -2298,7 +2382,7 @@ export type SFixed32Rules = Message<"buf.validate.SFixed32Rules"> & { * ```proto * message MySFixed32 { * // value must be in list [1, 2, 3] - * repeated sfixed32 value = 1 (buf.validate.field).sfixed32 = { in: [1, 2, 3] }; + * sfixed32 value = 1 [(buf.validate.field).sfixed32 = { in: [1, 2, 3] }]; * } * ``` * @@ -2314,7 +2398,7 @@ export type SFixed32Rules = Message<"buf.validate.SFixed32Rules"> & { * ```proto * message MySFixed32 { * // value must not be in list [1, 2, 3] - * repeated sfixed32 value = 1 (buf.validate.field).sfixed32 = { not_in: [1, 2, 3] }; + * sfixed32 value = 1 [(buf.validate.field).sfixed32 = { not_in: [1, 2, 3] }]; * } * ``` * @@ -2324,7 +2408,7 @@ export type SFixed32Rules = Message<"buf.validate.SFixed32Rules"> & { /** * `example` specifies values that the field may have. These values SHOULD - * conform to other constraints. `example` values will not impact validation + * conform to other rules. `example` values will not impact validation * but may be used as helpful guidance on how to populate the given field. * * ```proto @@ -2346,10 +2430,10 @@ export type SFixed32Rules = Message<"buf.validate.SFixed32Rules"> & { * Use `create(SFixed32RulesSchema)` to create a new message. */ export const SFixed32RulesSchema: GenMessage = /*@__PURE__*/ - messageDesc(file_buf_validate_validate, 15); + messageDesc(file_buf_validate_validate, 16); /** - * SFixed64Rules describes the constraints applied to `fixed64` values. + * SFixed64Rules describes the rules applied to `fixed64` values. * * @generated from message buf.validate.SFixed64Rules */ @@ -2471,7 +2555,7 @@ export type SFixed64Rules = Message<"buf.validate.SFixed64Rules"> & { * ```proto * message MySFixed64 { * // value must be in list [1, 2, 3] - * repeated sfixed64 value = 1 (buf.validate.field).sfixed64 = { in: [1, 2, 3] }; + * sfixed64 value = 1 [(buf.validate.field).sfixed64 = { in: [1, 2, 3] }]; * } * ``` * @@ -2487,7 +2571,7 @@ export type SFixed64Rules = Message<"buf.validate.SFixed64Rules"> & { * ```proto * message MySFixed64 { * // value must not be in list [1, 2, 3] - * repeated sfixed64 value = 1 (buf.validate.field).sfixed64 = { not_in: [1, 2, 3] }; + * sfixed64 value = 1 [(buf.validate.field).sfixed64 = { not_in: [1, 2, 3] }]; * } * ``` * @@ -2497,7 +2581,7 @@ export type SFixed64Rules = Message<"buf.validate.SFixed64Rules"> & { /** * `example` specifies values that the field may have. These values SHOULD - * conform to other constraints. `example` values will not impact validation + * conform to other rules. `example` values will not impact validation * but may be used as helpful guidance on how to populate the given field. * * ```proto @@ -2519,10 +2603,10 @@ export type SFixed64Rules = Message<"buf.validate.SFixed64Rules"> & { * Use `create(SFixed64RulesSchema)` to create a new message. */ export const SFixed64RulesSchema: GenMessage = /*@__PURE__*/ - messageDesc(file_buf_validate_validate, 16); + messageDesc(file_buf_validate_validate, 17); /** - * BoolRules describes the constraints applied to `bool` values. These rules + * BoolRules describes the rules applied to `bool` values. These rules * may also be applied to the `google.protobuf.BoolValue` Well-Known-Type. * * @generated from message buf.validate.BoolRules @@ -2545,7 +2629,7 @@ export type BoolRules = Message<"buf.validate.BoolRules"> & { /** * `example` specifies values that the field may have. These values SHOULD - * conform to other constraints. `example` values will not impact validation + * conform to other rules. `example` values will not impact validation * but may be used as helpful guidance on how to populate the given field. * * ```proto @@ -2567,10 +2651,10 @@ export type BoolRules = Message<"buf.validate.BoolRules"> & { * Use `create(BoolRulesSchema)` to create a new message. */ export const BoolRulesSchema: GenMessage = /*@__PURE__*/ - messageDesc(file_buf_validate_validate, 17); + messageDesc(file_buf_validate_validate, 18); /** - * StringRules describes the constraints applied to `string` values These + * StringRules describes the rules applied to `string` values These * rules may also be applied to the `google.protobuf.StringValue` Well-Known-Type. * * @generated from message buf.validate.StringRules @@ -2781,7 +2865,7 @@ export type StringRules = Message<"buf.validate.StringRules"> & { * ```proto * message MyString { * // value must be in list ["apple", "banana"] - * repeated string value = 1 [(buf.validate.field).string.in = "apple", (buf.validate.field).string.in = "banana"]; + * string value = 1 [(buf.validate.field).string.in = "apple", (buf.validate.field).string.in = "banana"]; * } * ``` * @@ -2796,7 +2880,7 @@ export type StringRules = Message<"buf.validate.StringRules"> & { * ```proto * message MyString { * // value must not be in list ["orange", "grape"] - * repeated string value = 1 [(buf.validate.field).string.not_in = "orange", (buf.validate.field).string.not_in = "grape"]; + * string value = 1 [(buf.validate.field).string.not_in = "orange", (buf.validate.field).string.not_in = "grape"]; * } * ``` * @@ -2805,15 +2889,21 @@ export type StringRules = Message<"buf.validate.StringRules"> & { notIn: string[]; /** - * `WellKnown` rules provide advanced constraints against common string - * patterns + * `WellKnown` rules provide advanced rules against common string + * patterns. * * @generated from oneof buf.validate.StringRules.well_known */ wellKnown: { /** - * `email` specifies that the field value must be a valid email address - * (addr-spec only) as defined by [RFC 5322](https://tools.ietf.org/html/rfc5322#section-3.4.1). + * `email` specifies that the field value must be a valid email address, for + * example "foo@example.com". + * + * Conforms to the definition for a valid email address from the [HTML standard](https://html.spec.whatwg.org/multipage/input.html#valid-e-mail-address). + * Note that this standard willfully deviates from [RFC 5322](https://datatracker.ietf.org/doc/html/rfc5322), + * which allows many unexpected forms of email addresses and will easily match + * a typographical error. + * * If the field value isn't a valid email address, an error message will be generated. * * ```proto @@ -2829,10 +2919,18 @@ export type StringRules = Message<"buf.validate.StringRules"> & { case: "email"; } | { /** - * `hostname` specifies that the field value must be a valid - * hostname as defined by [RFC 1034](https://tools.ietf.org/html/rfc1034#section-3.5). This constraint doesn't support - * internationalized domain names (IDNs). If the field value isn't a - * valid hostname, an error message will be generated. + * `hostname` specifies that the field value must be a valid hostname, for + * example "foo.example.com". + * + * A valid hostname follows the rules below: + * - The name consists of one or more labels, separated by a dot ("."). + * - Each label can be 1 to 63 alphanumeric characters. + * - A label can contain hyphens ("-"), but must not start or end with a hyphen. + * - The right-most label must not be digits only. + * - The name can have a trailing dot—for example, "foo.example.com.". + * - The name can be 253 characters at most, excluding the optional trailing dot. + * + * If the field value isn't a valid hostname, an error message will be generated. * * ```proto * message MyString { @@ -2847,8 +2945,15 @@ export type StringRules = Message<"buf.validate.StringRules"> & { case: "hostname"; } | { /** - * `ip` specifies that the field value must be a valid IP - * (v4 or v6) address, without surrounding square brackets for IPv6 addresses. + * `ip` specifies that the field value must be a valid IP (v4 or v6) address. + * + * IPv4 addresses are expected in the dotted decimal format—for example, "192.168.5.21". + * IPv6 addresses are expected in their text representation—for example, "::1", + * or "2001:0DB8:ABCD:0012::0". + * + * Both formats are well-defined in the internet standard [RFC 3986](https://datatracker.ietf.org/doc/html/rfc3986). + * Zone identifiers for IPv6 addresses (for example, "fe80::a%en1") are supported. + * * If the field value isn't a valid IP address, an error message will be * generated. * @@ -2865,9 +2970,9 @@ export type StringRules = Message<"buf.validate.StringRules"> & { case: "ip"; } | { /** - * `ipv4` specifies that the field value must be a valid IPv4 - * address. If the field value isn't a valid IPv4 address, an error message - * will be generated. + * `ipv4` specifies that the field value must be a valid IPv4 address—for + * example "192.168.5.21". If the field value isn't a valid IPv4 address, an + * error message will be generated. * * ```proto * message MyString { @@ -2882,9 +2987,9 @@ export type StringRules = Message<"buf.validate.StringRules"> & { case: "ipv4"; } | { /** - * `ipv6` specifies that the field value must be a valid - * IPv6 address, without surrounding square brackets. If the field value is - * not a valid IPv6 address, an error message will be generated. + * `ipv6` specifies that the field value must be a valid IPv6 address—for + * example "::1", or "d7a:115c:a1e0:ab12:4843:cd96:626b:430b". If the field + * value is not a valid IPv6 address, an error message will be generated. * * ```proto * message MyString { @@ -2899,9 +3004,13 @@ export type StringRules = Message<"buf.validate.StringRules"> & { case: "ipv6"; } | { /** - * `uri` specifies that the field value must be a valid, - * absolute URI as defined by [RFC 3986](https://tools.ietf.org/html/rfc3986#section-3). If the field value isn't a valid, - * absolute URI, an error message will be generated. + * `uri` specifies that the field value must be a valid URI, for example + * "https://example.com/foo/bar?baz=quux#frag". + * + * URI is defined in the internet standard [RFC 3986](https://datatracker.ietf.org/doc/html/rfc3986). + * Zone Identifiers in IPv6 address literals are supported ([RFC 6874](https://datatracker.ietf.org/doc/html/rfc6874)). + * + * If the field value isn't a valid URI, an error message will be generated. * * ```proto * message MyString { @@ -2916,13 +3025,20 @@ export type StringRules = Message<"buf.validate.StringRules"> & { case: "uri"; } | { /** - * `uri_ref` specifies that the field value must be a valid URI - * as defined by [RFC 3986](https://tools.ietf.org/html/rfc3986#section-3) and may be either relative or absolute. If the - * field value isn't a valid URI, an error message will be generated. + * `uri_ref` specifies that the field value must be a valid URI Reference—either + * a URI such as "https://example.com/foo/bar?baz=quux#frag", or a Relative + * Reference such as "./foo/bar?query". + * + * URI, URI Reference, and Relative Reference are defined in the internet + * standard [RFC 3986](https://datatracker.ietf.org/doc/html/rfc3986). Zone + * Identifiers in IPv6 address literals are supported ([RFC 6874](https://datatracker.ietf.org/doc/html/rfc6874)). + * + * If the field value isn't a valid URI Reference, an error message will be + * generated. * * ```proto * message MyString { - * // value must be a valid URI + * // value must be a valid URI Reference * string value = 1 [(buf.validate.field).string.uri_ref = true]; * } * ``` @@ -2934,10 +3050,9 @@ export type StringRules = Message<"buf.validate.StringRules"> & { } | { /** * `address` specifies that the field value must be either a valid hostname - * as defined by [RFC 1034](https://tools.ietf.org/html/rfc1034#section-3.5) - * (which doesn't support internationalized domain names or IDNs) or a valid - * IP (v4 or v6). If the field value isn't a valid hostname or IP, an error - * message will be generated. + * (for example, "example.com"), or a valid IP (v4 or v6) address (for example, + * "192.168.0.1", or "::1"). If the field value isn't a valid hostname or IP, + * an error message will be generated. * * ```proto * message MyString { @@ -2953,7 +3068,7 @@ export type StringRules = Message<"buf.validate.StringRules"> & { } | { /** * `uuid` specifies that the field value must be a valid UUID as defined by - * [RFC 4122](https://tools.ietf.org/html/rfc4122#section-4.1.2). If the + * [RFC 4122](https://datatracker.ietf.org/doc/html/rfc4122#section-4.1.2). If the * field value isn't a valid UUID, an error message will be generated. * * ```proto @@ -2970,7 +3085,7 @@ export type StringRules = Message<"buf.validate.StringRules"> & { } | { /** * `tuuid` (trimmed UUID) specifies that the field value must be a valid UUID as - * defined by [RFC 4122](https://tools.ietf.org/html/rfc4122#section-4.1.2) with all dashes + * defined by [RFC 4122](https://datatracker.ietf.org/doc/html/rfc4122#section-4.1.2) with all dashes * omitted. If the field value isn't a valid UUID without dashes, an error message * will be generated. * @@ -2987,10 +3102,10 @@ export type StringRules = Message<"buf.validate.StringRules"> & { case: "tuuid"; } | { /** - * `ip_with_prefixlen` specifies that the field value must be a valid IP (v4 or v6) - * address with prefix length. If the field value isn't a valid IP with prefix - * length, an error message will be generated. - * + * `ip_with_prefixlen` specifies that the field value must be a valid IP + * (v4 or v6) address with prefix length—for example, "192.168.5.21/16" or + * "2001:0DB8:ABCD:0012::F1/64". If the field value isn't a valid IP with + * prefix length, an error message will be generated. * * ```proto * message MyString { @@ -3006,9 +3121,9 @@ export type StringRules = Message<"buf.validate.StringRules"> & { } | { /** * `ipv4_with_prefixlen` specifies that the field value must be a valid - * IPv4 address with prefix. - * If the field value isn't a valid IPv4 address with prefix length, - * an error message will be generated. + * IPv4 address with prefix length—for example, "192.168.5.21/16". If the + * field value isn't a valid IPv4 address with prefix length, an error + * message will be generated. * * ```proto * message MyString { @@ -3024,7 +3139,7 @@ export type StringRules = Message<"buf.validate.StringRules"> & { } | { /** * `ipv6_with_prefixlen` specifies that the field value must be a valid - * IPv6 address with prefix length. + * IPv6 address with prefix length—for example, "2001:0DB8:ABCD:0012::F1/64". * If the field value is not a valid IPv6 address with prefix length, * an error message will be generated. * @@ -3041,10 +3156,15 @@ export type StringRules = Message<"buf.validate.StringRules"> & { case: "ipv6WithPrefixlen"; } | { /** - * `ip_prefix` specifies that the field value must be a valid IP (v4 or v6) prefix. + * `ip_prefix` specifies that the field value must be a valid IP (v4 or v6) + * prefix—for example, "192.168.0.0/16" or "2001:0DB8:ABCD:0012::0/64". + * + * The prefix must have all zeros for the unmasked bits. For example, + * "2001:0DB8:ABCD:0012::0/64" designates the left-most 64 bits for the + * prefix, and the remaining 64 bits must be zero. + * * If the field value isn't a valid IP prefix, an error message will be - * generated. The prefix must have all zeros for the masked bits of the prefix (e.g., - * `127.0.0.0/16`, not `127.0.0.1/16`). + * generated. * * ```proto * message MyString { @@ -3060,9 +3180,14 @@ export type StringRules = Message<"buf.validate.StringRules"> & { } | { /** * `ipv4_prefix` specifies that the field value must be a valid IPv4 - * prefix. If the field value isn't a valid IPv4 prefix, an error message - * will be generated. The prefix must have all zeros for the masked bits of - * the prefix (e.g., `127.0.0.0/16`, not `127.0.0.1/16`). + * prefix, for example "192.168.0.0/16". + * + * The prefix must have all zeros for the unmasked bits. For example, + * "192.168.0.0/16" designates the left-most 16 bits for the prefix, + * and the remaining 16 bits must be zero. + * + * If the field value isn't a valid IPv4 prefix, an error message + * will be generated. * * ```proto * message MyString { @@ -3077,10 +3202,15 @@ export type StringRules = Message<"buf.validate.StringRules"> & { case: "ipv4Prefix"; } | { /** - * `ipv6_prefix` specifies that the field value must be a valid IPv6 prefix. + * `ipv6_prefix` specifies that the field value must be a valid IPv6 prefix—for + * example, "2001:0DB8:ABCD:0012::0/64". + * + * The prefix must have all zeros for the unmasked bits. For example, + * "2001:0DB8:ABCD:0012::0/64" designates the left-most 64 bits for the + * prefix, and the remaining 64 bits must be zero. + * * If the field value is not a valid IPv6 prefix, an error message will be - * generated. The prefix must have all zeros for the masked bits of the prefix - * (e.g., `2001:db8::/48`, not `2001:db8::1/48`). + * generated. * * ```proto * message MyString { @@ -3095,10 +3225,16 @@ export type StringRules = Message<"buf.validate.StringRules"> & { case: "ipv6Prefix"; } | { /** - * `host_and_port` specifies the field value must be a valid host and port - * pair. The host must be a valid hostname or IP address while the port - * must be in the range of 0-65535, inclusive. IPv6 addresses must be delimited - * with square brackets (e.g., `[::1]:1234`). + * `host_and_port` specifies that the field value must be valid host/port + * pair—for example, "example.com:8080". + * + * The host can be one of: + * - An IPv4 address in dotted decimal format—for example, "192.168.5.21". + * - An IPv6 address enclosed in square brackets—for example, "[2001:0DB8:ABCD:0012::F1]". + * - A hostname—for example, "example.com". + * + * The port is separated by a colon. It must be non-empty, with a decimal number + * in the range of 0-65535, inclusive. * * @generated from field: bool host_and_port = 32; */ @@ -3124,8 +3260,8 @@ export type StringRules = Message<"buf.validate.StringRules"> & { * | Name | Number | Description | * |-------------------------------|--------|-------------------------------------------| * | KNOWN_REGEX_UNSPECIFIED | 0 | | - * | KNOWN_REGEX_HTTP_HEADER_NAME | 1 | HTTP header name as defined by [RFC 7230](https://tools.ietf.org/html/rfc7230#section-3.2) | - * | KNOWN_REGEX_HTTP_HEADER_VALUE | 2 | HTTP header value as defined by [RFC 7230](https://tools.ietf.org/html/rfc7230#section-3.2.4) | + * | KNOWN_REGEX_HTTP_HEADER_NAME | 1 | HTTP header name as defined by [RFC 7230](https://datatracker.ietf.org/doc/html/rfc7230#section-3.2) | + * | KNOWN_REGEX_HTTP_HEADER_VALUE | 2 | HTTP header value as defined by [RFC 7230](https://datatracker.ietf.org/doc/html/rfc7230#section-3.2.4) | * * @generated from field: buf.validate.KnownRegex well_known_regex = 24; */ @@ -3136,7 +3272,7 @@ export type StringRules = Message<"buf.validate.StringRules"> & { /** * This applies to regexes `HTTP_HEADER_NAME` and `HTTP_HEADER_VALUE` to * enable strict header validation. By default, this is true, and HTTP header - * validations are [RFC-compliant](https://tools.ietf.org/html/rfc7230#section-3). Setting to false will enable looser + * validations are [RFC-compliant](https://datatracker.ietf.org/doc/html/rfc7230#section-3). Setting to false will enable looser * validations that only disallow `\r\n\0` characters, which can be used to * bypass header matching rules. * @@ -3153,7 +3289,7 @@ export type StringRules = Message<"buf.validate.StringRules"> & { /** * `example` specifies values that the field may have. These values SHOULD - * conform to other constraints. `example` values will not impact validation + * conform to other rules. `example` values will not impact validation * but may be used as helpful guidance on how to populate the given field. * * ```proto @@ -3175,10 +3311,10 @@ export type StringRules = Message<"buf.validate.StringRules"> & { * Use `create(StringRulesSchema)` to create a new message. */ export const StringRulesSchema: GenMessage = /*@__PURE__*/ - messageDesc(file_buf_validate_validate, 18); + messageDesc(file_buf_validate_validate, 19); /** - * BytesRules describe the constraints applied to `bytes` values. These rules + * BytesRules describe the rules applied to `bytes` values. These rules * may also be applied to the `google.protobuf.BytesValue` Well-Known-Type. * * @generated from message buf.validate.BytesRules @@ -3346,7 +3482,7 @@ export type BytesRules = Message<"buf.validate.BytesRules"> & { notIn: Uint8Array[]; /** - * WellKnown rules provide advanced constraints against common byte + * WellKnown rules provide advanced rules against common byte * patterns * * @generated from oneof buf.validate.BytesRules.well_known @@ -3354,7 +3490,7 @@ export type BytesRules = Message<"buf.validate.BytesRules"> & { wellKnown: { /** * `ip` ensures that the field `value` is a valid IP address (v4 or v6) in byte format. - * If the field value doesn't meet this constraint, an error message is generated. + * If the field value doesn't meet this rule, an error message is generated. * * ```proto * message MyBytes { @@ -3370,7 +3506,7 @@ export type BytesRules = Message<"buf.validate.BytesRules"> & { } | { /** * `ipv4` ensures that the field `value` is a valid IPv4 address in byte format. - * If the field value doesn't meet this constraint, an error message is generated. + * If the field value doesn't meet this rule, an error message is generated. * * ```proto * message MyBytes { @@ -3386,7 +3522,7 @@ export type BytesRules = Message<"buf.validate.BytesRules"> & { } | { /** * `ipv6` ensures that the field `value` is a valid IPv6 address in byte format. - * If the field value doesn't meet this constraint, an error message is generated. + * If the field value doesn't meet this rule, an error message is generated. * ```proto * message MyBytes { * // value must be a valid IPv6 address @@ -3402,7 +3538,7 @@ export type BytesRules = Message<"buf.validate.BytesRules"> & { /** * `example` specifies values that the field may have. These values SHOULD - * conform to other constraints. `example` values will not impact validation + * conform to other rules. `example` values will not impact validation * but may be used as helpful guidance on how to populate the given field. * * ```proto @@ -3424,10 +3560,10 @@ export type BytesRules = Message<"buf.validate.BytesRules"> & { * Use `create(BytesRulesSchema)` to create a new message. */ export const BytesRulesSchema: GenMessage = /*@__PURE__*/ - messageDesc(file_buf_validate_validate, 19); + messageDesc(file_buf_validate_validate, 20); /** - * EnumRules describe the constraints applied to `enum` values. + * EnumRules describe the rules applied to `enum` values. * * @generated from message buf.validate.EnumRules */ @@ -3520,7 +3656,7 @@ export type EnumRules = Message<"buf.validate.EnumRules"> & { /** * `example` specifies values that the field may have. These values SHOULD - * conform to other constraints. `example` values will not impact validation + * conform to other rules. `example` values will not impact validation * but may be used as helpful guidance on how to populate the given field. * * ```proto @@ -3546,10 +3682,10 @@ export type EnumRules = Message<"buf.validate.EnumRules"> & { * Use `create(EnumRulesSchema)` to create a new message. */ export const EnumRulesSchema: GenMessage = /*@__PURE__*/ - messageDesc(file_buf_validate_validate, 20); + messageDesc(file_buf_validate_validate, 21); /** - * RepeatedRules describe the constraints applied to `repeated` values. + * RepeatedRules describe the rules applied to `repeated` values. * * @generated from message buf.validate.RepeatedRules */ @@ -3590,7 +3726,7 @@ export type RepeatedRules = Message<"buf.validate.RepeatedRules"> & { /** * `unique` indicates that all elements in this field must - * be unique. This constraint is strictly applicable to scalar and enum + * be unique. This rule is strictly applicable to scalar and enum * types, with message types not being supported. * * ```proto @@ -3605,13 +3741,13 @@ export type RepeatedRules = Message<"buf.validate.RepeatedRules"> & { unique: boolean; /** - * `items` details the constraints to be applied to each item + * `items` details the rules to be applied to each item * in the field. Even for repeated message fields, validation is executed - * against each item unless skip is explicitly specified. + * against each item unless `ignore` is specified. * * ```proto * message MyRepeated { - * // The items in the field `value` must follow the specified constraints. + * // The items in the field `value` must follow the specified rules. * repeated string value = 1 [(buf.validate.field).repeated.items = { * string: { * min_len: 3 @@ -3621,9 +3757,12 @@ export type RepeatedRules = Message<"buf.validate.RepeatedRules"> & { * } * ``` * - * @generated from field: optional buf.validate.FieldConstraints items = 4; + * Note that the `required` rule does not apply. Repeated items + * cannot be unset. + * + * @generated from field: optional buf.validate.FieldRules items = 4; */ - items?: FieldConstraints; + items?: FieldRules; }; /** @@ -3631,10 +3770,10 @@ export type RepeatedRules = Message<"buf.validate.RepeatedRules"> & { * Use `create(RepeatedRulesSchema)` to create a new message. */ export const RepeatedRulesSchema: GenMessage = /*@__PURE__*/ - messageDesc(file_buf_validate_validate, 21); + messageDesc(file_buf_validate_validate, 22); /** - * MapRules describe the constraints applied to `map` values. + * MapRules describe the rules applied to `map` values. * * @generated from message buf.validate.MapRules */ @@ -3670,11 +3809,11 @@ export type MapRules = Message<"buf.validate.MapRules"> & { maxPairs: bigint; /** - * Specifies the constraints to be applied to each key in the field. + * Specifies the rules to be applied to each key in the field. * * ```proto * message MyMap { - * // The keys in the field `value` must follow the specified constraints. + * // The keys in the field `value` must follow the specified rules. * map value = 1 [(buf.validate.field).map.keys = { * string: { * min_len: 3 @@ -3684,18 +3823,20 @@ export type MapRules = Message<"buf.validate.MapRules"> & { * } * ``` * - * @generated from field: optional buf.validate.FieldConstraints keys = 4; + * Note that the `required` rule does not apply. Map keys cannot be unset. + * + * @generated from field: optional buf.validate.FieldRules keys = 4; */ - keys?: FieldConstraints; + keys?: FieldRules; /** - * Specifies the constraints to be applied to the value of each key in the + * Specifies the rules to be applied to the value of each key in the * field. Message values will still have their validations evaluated unless - * skip is specified here. + * `ignore` is specified. * * ```proto * message MyMap { - * // The values in the field `value` must follow the specified constraints. + * // The values in the field `value` must follow the specified rules. * map value = 1 [(buf.validate.field).map.values = { * string: { * min_len: 5 @@ -3704,10 +3845,11 @@ export type MapRules = Message<"buf.validate.MapRules"> & { * }]; * } * ``` + * Note that the `required` rule does not apply. Map values cannot be unset. * - * @generated from field: optional buf.validate.FieldConstraints values = 5; + * @generated from field: optional buf.validate.FieldRules values = 5; */ - values?: FieldConstraints; + values?: FieldRules; }; /** @@ -3715,10 +3857,10 @@ export type MapRules = Message<"buf.validate.MapRules"> & { * Use `create(MapRulesSchema)` to create a new message. */ export const MapRulesSchema: GenMessage = /*@__PURE__*/ - messageDesc(file_buf_validate_validate, 22); + messageDesc(file_buf_validate_validate, 23); /** - * AnyRules describe constraints applied exclusively to the `google.protobuf.Any` well-known type. + * AnyRules describe rules applied exclusively to the `google.protobuf.Any` well-known type. * * @generated from message buf.validate.AnyRules */ @@ -3731,7 +3873,9 @@ export type AnyRules = Message<"buf.validate.AnyRules"> & { * ```proto * message MyAny { * // The `value` field must have a `type_url` equal to one of the specified values. - * google.protobuf.Any value = 1 [(buf.validate.field).any.in = ["type.googleapis.com/MyType1", "type.googleapis.com/MyType2"]]; + * google.protobuf.Any value = 1 [(buf.validate.field).any = { + * in: ["type.googleapis.com/MyType1", "type.googleapis.com/MyType2"] + * }]; * } * ``` * @@ -3744,8 +3888,10 @@ export type AnyRules = Message<"buf.validate.AnyRules"> & { * * ```proto * message MyAny { - * // The field `value` must not have a `type_url` equal to any of the specified values. - * google.protobuf.Any value = 1 [(buf.validate.field).any.not_in = ["type.googleapis.com/ForbiddenType1", "type.googleapis.com/ForbiddenType2"]]; + * // The `value` field must not have a `type_url` equal to any of the specified values. + * google.protobuf.Any value = 1 [(buf.validate.field).any = { + * not_in: ["type.googleapis.com/ForbiddenType1", "type.googleapis.com/ForbiddenType2"] + * }]; * } * ``` * @@ -3759,10 +3905,10 @@ export type AnyRules = Message<"buf.validate.AnyRules"> & { * Use `create(AnyRulesSchema)` to create a new message. */ export const AnyRulesSchema: GenMessage = /*@__PURE__*/ - messageDesc(file_buf_validate_validate, 23); + messageDesc(file_buf_validate_validate, 24); /** - * DurationRules describe the constraints applied exclusively to the `google.protobuf.Duration` well-known type. + * DurationRules describe the rules applied exclusively to the `google.protobuf.Duration` well-known type. * * @generated from message buf.validate.DurationRules */ @@ -3912,7 +4058,7 @@ export type DurationRules = Message<"buf.validate.DurationRules"> & { /** * `example` specifies values that the field may have. These values SHOULD - * conform to other constraints. `example` values will not impact validation + * conform to other rules. `example` values will not impact validation * but may be used as helpful guidance on how to populate the given field. * * ```proto @@ -3934,10 +4080,10 @@ export type DurationRules = Message<"buf.validate.DurationRules"> & { * Use `create(DurationRulesSchema)` to create a new message. */ export const DurationRulesSchema: GenMessage = /*@__PURE__*/ - messageDesc(file_buf_validate_validate, 24); + messageDesc(file_buf_validate_validate, 25); /** - * TimestampRules describe the constraints applied exclusively to the `google.protobuf.Timestamp` well-known type. + * TimestampRules describe the rules applied exclusively to the `google.protobuf.Timestamp` well-known type. * * @generated from message buf.validate.TimestampRules */ @@ -4091,6 +4237,19 @@ export type TimestampRules = Message<"buf.validate.TimestampRules"> & { within?: Duration; /** + * `example` specifies values that the field may have. These values SHOULD + * conform to other rules. `example` values will not impact validation + * but may be used as helpful guidance on how to populate the given field. + * + * ```proto + * message MyTimestamp { + * google.protobuf.Timestamp value = 1 [ + * (buf.validate.field).timestamp.example = { seconds: 1672444800 }, + * (buf.validate.field).timestamp.example = { seconds: 1672531200 }, + * ]; + * } + * ``` + * * @generated from field: repeated google.protobuf.Timestamp example = 10; */ example: Timestamp[]; @@ -4101,11 +4260,11 @@ export type TimestampRules = Message<"buf.validate.TimestampRules"> & { * Use `create(TimestampRulesSchema)` to create a new message. */ export const TimestampRulesSchema: GenMessage = /*@__PURE__*/ - messageDesc(file_buf_validate_validate, 25); + messageDesc(file_buf_validate_validate, 26); /** * `Violations` is a collection of `Violation` messages. This message type is returned by - * protovalidate when a proto message fails to meet the requirements set by the `Constraint` validation rules. + * Protovalidate when a proto message fails to meet the requirements set by the `Rule` validation rules. * Each individual violation is represented by a `Violation` message. * * @generated from message buf.validate.Violations @@ -4124,19 +4283,50 @@ export type Violations = Message<"buf.validate.Violations"> & { * Use `create(ViolationsSchema)` to create a new message. */ export const ViolationsSchema: GenMessage = /*@__PURE__*/ - messageDesc(file_buf_validate_validate, 26); + messageDesc(file_buf_validate_validate, 27); /** * `Violation` represents a single instance where a validation rule, expressed - * as a `Constraint`, was not met. It provides information about the field that - * caused the violation, the specific constraint that wasn't fulfilled, and a + * as a `Rule`, was not met. It provides information about the field that + * caused the violation, the specific rule that wasn't fulfilled, and a * human-readable error message. * + * For example, consider the following message: + * + * ```proto + * message User { + * int32 age = 1 [(buf.validate.field).cel = { + * id: "user.age", + * expression: "this < 18 ? 'User must be at least 18 years old' : ''", + * }]; + * } + * ``` + * + * It could produce the following violation: + * * ```json * { - * "fieldPath": "bar", - * "constraintId": "foo.bar", - * "message": "bar must be greater than 0" + * "ruleId": "user.age", + * "message": "User must be at least 18 years old", + * "field": { + * "elements": [ + * { + * "fieldNumber": 1, + * "fieldName": "age", + * "fieldType": "TYPE_INT32" + * } + * ] + * }, + * "rule": { + * "elements": [ + * { + * "fieldNumber": 23, + * "fieldName": "cel", + * "fieldType": "TYPE_MESSAGE", + * "index": "0" + * } + * ] + * } * } * ``` * @@ -4169,9 +4359,9 @@ export type Violation = Message<"buf.validate.Violation"> & { field?: FieldPath; /** - * `rule` is a machine-readable path that points to the specific constraint rule that failed validation. - * This will be a nested field starting from the FieldConstraints of the field that failed validation. - * For custom constraints, this will provide the path of the constraint, e.g. `cel[0]`. + * `rule` is a machine-readable path that points to the specific rule that failed validation. + * This will be a nested field starting from the FieldRules of the field that failed validation. + * For custom rules, this will provide the path of the rule, e.g. `cel[0]`. * * For example, consider the following message: * @@ -4179,7 +4369,7 @@ export type Violation = Message<"buf.validate.Violation"> & { * message Message { * bool a = 1 [(buf.validate.field).required = true]; * bool b = 2 [(buf.validate.field).cel = { - * id: "custom_constraint", + * id: "custom_rule", * expression: "!this ? 'b must be true': ''" * }] * } @@ -4203,16 +4393,16 @@ export type Violation = Message<"buf.validate.Violation"> & { rule?: FieldPath; /** - * `constraint_id` is the unique identifier of the `Constraint` that was not fulfilled. - * This is the same `id` that was specified in the `Constraint` message, allowing easy tracing of which rule was violated. + * `rule_id` is the unique identifier of the `Rule` that was not fulfilled. + * This is the same `id` that was specified in the `Rule` message, allowing easy tracing of which rule was violated. * - * @generated from field: optional string constraint_id = 2; + * @generated from field: optional string rule_id = 2; */ - constraintId: string; + ruleId: string; /** * `message` is a human-readable error message that describes the nature of the violation. - * This can be the default error message from the violated `Constraint`, or it can be a custom message that gives more context about the violation. + * This can be the default error message from the violated `Rule`, or it can be a custom message that gives more context about the violation. * * @generated from field: optional string message = 3; */ @@ -4231,7 +4421,7 @@ export type Violation = Message<"buf.validate.Violation"> & { * Use `create(ViolationSchema)` to create a new message. */ export const ViolationSchema: GenMessage = /*@__PURE__*/ - messageDesc(file_buf_validate_validate, 27); + messageDesc(file_buf_validate_validate, 28); /** * `FieldPath` provides a path to a nested protobuf field. @@ -4255,7 +4445,7 @@ export type FieldPath = Message<"buf.validate.FieldPath"> & { * Use `create(FieldPathSchema)` to create a new message. */ export const FieldPathSchema: GenMessage = /*@__PURE__*/ - messageDesc(file_buf_validate_validate, 28); + messageDesc(file_buf_validate_validate, 29); /** * `FieldPathElement` provides enough information to nest through a single protobuf field. @@ -4368,163 +4558,101 @@ export type FieldPathElement = Message<"buf.validate.FieldPathElement"> & { * Use `create(FieldPathElementSchema)` to create a new message. */ export const FieldPathElementSchema: GenMessage = /*@__PURE__*/ - messageDesc(file_buf_validate_validate, 29); + messageDesc(file_buf_validate_validate, 30); /** - * Specifies how FieldConstraints.ignore behaves. See the documentation for - * FieldConstraints.required for definitions of "populated" and "nullable". + * Specifies how `FieldRules.ignore` behaves, depending on the field's value, and + * whether the field tracks presence. * * @generated from enum buf.validate.Ignore */ export enum Ignore { /** - * Validation is only skipped if it's an unpopulated nullable fields. + * Ignore rules if the field tracks presence and is unset. This is the default + * behavior. + * + * In proto3, only message fields, members of a Protobuf `oneof`, and fields + * with the `optional` label track presence. Consequently, the following fields + * are always validated, whether a value is set or not: * * ```proto * syntax="proto3"; * - * message Request { - * // The uri rule applies to any value, including the empty string. - * string foo = 1 [ - * (buf.validate.field).string.uri = true - * ]; - * - * // The uri rule only applies if the field is set, including if it's - * // set to the empty string. - * optional string bar = 2 [ - * (buf.validate.field).string.uri = true + * message RulesApply { + * string email = 1 [ + * (buf.validate.field).string.email = true * ]; - * - * // The min_items rule always applies, even if the list is empty. - * repeated string baz = 3 [ - * (buf.validate.field).repeated.min_items = 3 + * int32 age = 2 [ + * (buf.validate.field).int32.gt = 0 * ]; - * - * // The custom CEL rule applies only if the field is set, including if - * // it's the "zero" value of that message. - * SomeMessage quux = 4 [ - * (buf.validate.field).cel = {/* ... *\/} + * repeated string labels = 3 [ + * (buf.validate.field).repeated.min_items = 1 * ]; * } * ``` * - * @generated from enum value: IGNORE_UNSPECIFIED = 0; - */ - UNSPECIFIED = 0, - - /** - * Validation is skipped if the field is unpopulated. This rule is redundant - * if the field is already nullable. + * In contrast, the following fields track presence, and are only validated if + * a value is set: * * ```proto - * syntax="proto3 - * - * message Request { - * // The uri rule applies only if the value is not the empty string. - * string foo = 1 [ - * (buf.validate.field).string.uri = true, - * (buf.validate.field).ignore = IGNORE_IF_UNPOPULATED - * ]; - * - * // IGNORE_IF_UNPOPULATED is equivalent to IGNORE_UNSPECIFIED in this - * // case: the uri rule only applies if the field is set, including if - * // it's set to the empty string. - * optional string bar = 2 [ - * (buf.validate.field).string.uri = true, - * (buf.validate.field).ignore = IGNORE_IF_UNPOPULATED - * ]; + * syntax="proto3"; * - * // The min_items rule only applies if the list has at least one item. - * repeated string baz = 3 [ - * (buf.validate.field).repeated.min_items = 3, - * (buf.validate.field).ignore = IGNORE_IF_UNPOPULATED + * message RulesApplyIfSet { + * optional string email = 1 [ + * (buf.validate.field).string.email = true * ]; - * - * // IGNORE_IF_UNPOPULATED is equivalent to IGNORE_UNSPECIFIED in this - * // case: the custom CEL rule applies only if the field is set, including - * // if it's the "zero" value of that message. - * SomeMessage quux = 4 [ - * (buf.validate.field).cel = {/* ... *\/}, - * (buf.validate.field).ignore = IGNORE_IF_UNPOPULATED + * oneof ref { + * string reference = 2 [ + * (buf.validate.field).string.uuid = true + * ]; + * string name = 3 [ + * (buf.validate.field).string.min_len = 4 + * ]; + * } + * SomeMessage msg = 4 [ + * (buf.validate.field).cel = {/* ... *\/} * ]; * } * ``` * - * @generated from enum value: IGNORE_IF_UNPOPULATED = 1; + * To ensure that such a field is set, add the `required` rule. + * + * To learn which fields track presence, see the + * [Field Presence cheat sheet](https://protobuf.dev/programming-guides/field_presence/#cheat). + * + * @generated from enum value: IGNORE_UNSPECIFIED = 0; */ - IF_UNPOPULATED = 1, + UNSPECIFIED = 0, /** - * Validation is skipped if the field is unpopulated or if it is a nullable - * field populated with its default value. This is typically the zero or - * empty value, but proto2 scalars support custom defaults. For messages, the - * default is a non-null message with all its fields unpopulated. - * - * ```proto - * syntax="proto3 - * - * message Request { - * // IGNORE_IF_DEFAULT_VALUE is equivalent to IGNORE_IF_UNPOPULATED in - * // this case; the uri rule applies only if the value is not the empty - * // string. - * string foo = 1 [ - * (buf.validate.field).string.uri = true, - * (buf.validate.field).ignore = IGNORE_IF_DEFAULT_VALUE - * ]; + * Ignore rules if the field is unset, or set to the zero value. * - * // The uri rule only applies if the field is set to a value other than - * // the empty string. - * optional string bar = 2 [ - * (buf.validate.field).string.uri = true, - * (buf.validate.field).ignore = IGNORE_IF_DEFAULT_VALUE - * ]; - * - * // IGNORE_IF_DEFAULT_VALUE is equivalent to IGNORE_IF_UNPOPULATED in - * // this case; the min_items rule only applies if the list has at least - * // one item. - * repeated string baz = 3 [ - * (buf.validate.field).repeated.min_items = 3, - * (buf.validate.field).ignore = IGNORE_IF_DEFAULT_VALUE - * ]; - * - * // The custom CEL rule only applies if the field is set to a value other - * // than an empty message (i.e., fields are unpopulated). - * SomeMessage quux = 4 [ - * (buf.validate.field).cel = {/* ... *\/}, - * (buf.validate.field).ignore = IGNORE_IF_DEFAULT_VALUE - * ]; - * } - * ``` - * - * This rule is affected by proto2 custom default values: + * The zero value depends on the field type: + * - For strings, the zero value is the empty string. + * - For bytes, the zero value is empty bytes. + * - For bool, the zero value is false. + * - For numeric types, the zero value is zero. + * - For enums, the zero value is the first defined enum value. + * - For repeated fields, the zero is an empty list. + * - For map fields, the zero is an empty map. + * - For message fields, absence of the message (typically a null-value) is considered zero value. * - * ```proto - * syntax="proto2"; - * - * message Request { - * // The gt rule only applies if the field is set and it's value is not - * the default (i.e., not -42). The rule even applies if the field is set - * to zero since the default value differs. - * optional int32 value = 1 [ - * default = -42, - * (buf.validate.field).int32.gt = 0, - * (buf.validate.field).ignore = IGNORE_IF_DEFAULT_VALUE - * ]; - * } + * For fields that track presence (e.g. adding the `optional` label in proto3), + * this a no-op and behavior is the same as the default `IGNORE_UNSPECIFIED`. * - * @generated from enum value: IGNORE_IF_DEFAULT_VALUE = 2; + * @generated from enum value: IGNORE_IF_ZERO_VALUE = 1; */ - IF_DEFAULT_VALUE = 2, + IF_ZERO_VALUE = 1, /** - * The validation rules of this field will be skipped and not evaluated. This - * is useful for situations that necessitate turning off the rules of a field - * containing a message that may not make sense in the current context, or to - * temporarily disable constraints during development. + * Always ignore rules, including the `required` rule. + * + * This is useful for ignoring the rules of a referenced message, or to + * temporarily ignore rules during development. * * ```proto * message MyMessage { - * // The field's rules will always be ignored, including any validation's + * // The field's rules will always be ignored, including any validations * // on value's fields. * MyOtherMessage value = 1 [ * (buf.validate.field).ignore = IGNORE_ALWAYS]; @@ -4543,7 +4671,7 @@ export const IgnoreSchema: GenEnum = /*@__PURE__*/ enumDesc(file_buf_validate_validate, 0); /** - * WellKnownRegex contain some well-known patterns. + * KnownRegex contains some well-known patterns. * * @generated from enum buf.validate.KnownRegex */ @@ -4554,14 +4682,14 @@ export enum KnownRegex { UNSPECIFIED = 0, /** - * HTTP header name as defined by [RFC 7230](https://tools.ietf.org/html/rfc7230#section-3.2). + * HTTP header name as defined by [RFC 7230](https://datatracker.ietf.org/doc/html/rfc7230#section-3.2). * * @generated from enum value: KNOWN_REGEX_HTTP_HEADER_NAME = 1; */ HTTP_HEADER_NAME = 1, /** - * HTTP header value as defined by [RFC 7230](https://tools.ietf.org/html/rfc7230#section-3.2.4). + * HTTP header value as defined by [RFC 7230](https://datatracker.ietf.org/doc/html/rfc7230#section-3.2.4). * * @generated from enum value: KNOWN_REGEX_HTTP_HEADER_VALUE = 2; */ @@ -4578,31 +4706,31 @@ export const KnownRegexSchema: GenEnum = /*@__PURE__*/ * Rules specify the validations to be performed on this message. By default, * no validation is performed against a message. * - * @generated from extension: optional buf.validate.MessageConstraints message = 1159; + * @generated from extension: optional buf.validate.MessageRules message = 1159; */ -export const message: GenExtension = /*@__PURE__*/ +export const message: GenExtension = /*@__PURE__*/ extDesc(file_buf_validate_validate, 0); /** * Rules specify the validations to be performed on this oneof. By default, * no validation is performed against a oneof. * - * @generated from extension: optional buf.validate.OneofConstraints oneof = 1159; + * @generated from extension: optional buf.validate.OneofRules oneof = 1159; */ -export const oneof: GenExtension = /*@__PURE__*/ +export const oneof: GenExtension = /*@__PURE__*/ extDesc(file_buf_validate_validate, 1); /** * Rules specify the validations to be performed on this field. By default, * no validation is performed against a field. * - * @generated from extension: optional buf.validate.FieldConstraints field = 1159; + * @generated from extension: optional buf.validate.FieldRules field = 1159; */ -export const field: GenExtension = /*@__PURE__*/ +export const field: GenExtension = /*@__PURE__*/ extDesc(file_buf_validate_validate, 2); /** - * Specifies predefined rules. When extending a standard constraint message, + * Specifies predefined rules. When extending a standard rule message, * this adds additional CEL expressions that apply when the extension is used. * * ```proto @@ -4619,8 +4747,8 @@ export const field: GenExtension = /*@__PURE__*/ * } * ``` * - * @generated from extension: optional buf.validate.PredefinedConstraints predefined = 1160; + * @generated from extension: optional buf.validate.PredefinedRules predefined = 1160; */ -export const predefined: GenExtension = /*@__PURE__*/ +export const predefined: GenExtension = /*@__PURE__*/ extDesc(file_buf_validate_validate, 3); diff --git a/lib/src/platform/common/common_pb.ts b/lib/src/platform/common/common_pb.ts index 305d4ab70..3f3c94c35 100644 --- a/lib/src/platform/common/common_pb.ts +++ b/lib/src/platform/common/common_pb.ts @@ -6,13 +6,58 @@ import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1" import { enumDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; import type { Timestamp } from "@bufbuild/protobuf/wkt"; import { file_google_protobuf_timestamp } from "@bufbuild/protobuf/wkt"; +import { file_buf_validate_validate } from "../buf/validate/validate_pb.js"; import type { Message } from "@bufbuild/protobuf"; /** * Describes the file common/common.proto. */ export const file_common_common: GenFile = /*@__PURE__*/ - fileDesc("ChNjb21tb24vY29tbW9uLnByb3RvEgZjb21tb24ixwEKCE1ldGFkYXRhEi4KCmNyZWF0ZWRfYXQYASABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEi4KCnVwZGF0ZWRfYXQYAiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEiwKBmxhYmVscxgDIAMoCzIcLmNvbW1vbi5NZXRhZGF0YS5MYWJlbHNFbnRyeRotCgtMYWJlbHNFbnRyeRILCgNrZXkYASABKAkSDQoFdmFsdWUYAiABKAk6AjgBInUKD01ldGFkYXRhTXV0YWJsZRIzCgZsYWJlbHMYAyADKAsyIy5jb21tb24uTWV0YWRhdGFNdXRhYmxlLkxhYmVsc0VudHJ5Gi0KC0xhYmVsc0VudHJ5EgsKA2tleRgBIAEoCRINCgV2YWx1ZRgCIAEoCToCOAEqfQoSTWV0YWRhdGFVcGRhdGVFbnVtEiQKIE1FVEFEQVRBX1VQREFURV9FTlVNX1VOU1BFQ0lGSUVEEAASHwobTUVUQURBVEFfVVBEQVRFX0VOVU1fRVhURU5EEAESIAocTUVUQURBVEFfVVBEQVRFX0VOVU1fUkVQTEFDRRACKo0BCg9BY3RpdmVTdGF0ZUVudW0SIQodQUNUSVZFX1NUQVRFX0VOVU1fVU5TUEVDSUZJRUQQABIcChhBQ1RJVkVfU1RBVEVfRU5VTV9BQ1RJVkUQARIeChpBQ1RJVkVfU1RBVEVfRU5VTV9JTkFDVElWRRACEhkKFUFDVElWRV9TVEFURV9FTlVNX0FOWRADYgZwcm90bzM", [file_google_protobuf_timestamp]); + fileDesc("ChNjb21tb24vY29tbW9uLnByb3RvEgZjb21tb24iyAIKEElkTmFtZUlkZW50aWZpZXISFAoCaWQYASABKAlCCLpIBXIDsAEBEooCCgRuYW1lGAIgASgJQvsBukj3AboB7AEKC25hbWVfZm9ybWF0Ep8BTmFtZSBtdXN0IGJlIGFuIGFscGhhbnVtZXJpYyBzdHJpbmcsIGFsbG93aW5nIGh5cGhlbnMgYW5kIHVuZGVyc2NvcmVzIGJ1dCBub3QgYXMgdGhlIGZpcnN0IG9yIGxhc3QgY2hhcmFjdGVyLiBUaGUgc3RvcmVkIG5hbWUgd2lsbCBiZSBub3JtYWxpemVkIHRvIGxvd2VyIGNhc2UuGjt0aGlzLm1hdGNoZXMoJ15bYS16QS1aMC05XSg/OlthLXpBLVowLTlfLV0qW2EtekEtWjAtOV0pPyQnKXIFEAEY/QE6EbpIDiIMCgJpZAoEbmFtZRABIlIKD0lkRnFuSWRlbnRpZmllchIUCgJpZBgBIAEoCUIIukgFcgOwAQESFwoDZnFuGAIgASgJQgq6SAdyBRABiAEBOhC6SA0iCwoCaWQKA2ZxbhABIscBCghNZXRhZGF0YRIuCgpjcmVhdGVkX2F0GAEgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBIuCgp1cGRhdGVkX2F0GAIgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBIsCgZsYWJlbHMYAyADKAsyHC5jb21tb24uTWV0YWRhdGEuTGFiZWxzRW50cnkaLQoLTGFiZWxzRW50cnkSCwoDa2V5GAEgASgJEg0KBXZhbHVlGAIgASgJOgI4ASJ1Cg9NZXRhZGF0YU11dGFibGUSMwoGbGFiZWxzGAMgAygLMiMuY29tbW9uLk1ldGFkYXRhTXV0YWJsZS5MYWJlbHNFbnRyeRotCgtMYWJlbHNFbnRyeRILCgNrZXkYASABKAkSDQoFdmFsdWUYAiABKAk6AjgBKn0KEk1ldGFkYXRhVXBkYXRlRW51bRIkCiBNRVRBREFUQV9VUERBVEVfRU5VTV9VTlNQRUNJRklFRBAAEh8KG01FVEFEQVRBX1VQREFURV9FTlVNX0VYVEVORBABEiAKHE1FVEFEQVRBX1VQREFURV9FTlVNX1JFUExBQ0UQAiqNAQoPQWN0aXZlU3RhdGVFbnVtEiEKHUFDVElWRV9TVEFURV9FTlVNX1VOU1BFQ0lGSUVEEAASHAoYQUNUSVZFX1NUQVRFX0VOVU1fQUNUSVZFEAESHgoaQUNUSVZFX1NUQVRFX0VOVU1fSU5BQ1RJVkUQAhIZChVBQ1RJVkVfU1RBVEVfRU5VTV9BTlkQA2IGcHJvdG8z", [file_google_protobuf_timestamp, file_buf_validate_validate]); + +/** + * @generated from message common.IdNameIdentifier + */ +export type IdNameIdentifier = Message<"common.IdNameIdentifier"> & { + /** + * @generated from field: string id = 1; + */ + id: string; + + /** + * @generated from field: string name = 2; + */ + name: string; +}; + +/** + * Describes the message common.IdNameIdentifier. + * Use `create(IdNameIdentifierSchema)` to create a new message. + */ +export const IdNameIdentifierSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_common_common, 0); + +/** + * @generated from message common.IdFqnIdentifier + */ +export type IdFqnIdentifier = Message<"common.IdFqnIdentifier"> & { + /** + * @generated from field: string id = 1; + */ + id: string; + + /** + * @generated from field: string fqn = 2; + */ + fqn: string; +}; + +/** + * Describes the message common.IdFqnIdentifier. + * Use `create(IdFqnIdentifierSchema)` to create a new message. + */ +export const IdFqnIdentifierSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_common_common, 1); /** * Struct to uniquely identify a resource with optional additional metadata @@ -47,7 +92,7 @@ export type Metadata = Message<"common.Metadata"> & { * Use `create(MetadataSchema)` to create a new message. */ export const MetadataSchema: GenMessage = /*@__PURE__*/ - messageDesc(file_common_common, 0); + messageDesc(file_common_common, 2); /** * @generated from message common.MetadataMutable @@ -66,7 +111,7 @@ export type MetadataMutable = Message<"common.MetadataMutable"> & { * Use `create(MetadataMutableSchema)` to create a new message. */ export const MetadataMutableSchema: GenMessage = /*@__PURE__*/ - messageDesc(file_common_common, 1); + messageDesc(file_common_common, 3); /** * @generated from enum common.MetadataUpdateEnum diff --git a/lib/src/platform/entity/entity_pb.ts b/lib/src/platform/entity/entity_pb.ts new file mode 100644 index 000000000..c470ed880 --- /dev/null +++ b/lib/src/platform/entity/entity_pb.ts @@ -0,0 +1,154 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.js" +// @generated from file entity/entity.proto (package entity, syntax proto3) +/* eslint-disable */ + +import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1"; +import { enumDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1"; +import { file_buf_validate_validate } from "../buf/validate/validate_pb.js"; +import type { Any } from "@bufbuild/protobuf/wkt"; +import { file_google_protobuf_any } from "@bufbuild/protobuf/wkt"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file entity/entity.proto. + */ +export const file_entity_entity: GenFile = /*@__PURE__*/ + fileDesc("ChNlbnRpdHkvZW50aXR5LnByb3RvEgZlbnRpdHkiMgoFVG9rZW4SFAoMZXBoZW1lcmFsX2lkGAEgASgJEhMKA2p3dBgCIAEoCUIGukgDyAEBIpkCCgZFbnRpdHkSFAoMZXBoZW1lcmFsX2lkGAEgASgJEhcKDWVtYWlsX2FkZHJlc3MYAiABKAlIABITCgl1c2VyX25hbWUYAyABKAlIABImCgZjbGFpbXMYBCABKAsyFC5nb29nbGUucHJvdG9idWYuQW55SAASEwoJY2xpZW50X2lkGAUgASgJSAASKQoIY2F0ZWdvcnkYCyABKA4yFy5lbnRpdHkuRW50aXR5LkNhdGVnb3J5IlQKCENhdGVnb3J5EhgKFENBVEVHT1JZX1VOU1BFQ0lGSUVEEAASFAoQQ0FURUdPUllfU1VCSkVDVBABEhgKFENBVEVHT1JZX0VOVklST05NRU5UEAJCDQoLZW50aXR5X3R5cGUiRQoLRW50aXR5Q2hhaW4SFAoMZXBoZW1lcmFsX2lkGAEgASgJEiAKCGVudGl0aWVzGAIgAygLMg4uZW50aXR5LkVudGl0eWIGcHJvdG8z", [file_buf_validate_validate, file_google_protobuf_any]); + +/** + * @generated from message entity.Token + */ +export type Token = Message<"entity.Token"> & { + /** + * ephemeral id for tracking between request and response + * + * @generated from field: string ephemeral_id = 1; + */ + ephemeralId: string; + + /** + * the token + * + * @generated from field: string jwt = 2; + */ + jwt: string; +}; + +/** + * Describes the message entity.Token. + * Use `create(TokenSchema)` to create a new message. + */ +export const TokenSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_entity_entity, 0); + +/** + * PE (Person Entity) or NPE (Non-Person Entity) + * + * @generated from message entity.Entity + */ +export type Entity = Message<"entity.Entity"> & { + /** + * ephemeral id for tracking between request and response + * + * @generated from field: string ephemeral_id = 1; + */ + ephemeralId: string; + + /** + * Standard entity types supported by the platform, one of which must be set + * + * @generated from oneof entity.Entity.entity_type + */ + entityType: { + /** + * @generated from field: string email_address = 2; + */ + value: string; + case: "emailAddress"; + } | { + /** + * @generated from field: string user_name = 3; + */ + value: string; + case: "userName"; + } | { + /** + * used by ERS claims mode + * + * @generated from field: google.protobuf.Any claims = 4; + */ + value: Any; + case: "claims"; + } | { + /** + * @generated from field: string client_id = 5; + */ + value: string; + case: "clientId"; + } | { case: undefined; value?: undefined }; + + /** + * @generated from field: entity.Entity.Category category = 11; + */ + category: Entity_Category; +}; + +/** + * Describes the message entity.Entity. + * Use `create(EntitySchema)` to create a new message. + */ +export const EntitySchema: GenMessage = /*@__PURE__*/ + messageDesc(file_entity_entity, 1); + +/** + * @generated from enum entity.Entity.Category + */ +export enum Entity_Category { + /** + * @generated from enum value: CATEGORY_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * @generated from enum value: CATEGORY_SUBJECT = 1; + */ + SUBJECT = 1, + + /** + * @generated from enum value: CATEGORY_ENVIRONMENT = 2; + */ + ENVIRONMENT = 2, +} + +/** + * Describes the enum entity.Entity.Category. + */ +export const Entity_CategorySchema: GenEnum = /*@__PURE__*/ + enumDesc(file_entity_entity, 1, 0); + +/** + * A set of related PE and NPE + * + * @generated from message entity.EntityChain + */ +export type EntityChain = Message<"entity.EntityChain"> & { + /** + * ephemeral id for tracking between request and response + * + * @generated from field: string ephemeral_id = 1; + */ + ephemeralId: string; + + /** + * @generated from field: repeated entity.Entity entities = 2; + */ + entities: Entity[]; +}; + +/** + * Describes the message entity.EntityChain. + * Use `create(EntityChainSchema)` to create a new message. + */ +export const EntityChainSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_entity_entity, 2); + diff --git a/lib/src/platform/entityresolution/v2/entity_resolution_pb.ts b/lib/src/platform/entityresolution/v2/entity_resolution_pb.ts new file mode 100644 index 000000000..b0c121751 --- /dev/null +++ b/lib/src/platform/entityresolution/v2/entity_resolution_pb.ts @@ -0,0 +1,170 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.js" +// @generated from file entityresolution/v2/entity_resolution.proto (package entityresolution.v2, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage, GenService } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc, serviceDesc } from "@bufbuild/protobuf/codegenv1"; +import { file_buf_validate_validate } from "../../buf/validate/validate_pb.js"; +import type { Entity, EntityChain, Token } from "../../entity/entity_pb.js"; +import { file_entity_entity } from "../../entity/entity_pb.js"; +import type { Any } from "@bufbuild/protobuf/wkt"; +import { file_google_protobuf_any, file_google_protobuf_struct } from "@bufbuild/protobuf/wkt"; +import type { JsonObject, Message } from "@bufbuild/protobuf"; + +/** + * Describes the file entityresolution/v2/entity_resolution.proto. + */ +export const file_entityresolution_v2_entity_resolution: GenFile = /*@__PURE__*/ + fileDesc("CitlbnRpdHlyZXNvbHV0aW9uL3YyL2VudGl0eV9yZXNvbHV0aW9uLnByb3RvEhNlbnRpdHlyZXNvbHV0aW9uLnYyIl4KFEVudGl0eVJlcHJlc2VudGF0aW9uEhMKC29yaWdpbmFsX2lkGAEgASgJEjEKEGFkZGl0aW9uYWxfcHJvcHMYAiADKAsyFy5nb29nbGUucHJvdG9idWYuU3RydWN0IkcKFlJlc29sdmVFbnRpdGllc1JlcXVlc3QSLQoIZW50aXRpZXMYASADKAsyDi5lbnRpdHkuRW50aXR5Qgu6SAjIAQGSAQIIASJkChdSZXNvbHZlRW50aXRpZXNSZXNwb25zZRJJChZlbnRpdHlfcmVwcmVzZW50YXRpb25zGAEgAygLMikuZW50aXR5cmVzb2x1dGlvbi52Mi5FbnRpdHlSZXByZXNlbnRhdGlvbiJrChNFbnRpdHlOb3RGb3VuZEVycm9yEgwKBGNvZGUYASABKAUSDwoHbWVzc2FnZRgCIAEoCRIlCgdkZXRhaWxzGAMgAygLMhQuZ29vZ2xlLnByb3RvYnVmLkFueRIOCgZlbnRpdHkYBCABKAkiRAojQ3JlYXRlRW50aXR5Q2hhaW5zRnJvbVRva2Vuc1JlcXVlc3QSHQoGdG9rZW5zGAEgAygLMg0uZW50aXR5LlRva2VuIlIKJENyZWF0ZUVudGl0eUNoYWluc0Zyb21Ub2tlbnNSZXNwb25zZRIqCg1lbnRpdHlfY2hhaW5zGAEgAygLMhMuZW50aXR5LkVudGl0eUNoYWluMqECChdFbnRpdHlSZXNvbHV0aW9uU2VydmljZRJuCg9SZXNvbHZlRW50aXRpZXMSKy5lbnRpdHlyZXNvbHV0aW9uLnYyLlJlc29sdmVFbnRpdGllc1JlcXVlc3QaLC5lbnRpdHlyZXNvbHV0aW9uLnYyLlJlc29sdmVFbnRpdGllc1Jlc3BvbnNlIgASlQEKHENyZWF0ZUVudGl0eUNoYWluc0Zyb21Ub2tlbnMSOC5lbnRpdHlyZXNvbHV0aW9uLnYyLkNyZWF0ZUVudGl0eUNoYWluc0Zyb21Ub2tlbnNSZXF1ZXN0GjkuZW50aXR5cmVzb2x1dGlvbi52Mi5DcmVhdGVFbnRpdHlDaGFpbnNGcm9tVG9rZW5zUmVzcG9uc2UiAGIGcHJvdG8z", [file_buf_validate_validate, file_entity_entity, file_google_protobuf_any, file_google_protobuf_struct]); + +/** + * @generated from message entityresolution.v2.EntityRepresentation + */ +export type EntityRepresentation = Message<"entityresolution.v2.EntityRepresentation"> & { + /** + * ephemeral entity id from the request + * + * @generated from field: string original_id = 1; + */ + originalId: string; + + /** + * @generated from field: repeated google.protobuf.Struct additional_props = 2; + */ + additionalProps: JsonObject[]; +}; + +/** + * Describes the message entityresolution.v2.EntityRepresentation. + * Use `create(EntityRepresentationSchema)` to create a new message. + */ +export const EntityRepresentationSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_entityresolution_v2_entity_resolution, 0); + +/** + * Resolve a set of entities to their representations. + * + * @generated from message entityresolution.v2.ResolveEntitiesRequest + */ +export type ResolveEntitiesRequest = Message<"entityresolution.v2.ResolveEntitiesRequest"> & { + /** + * @generated from field: repeated entity.Entity entities = 1; + */ + entities: Entity[]; +}; + +/** + * Describes the message entityresolution.v2.ResolveEntitiesRequest. + * Use `create(ResolveEntitiesRequestSchema)` to create a new message. + */ +export const ResolveEntitiesRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_entityresolution_v2_entity_resolution, 1); + +/** + * @generated from message entityresolution.v2.ResolveEntitiesResponse + */ +export type ResolveEntitiesResponse = Message<"entityresolution.v2.ResolveEntitiesResponse"> & { + /** + * @generated from field: repeated entityresolution.v2.EntityRepresentation entity_representations = 1; + */ + entityRepresentations: EntityRepresentation[]; +}; + +/** + * Describes the message entityresolution.v2.ResolveEntitiesResponse. + * Use `create(ResolveEntitiesResponseSchema)` to create a new message. + */ +export const ResolveEntitiesResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_entityresolution_v2_entity_resolution, 2); + +/** + * @generated from message entityresolution.v2.EntityNotFoundError + */ +export type EntityNotFoundError = Message<"entityresolution.v2.EntityNotFoundError"> & { + /** + * @generated from field: int32 code = 1; + */ + code: number; + + /** + * @generated from field: string message = 2; + */ + message: string; + + /** + * @generated from field: repeated google.protobuf.Any details = 3; + */ + details: Any[]; + + /** + * @generated from field: string entity = 4; + */ + entity: string; +}; + +/** + * Describes the message entityresolution.v2.EntityNotFoundError. + * Use `create(EntityNotFoundErrorSchema)` to create a new message. + */ +export const EntityNotFoundErrorSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_entityresolution_v2_entity_resolution, 3); + +/** + * Create an entity chain for each token (JWT) in the request. + * + * @generated from message entityresolution.v2.CreateEntityChainsFromTokensRequest + */ +export type CreateEntityChainsFromTokensRequest = Message<"entityresolution.v2.CreateEntityChainsFromTokensRequest"> & { + /** + * @generated from field: repeated entity.Token tokens = 1; + */ + tokens: Token[]; +}; + +/** + * Describes the message entityresolution.v2.CreateEntityChainsFromTokensRequest. + * Use `create(CreateEntityChainsFromTokensRequestSchema)` to create a new message. + */ +export const CreateEntityChainsFromTokensRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_entityresolution_v2_entity_resolution, 4); + +/** + * @generated from message entityresolution.v2.CreateEntityChainsFromTokensResponse + */ +export type CreateEntityChainsFromTokensResponse = Message<"entityresolution.v2.CreateEntityChainsFromTokensResponse"> & { + /** + * @generated from field: repeated entity.EntityChain entity_chains = 1; + */ + entityChains: EntityChain[]; +}; + +/** + * Describes the message entityresolution.v2.CreateEntityChainsFromTokensResponse. + * Use `create(CreateEntityChainsFromTokensResponseSchema)` to create a new message. + */ +export const CreateEntityChainsFromTokensResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_entityresolution_v2_entity_resolution, 5); + +/** + * @generated from service entityresolution.v2.EntityResolutionService + */ +export const EntityResolutionService: GenService<{ + /** + * @generated from rpc entityresolution.v2.EntityResolutionService.ResolveEntities + */ + resolveEntities: { + methodKind: "unary"; + input: typeof ResolveEntitiesRequestSchema; + output: typeof ResolveEntitiesResponseSchema; + }, + /** + * @generated from rpc entityresolution.v2.EntityResolutionService.CreateEntityChainsFromTokens + */ + createEntityChainsFromTokens: { + methodKind: "unary"; + input: typeof CreateEntityChainsFromTokensRequestSchema; + output: typeof CreateEntityChainsFromTokensResponseSchema; + }, +}> = /*@__PURE__*/ + serviceDesc(file_entityresolution_v2_entity_resolution, 0); + diff --git a/lib/src/platform/google/api/annotations_pb.ts b/lib/src/platform/google/api/annotations_pb.ts index cbe26cb12..cc7768f26 100644 --- a/lib/src/platform/google/api/annotations_pb.ts +++ b/lib/src/platform/google/api/annotations_pb.ts @@ -1,4 +1,4 @@ -// Copyright 2024 Google LLC +// Copyright 2025 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. diff --git a/lib/src/platform/google/api/http_pb.ts b/lib/src/platform/google/api/http_pb.ts index 793377515..50bfa9f5b 100644 --- a/lib/src/platform/google/api/http_pb.ts +++ b/lib/src/platform/google/api/http_pb.ts @@ -1,4 +1,4 @@ -// Copyright 2024 Google LLC +// Copyright 2025 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -24,7 +24,7 @@ import type { Message } from "@bufbuild/protobuf"; * Describes the file google/api/http.proto. */ export const file_google_api_http: GenFile = /*@__PURE__*/ - fileDesc("ChVnb29nbGUvYXBpL2h0dHAucHJvdG8SCmdvb2dsZS5hcGkiVAoESHR0cBIjCgVydWxlcxgBIAMoCzIULmdvb2dsZS5hcGkuSHR0cFJ1bGUSJwofZnVsbHlfZGVjb2RlX3Jlc2VydmVkX2V4cGFuc2lvbhgCIAEoCCKBAgoISHR0cFJ1bGUSEAoIc2VsZWN0b3IYASABKAkSDQoDZ2V0GAIgASgJSAASDQoDcHV0GAMgASgJSAASDgoEcG9zdBgEIAEoCUgAEhAKBmRlbGV0ZRgFIAEoCUgAEg8KBXBhdGNoGAYgASgJSAASLwoGY3VzdG9tGAggASgLMh0uZ29vZ2xlLmFwaS5DdXN0b21IdHRwUGF0dGVybkgAEgwKBGJvZHkYByABKAkSFQoNcmVzcG9uc2VfYm9keRgMIAEoCRIxChNhZGRpdGlvbmFsX2JpbmRpbmdzGAsgAygLMhQuZ29vZ2xlLmFwaS5IdHRwUnVsZUIJCgdwYXR0ZXJuIi8KEUN1c3RvbUh0dHBQYXR0ZXJuEgwKBGtpbmQYASABKAkSDAoEcGF0aBgCIAEoCUJqCg5jb20uZ29vZ2xlLmFwaUIJSHR0cFByb3RvUAFaQWdvb2dsZS5nb2xhbmcub3JnL2dlbnByb3RvL2dvb2dsZWFwaXMvYXBpL2Fubm90YXRpb25zO2Fubm90YXRpb25z+AEBogIER0FQSWIGcHJvdG8z"); + fileDesc("ChVnb29nbGUvYXBpL2h0dHAucHJvdG8SCmdvb2dsZS5hcGkiVAoESHR0cBIjCgVydWxlcxgBIAMoCzIULmdvb2dsZS5hcGkuSHR0cFJ1bGUSJwofZnVsbHlfZGVjb2RlX3Jlc2VydmVkX2V4cGFuc2lvbhgCIAEoCCKBAgoISHR0cFJ1bGUSEAoIc2VsZWN0b3IYASABKAkSDQoDZ2V0GAIgASgJSAASDQoDcHV0GAMgASgJSAASDgoEcG9zdBgEIAEoCUgAEhAKBmRlbGV0ZRgFIAEoCUgAEg8KBXBhdGNoGAYgASgJSAASLwoGY3VzdG9tGAggASgLMh0uZ29vZ2xlLmFwaS5DdXN0b21IdHRwUGF0dGVybkgAEgwKBGJvZHkYByABKAkSFQoNcmVzcG9uc2VfYm9keRgMIAEoCRIxChNhZGRpdGlvbmFsX2JpbmRpbmdzGAsgAygLMhQuZ29vZ2xlLmFwaS5IdHRwUnVsZUIJCgdwYXR0ZXJuIi8KEUN1c3RvbUh0dHBQYXR0ZXJuEgwKBGtpbmQYASABKAkSDAoEcGF0aBgCIAEoCUJnCg5jb20uZ29vZ2xlLmFwaUIJSHR0cFByb3RvUAFaQWdvb2dsZS5nb2xhbmcub3JnL2dlbnByb3RvL2dvb2dsZWFwaXMvYXBpL2Fubm90YXRpb25zO2Fubm90YXRpb25zogIER0FQSWIGcHJvdG8z"); /** * Defines the HTTP configuration for an API service. It contains a list of diff --git a/lib/src/platform/kas/kas_pb.ts b/lib/src/platform/kas/kas_pb.ts index e4eebf555..9724bfdfb 100644 --- a/lib/src/platform/kas/kas_pb.ts +++ b/lib/src/platform/kas/kas_pb.ts @@ -14,7 +14,7 @@ import type { Message } from "@bufbuild/protobuf"; * Describes the file kas/kas.proto. */ export const file_kas_kas: GenFile = /*@__PURE__*/ - fileDesc("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", [file_google_api_annotations, file_google_protobuf_struct, file_google_protobuf_wrappers, file_protoc_gen_openapiv2_options_annotations]); + fileDesc("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", [file_google_api_annotations, file_google_protobuf_struct, file_google_protobuf_wrappers, file_protoc_gen_openapiv2_options_annotations]); /** * Intentionally empty. May include features later. @@ -462,9 +462,14 @@ export const AccessService: GenService<{ output: typeof PublicKeyResponseSchema; }, /** + * Endpoint intended for gRPC Gateway's REST endpoint to provide v1 compatibility with older TDF clients + * + * This endpoint is not recommended for use in new applications, prefer the v2 endpoint ('PublicKey') instead. + * * buf:lint:ignore RPC_RESPONSE_STANDARD_NAME * * @generated from rpc kas.AccessService.LegacyPublicKey + * @deprecated */ legacyPublicKey: { methodKind: "unary"; diff --git a/lib/src/platform/policy/attributes/attributes_pb.ts b/lib/src/platform/policy/attributes/attributes_pb.ts index 26d227716..2fa004c13 100644 --- a/lib/src/platform/policy/attributes/attributes_pb.ts +++ b/lib/src/platform/policy/attributes/attributes_pb.ts @@ -18,10 +18,13 @@ import type { Message } from "@bufbuild/protobuf"; * Describes the file policy/attributes/attributes.proto. */ export const file_policy_attributes_attributes: GenFile = /*@__PURE__*/ - fileDesc("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", [file_buf_validate_validate, file_common_common, file_google_api_annotations, file_policy_objects, file_policy_selectors]); + fileDesc("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", [file_buf_validate_validate, file_common_common, file_google_api_annotations, file_policy_objects, file_policy_selectors]); /** + * Deprecated + * * @generated from message policy.attributes.AttributeKeyAccessServer + * @deprecated */ export type AttributeKeyAccessServer = Message<"policy.attributes.AttributeKeyAccessServer"> & { /** @@ -42,12 +45,14 @@ export type AttributeKeyAccessServer = Message<"policy.attributes.AttributeKeyAc /** * Describes the message policy.attributes.AttributeKeyAccessServer. * Use `create(AttributeKeyAccessServerSchema)` to create a new message. + * @deprecated */ export const AttributeKeyAccessServerSchema: GenMessage = /*@__PURE__*/ messageDesc(file_policy_attributes_attributes, 0); /** * @generated from message policy.attributes.ValueKeyAccessServer + * @deprecated */ export type ValueKeyAccessServer = Message<"policy.attributes.ValueKeyAccessServer"> & { /** @@ -68,6 +73,7 @@ export type ValueKeyAccessServer = Message<"policy.attributes.ValueKeyAccessServ /** * Describes the message policy.attributes.ValueKeyAccessServer. * Use `create(ValueKeyAccessServerSchema)` to create a new message. + * @deprecated */ export const ValueKeyAccessServerSchema: GenMessage = /*@__PURE__*/ messageDesc(file_policy_attributes_attributes, 1); @@ -263,7 +269,7 @@ export type CreateAttributeRequest = Message<"policy.attributes.CreateAttributeR rule: AttributeRuleTypeEnum; /** - * Optional + * Optional * Attribute values (when provided) must be alphanumeric strings, allowing hyphens and underscores but not as the first or last character. * The stored attribute value will be normalized to lower case. * @@ -710,6 +716,7 @@ export const GetAttributeValuesByFqnsResponse_AttributeAndValueSchema: GenMessag /** * @generated from message policy.attributes.AssignKeyAccessServerToAttributeRequest + * @deprecated */ export type AssignKeyAccessServerToAttributeRequest = Message<"policy.attributes.AssignKeyAccessServerToAttributeRequest"> & { /** @@ -723,12 +730,14 @@ export type AssignKeyAccessServerToAttributeRequest = Message<"policy.attributes /** * Describes the message policy.attributes.AssignKeyAccessServerToAttributeRequest. * Use `create(AssignKeyAccessServerToAttributeRequestSchema)` to create a new message. + * @deprecated */ export const AssignKeyAccessServerToAttributeRequestSchema: GenMessage = /*@__PURE__*/ messageDesc(file_policy_attributes_attributes, 26); /** * @generated from message policy.attributes.AssignKeyAccessServerToAttributeResponse + * @deprecated */ export type AssignKeyAccessServerToAttributeResponse = Message<"policy.attributes.AssignKeyAccessServerToAttributeResponse"> & { /** @@ -740,12 +749,14 @@ export type AssignKeyAccessServerToAttributeResponse = Message<"policy.attribute /** * Describes the message policy.attributes.AssignKeyAccessServerToAttributeResponse. * Use `create(AssignKeyAccessServerToAttributeResponseSchema)` to create a new message. + * @deprecated */ export const AssignKeyAccessServerToAttributeResponseSchema: GenMessage = /*@__PURE__*/ messageDesc(file_policy_attributes_attributes, 27); /** * @generated from message policy.attributes.RemoveKeyAccessServerFromAttributeRequest + * @deprecated */ export type RemoveKeyAccessServerFromAttributeRequest = Message<"policy.attributes.RemoveKeyAccessServerFromAttributeRequest"> & { /** @@ -759,12 +770,14 @@ export type RemoveKeyAccessServerFromAttributeRequest = Message<"policy.attribut /** * Describes the message policy.attributes.RemoveKeyAccessServerFromAttributeRequest. * Use `create(RemoveKeyAccessServerFromAttributeRequestSchema)` to create a new message. + * @deprecated */ export const RemoveKeyAccessServerFromAttributeRequestSchema: GenMessage = /*@__PURE__*/ messageDesc(file_policy_attributes_attributes, 28); /** * @generated from message policy.attributes.RemoveKeyAccessServerFromAttributeResponse + * @deprecated */ export type RemoveKeyAccessServerFromAttributeResponse = Message<"policy.attributes.RemoveKeyAccessServerFromAttributeResponse"> & { /** @@ -776,12 +789,14 @@ export type RemoveKeyAccessServerFromAttributeResponse = Message<"policy.attribu /** * Describes the message policy.attributes.RemoveKeyAccessServerFromAttributeResponse. * Use `create(RemoveKeyAccessServerFromAttributeResponseSchema)` to create a new message. + * @deprecated */ export const RemoveKeyAccessServerFromAttributeResponseSchema: GenMessage = /*@__PURE__*/ messageDesc(file_policy_attributes_attributes, 29); /** * @generated from message policy.attributes.AssignKeyAccessServerToValueRequest + * @deprecated */ export type AssignKeyAccessServerToValueRequest = Message<"policy.attributes.AssignKeyAccessServerToValueRequest"> & { /** @@ -795,12 +810,14 @@ export type AssignKeyAccessServerToValueRequest = Message<"policy.attributes.Ass /** * Describes the message policy.attributes.AssignKeyAccessServerToValueRequest. * Use `create(AssignKeyAccessServerToValueRequestSchema)` to create a new message. + * @deprecated */ export const AssignKeyAccessServerToValueRequestSchema: GenMessage = /*@__PURE__*/ messageDesc(file_policy_attributes_attributes, 30); /** * @generated from message policy.attributes.AssignKeyAccessServerToValueResponse + * @deprecated */ export type AssignKeyAccessServerToValueResponse = Message<"policy.attributes.AssignKeyAccessServerToValueResponse"> & { /** @@ -812,12 +829,14 @@ export type AssignKeyAccessServerToValueResponse = Message<"policy.attributes.As /** * Describes the message policy.attributes.AssignKeyAccessServerToValueResponse. * Use `create(AssignKeyAccessServerToValueResponseSchema)` to create a new message. + * @deprecated */ export const AssignKeyAccessServerToValueResponseSchema: GenMessage = /*@__PURE__*/ messageDesc(file_policy_attributes_attributes, 31); /** * @generated from message policy.attributes.RemoveKeyAccessServerFromValueRequest + * @deprecated */ export type RemoveKeyAccessServerFromValueRequest = Message<"policy.attributes.RemoveKeyAccessServerFromValueRequest"> & { /** @@ -831,12 +850,14 @@ export type RemoveKeyAccessServerFromValueRequest = Message<"policy.attributes.R /** * Describes the message policy.attributes.RemoveKeyAccessServerFromValueRequest. * Use `create(RemoveKeyAccessServerFromValueRequestSchema)` to create a new message. + * @deprecated */ export const RemoveKeyAccessServerFromValueRequestSchema: GenMessage = /*@__PURE__*/ messageDesc(file_policy_attributes_attributes, 32); /** * @generated from message policy.attributes.RemoveKeyAccessServerFromValueResponse + * @deprecated */ export type RemoveKeyAccessServerFromValueResponse = Message<"policy.attributes.RemoveKeyAccessServerFromValueResponse"> & { /** @@ -848,6 +869,7 @@ export type RemoveKeyAccessServerFromValueResponse = Message<"policy.attributes. /** * Describes the message policy.attributes.RemoveKeyAccessServerFromValueResponse. * Use `create(RemoveKeyAccessServerFromValueResponseSchema)` to create a new message. + * @deprecated */ export const RemoveKeyAccessServerFromValueResponseSchema: GenMessage = /*@__PURE__*/ messageDesc(file_policy_attributes_attributes, 33); @@ -1114,6 +1136,7 @@ export const AttributesService: GenService<{ * --------------------------------------- * * @generated from rpc policy.attributes.AttributesService.AssignKeyAccessServerToAttribute + * @deprecated */ assignKeyAccessServerToAttribute: { methodKind: "unary"; @@ -1122,6 +1145,7 @@ export const AttributesService: GenService<{ }, /** * @generated from rpc policy.attributes.AttributesService.RemoveKeyAccessServerFromAttribute + * @deprecated */ removeKeyAccessServerFromAttribute: { methodKind: "unary"; @@ -1130,6 +1154,7 @@ export const AttributesService: GenService<{ }, /** * @generated from rpc policy.attributes.AttributesService.AssignKeyAccessServerToValue + * @deprecated */ assignKeyAccessServerToValue: { methodKind: "unary"; @@ -1138,6 +1163,7 @@ export const AttributesService: GenService<{ }, /** * @generated from rpc policy.attributes.AttributesService.RemoveKeyAccessServerFromValue + * @deprecated */ removeKeyAccessServerFromValue: { methodKind: "unary"; diff --git a/lib/src/platform/policy/kasregistry/key_access_server_registry_pb.ts b/lib/src/platform/policy/kasregistry/key_access_server_registry_pb.ts index 6c9794ea6..45ade9705 100644 --- a/lib/src/platform/policy/kasregistry/key_access_server_registry_pb.ts +++ b/lib/src/platform/policy/kasregistry/key_access_server_registry_pb.ts @@ -5,9 +5,9 @@ import type { GenFile, GenMessage, GenService } from "@bufbuild/protobuf/codegenv1"; import { fileDesc, messageDesc, serviceDesc } from "@bufbuild/protobuf/codegenv1"; import { file_buf_validate_validate } from "../../buf/validate/validate_pb.js"; -import { file_google_api_annotations } from "../../google/api/annotations_pb.js"; import type { MetadataMutable, MetadataUpdateEnum } from "../../common/common_pb.js"; import { file_common_common } from "../../common/common_pb.js"; +import { file_google_api_annotations } from "../../google/api/annotations_pb.js"; import type { Algorithm, KasKey, KasPublicKey, Key, KeyAccessServer, KeyMode, PrivateKeyCtx, PublicKey, PublicKeyCtx, SimpleKasKey, SourceType } from "../objects_pb.js"; import { file_policy_objects } from "../objects_pb.js"; import type { PageRequest, PageResponse } from "../selectors_pb.js"; @@ -18,7 +18,7 @@ import type { Message } from "@bufbuild/protobuf"; * Describes the file policy/kasregistry/key_access_server_registry.proto. */ export const file_policy_kasregistry_key_access_server_registry: GenFile = /*@__PURE__*/ - fileDesc("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", [file_buf_validate_validate, file_google_api_annotations, file_common_common, file_policy_objects, file_policy_selectors]); + fileDesc("CjNwb2xpY3kva2FzcmVnaXN0cnkva2V5X2FjY2Vzc19zZXJ2ZXJfcmVnaXN0cnkucHJvdG8SEnBvbGljeS5rYXNyZWdpc3RyeSLOAwoZR2V0S2V5QWNjZXNzU2VydmVyUmVxdWVzdBIZCgJpZBgBIAEoCUINGAG6SAjYAQFyA7ABARIaCgZrYXNfaWQYAiABKAlCCLpIBXIDsAEBSAASFwoEbmFtZRgDIAEoCUIHukgEcgIQAUgAEhkKA3VyaRgEIAEoCUIKukgHcgUQAYgBAUgAOrcCukizAhqoAQoQZXhjbHVzaXZlX2ZpZWxkcxJKRWl0aGVyIHVzZSBkZXByZWNhdGVkICdpZCcgZmllbGQgb3Igb25lIG9mICdrYXNfaWQnIG9yICd1cmknLCBidXQgbm90IGJvdGgaSCEoaGFzKHRoaXMuaWQpICYmIChoYXModGhpcy5rYXNfaWQpIHx8IGhhcyh0aGlzLnVyaSkgfHwgaGFzKHRoaXMubmFtZSkpKRqFAQoPcmVxdWlyZWRfZmllbGRzEi1FaXRoZXIgaWQgb3Igb25lIG9mIGthc19pZCBvciB1cmkgbXVzdCBiZSBzZXQaQ2hhcyh0aGlzLmlkKSB8fCBoYXModGhpcy5rYXNfaWQpIHx8IGhhcyh0aGlzLnVyaSkgfHwgaGFzKHRoaXMubmFtZSlCDAoKaWRlbnRpZmllciJQChpHZXRLZXlBY2Nlc3NTZXJ2ZXJSZXNwb25zZRIyChFrZXlfYWNjZXNzX3NlcnZlchgBIAEoCzIXLnBvbGljeS5LZXlBY2Nlc3NTZXJ2ZXIiRgobTGlzdEtleUFjY2Vzc1NlcnZlcnNSZXF1ZXN0EicKCnBhZ2luYXRpb24YCiABKAsyEy5wb2xpY3kuUGFnZVJlcXVlc3QifQocTGlzdEtleUFjY2Vzc1NlcnZlcnNSZXNwb25zZRIzChJrZXlfYWNjZXNzX3NlcnZlcnMYASADKAsyFy5wb2xpY3kuS2V5QWNjZXNzU2VydmVyEigKCnBhZ2luYXRpb24YCiABKAsyFC5wb2xpY3kuUGFnZVJlc3BvbnNlIukFChxDcmVhdGVLZXlBY2Nlc3NTZXJ2ZXJSZXF1ZXN0EoICCgN1cmkYASABKAlC9AG6SPABugHsAQoKdXJpX2Zvcm1hdBLPAVVSSSBtdXN0IGJlIGEgdmFsaWQgVVJMIChlLmcuLCAnaHR0cHM6Ly9kZW1vLmNvbS8nKSBmb2xsb3dlZCBieSBhZGRpdGlvbmFsIHNlZ21lbnRzLiBFYWNoIHNlZ21lbnQgbXVzdCBzdGFydCBhbmQgZW5kIHdpdGggYW4gYWxwaGFudW1lcmljIGNoYXJhY3RlciwgY2FuIGNvbnRhaW4gaHlwaGVucywgYWxwaGFudW1lcmljIGNoYXJhY3RlcnMsIGFuZCBzbGFzaGVzLhoMdGhpcy5pc1VyaSgpEiUKCnB1YmxpY19rZXkYAiABKAsyES5wb2xpY3kuUHVibGljS2V5EjQKC3NvdXJjZV90eXBlGAMgASgOMhIucG9saWN5LlNvdXJjZVR5cGVCC7pICMgBAIIBAhABErsCCgRuYW1lGBQgASgJQqwCukioAroBnAIKD2thc19uYW1lX2Zvcm1hdBKzAVJlZ2lzdGVyZWQgS0FTIG5hbWUgbXVzdCBiZSBhbiBhbHBoYW51bWVyaWMgc3RyaW5nLCBhbGxvd2luZyBoeXBoZW5zLCBhbmQgdW5kZXJzY29yZXMgYnV0IG5vdCBhcyB0aGUgZmlyc3Qgb3IgbGFzdCBjaGFyYWN0ZXIuIFRoZSBzdG9yZWQgS0FTIG5hbWUgd2lsbCBiZSBub3JtYWxpemVkIHRvIGxvd2VyIGNhc2UuGlNzaXplKHRoaXMpID4gMCA/IHRoaXMubWF0Y2hlcygnXlthLXpBLVowLTldKD86W2EtekEtWjAtOV8tXSpbYS16QS1aMC05XSk/JCcpIDogdHJ1ZcgBAHIDGP0BEikKCG1ldGFkYXRhGGQgASgLMhcuY29tbW9uLk1ldGFkYXRhTXV0YWJsZSJTCh1DcmVhdGVLZXlBY2Nlc3NTZXJ2ZXJSZXNwb25zZRIyChFrZXlfYWNjZXNzX3NlcnZlchgBIAEoCzIXLnBvbGljeS5LZXlBY2Nlc3NTZXJ2ZXIi3QYKHFVwZGF0ZUtleUFjY2Vzc1NlcnZlclJlcXVlc3QSFAoCaWQYASABKAlCCLpIBXIDsAEBEqcCCgN1cmkYAiABKAlCmQK6SJUCugGRAgoTb3B0aW9uYWxfdXJpX2Zvcm1hdBLYAU9wdGlvbmFsIFVSSSBtdXN0IGJlIGEgdmFsaWQgVVJMIChlLmcuLCAnaHR0cHM6Ly9kZW1vLmNvbS8nKSBmb2xsb3dlZCBieSBhZGRpdGlvbmFsIHNlZ21lbnRzLiBFYWNoIHNlZ21lbnQgbXVzdCBzdGFydCBhbmQgZW5kIHdpdGggYW4gYWxwaGFudW1lcmljIGNoYXJhY3RlciwgY2FuIGNvbnRhaW4gaHlwaGVucywgYWxwaGFudW1lcmljIGNoYXJhY3RlcnMsIGFuZCBzbGFzaGVzLhofc2l6ZSh0aGlzKSA9PSAwIHx8IHRoaXMuaXNVcmkoKRIlCgpwdWJsaWNfa2V5GAMgASgLMhEucG9saWN5LlB1YmxpY0tleRI0Cgtzb3VyY2VfdHlwZRgEIAEoDjISLnBvbGljeS5Tb3VyY2VUeXBlQgu6SAjIAQCCAQIQARK2AgoEbmFtZRgUIAEoCUKnArpIowK6AZcCCg9rYXNfbmFtZV9mb3JtYXQSswFSZWdpc3RlcmVkIEtBUyBuYW1lIG11c3QgYmUgYW4gYWxwaGFudW1lcmljIHN0cmluZywgYWxsb3dpbmcgaHlwaGVucywgYW5kIHVuZGVyc2NvcmVzIGJ1dCBub3QgYXMgdGhlIGZpcnN0IG9yIGxhc3QgY2hhcmFjdGVyLiBUaGUgc3RvcmVkIEtBUyBuYW1lIHdpbGwgYmUgbm9ybWFsaXplZCB0byBsb3dlciBjYXNlLhpOc2l6ZSh0aGlzKSA9PSAwIHx8IHRoaXMubWF0Y2hlcygnXlthLXpBLVowLTldKD86W2EtekEtWjAtOV8tXSpbYS16QS1aMC05XSk/JCcpyAEAcgMY/QESKQoIbWV0YWRhdGEYZCABKAsyFy5jb21tb24uTWV0YWRhdGFNdXRhYmxlEjwKGG1ldGFkYXRhX3VwZGF0ZV9iZWhhdmlvchhlIAEoDjIaLmNvbW1vbi5NZXRhZGF0YVVwZGF0ZUVudW0iUwodVXBkYXRlS2V5QWNjZXNzU2VydmVyUmVzcG9uc2USMgoRa2V5X2FjY2Vzc19zZXJ2ZXIYASABKAsyFy5wb2xpY3kuS2V5QWNjZXNzU2VydmVyIjQKHERlbGV0ZUtleUFjY2Vzc1NlcnZlclJlcXVlc3QSFAoCaWQYASABKAlCCLpIBXIDsAEBIlMKHURlbGV0ZUtleUFjY2Vzc1NlcnZlclJlc3BvbnNlEjIKEWtleV9hY2Nlc3Nfc2VydmVyGAEgASgLMhcucG9saWN5LktleUFjY2Vzc1NlcnZlciIuChNHcmFudGVkUG9saWN5T2JqZWN0EgoKAmlkGAEgASgJEgsKA2ZxbhgCIAEoCSKQAgoVS2V5QWNjZXNzU2VydmVyR3JhbnRzEjIKEWtleV9hY2Nlc3Nfc2VydmVyGAEgASgLMhcucG9saWN5LktleUFjY2Vzc1NlcnZlchJBChBuYW1lc3BhY2VfZ3JhbnRzGAIgAygLMicucG9saWN5Lmthc3JlZ2lzdHJ5LkdyYW50ZWRQb2xpY3lPYmplY3QSQQoQYXR0cmlidXRlX2dyYW50cxgDIAMoCzInLnBvbGljeS5rYXNyZWdpc3RyeS5HcmFudGVkUG9saWN5T2JqZWN0Ej0KDHZhbHVlX2dyYW50cxgEIAMoCzInLnBvbGljeS5rYXNyZWdpc3RyeS5HcmFudGVkUG9saWN5T2JqZWN0IogBChZDcmVhdGVQdWJsaWNLZXlSZXF1ZXN0EhgKBmthc19pZBgBIAEoCUIIukgFcgOwAQESKQoDa2V5GAIgASgLMhQucG9saWN5Lkthc1B1YmxpY0tleUIGukgDyAEBEikKCG1ldGFkYXRhGGQgASgLMhcuY29tbW9uLk1ldGFkYXRhTXV0YWJsZSIzChdDcmVhdGVQdWJsaWNLZXlSZXNwb25zZRIYCgNrZXkYASABKAsyCy5wb2xpY3kuS2V5IjsKE0dldFB1YmxpY0tleVJlcXVlc3QSFgoCaWQYASABKAlCCLpIBXIDsAEBSABCDAoKaWRlbnRpZmllciIwChRHZXRQdWJsaWNLZXlSZXNwb25zZRIYCgNrZXkYASABKAsyCy5wb2xpY3kuS2V5IqYBChVMaXN0UHVibGljS2V5c1JlcXVlc3QSGgoGa2FzX2lkGAEgASgJQgi6SAVyA7ABAUgAEhsKCGthc19uYW1lGAIgASgJQge6SARyAhABSAASHQoHa2FzX3VyaRgDIAEoCUIKukgHcgUQAYgBAUgAEicKCnBhZ2luYXRpb24YCiABKAsyEy5wb2xpY3kuUGFnZVJlcXVlc3RCDAoKa2FzX2ZpbHRlciJdChZMaXN0UHVibGljS2V5c1Jlc3BvbnNlEhkKBGtleXMYASADKAsyCy5wb2xpY3kuS2V5EigKCnBhZ2luYXRpb24YCiABKAsyFC5wb2xpY3kuUGFnZVJlc3BvbnNlItABChtMaXN0UHVibGljS2V5TWFwcGluZ1JlcXVlc3QSGgoGa2FzX2lkGAEgASgJQgi6SAVyA7ABAUgAEhsKCGthc19uYW1lGAIgASgJQge6SARyAhABSAASHQoHa2FzX3VyaRgDIAEoCUIKukgHcgUQAYgBAUgAEiIKDXB1YmxpY19rZXlfaWQYBCABKAlCC7pICNgBAXIDsAEBEicKCnBhZ2luYXRpb24YCiABKAsyEy5wb2xpY3kuUGFnZVJlcXVlc3RCDAoKa2FzX2ZpbHRlciKEBQocTGlzdFB1YmxpY0tleU1hcHBpbmdSZXNwb25zZRJeChNwdWJsaWNfa2V5X21hcHBpbmdzGAEgAygLMkEucG9saWN5Lmthc3JlZ2lzdHJ5Lkxpc3RQdWJsaWNLZXlNYXBwaW5nUmVzcG9uc2UuUHVibGljS2V5TWFwcGluZxIoCgpwYWdpbmF0aW9uGAogASgLMhQucG9saWN5LlBhZ2VSZXNwb25zZRqWAQoQUHVibGljS2V5TWFwcGluZxIOCgZrYXNfaWQYAiABKAkSEAoIa2FzX25hbWUYAyABKAkSDwoHa2FzX3VyaRgEIAEoCRJPCgtwdWJsaWNfa2V5cxgFIAMoCzI6LnBvbGljeS5rYXNyZWdpc3RyeS5MaXN0UHVibGljS2V5TWFwcGluZ1Jlc3BvbnNlLlB1YmxpY0tleRqYAgoJUHVibGljS2V5EhgKA2tleRgBIAEoCzILLnBvbGljeS5LZXkSTAoGdmFsdWVzGAYgAygLMjwucG9saWN5Lmthc3JlZ2lzdHJ5Lkxpc3RQdWJsaWNLZXlNYXBwaW5nUmVzcG9uc2UuQXNzb2NpYXRpb24SUQoLZGVmaW5pdGlvbnMYByADKAsyPC5wb2xpY3kua2FzcmVnaXN0cnkuTGlzdFB1YmxpY0tleU1hcHBpbmdSZXNwb25zZS5Bc3NvY2lhdGlvbhJQCgpuYW1lc3BhY2VzGAggAygLMjwucG9saWN5Lmthc3JlZ2lzdHJ5Lkxpc3RQdWJsaWNLZXlNYXBwaW5nUmVzcG9uc2UuQXNzb2NpYXRpb24aJgoLQXNzb2NpYXRpb24SCgoCaWQYASABKAkSCwoDZnFuGAIgASgJIpcBChZVcGRhdGVQdWJsaWNLZXlSZXF1ZXN0EhQKAmlkGAEgASgJQgi6SAVyA7ABARIpCghtZXRhZGF0YRhkIAEoCzIXLmNvbW1vbi5NZXRhZGF0YU11dGFibGUSPAoYbWV0YWRhdGFfdXBkYXRlX2JlaGF2aW9yGGUgASgOMhouY29tbW9uLk1ldGFkYXRhVXBkYXRlRW51bSIzChdVcGRhdGVQdWJsaWNLZXlSZXNwb25zZRIYCgNrZXkYASABKAsyCy5wb2xpY3kuS2V5IjIKGkRlYWN0aXZhdGVQdWJsaWNLZXlSZXF1ZXN0EhQKAmlkGAEgASgJQgi6SAVyA7ABASI3ChtEZWFjdGl2YXRlUHVibGljS2V5UmVzcG9uc2USGAoDa2V5GAEgASgLMgsucG9saWN5LktleSIwChhBY3RpdmF0ZVB1YmxpY0tleVJlcXVlc3QSFAoCaWQYASABKAlCCLpIBXIDsAEBIjUKGUFjdGl2YXRlUHVibGljS2V5UmVzcG9uc2USGAoDa2V5GAEgASgLMgsucG9saWN5LktleSKBBwogTGlzdEtleUFjY2Vzc1NlcnZlckdyYW50c1JlcXVlc3QSxAEKBmthc19pZBgBIAEoCUKzAbpIrwG6AasBChRvcHRpb25hbF91dWlkX2Zvcm1hdBIjT3B0aW9uYWwgZmllbGQgbXVzdCBiZSBhIHZhbGlkIFVVSUQabnNpemUodGhpcykgPT0gMCB8fCB0aGlzLm1hdGNoZXMoJ1swLTlhLWZBLUZdezh9LVswLTlhLWZBLUZdezR9LVswLTlhLWZBLUZdezR9LVswLTlhLWZBLUZdezR9LVswLTlhLWZBLUZdezEyfScpEqsCCgdrYXNfdXJpGAIgASgJQpkCukiVAroBkQIKE29wdGlvbmFsX3VyaV9mb3JtYXQS2AFPcHRpb25hbCBVUkkgbXVzdCBiZSBhIHZhbGlkIFVSTCAoZS5nLiwgJ2h0dHBzOi8vZGVtby5jb20vJykgZm9sbG93ZWQgYnkgYWRkaXRpb25hbCBzZWdtZW50cy4gRWFjaCBzZWdtZW50IG11c3Qgc3RhcnQgYW5kIGVuZCB3aXRoIGFuIGFscGhhbnVtZXJpYyBjaGFyYWN0ZXIsIGNhbiBjb250YWluIGh5cGhlbnMsIGFscGhhbnVtZXJpYyBjaGFyYWN0ZXJzLCBhbmQgc2xhc2hlcy4aH3NpemUodGhpcykgPT0gMCB8fCB0aGlzLmlzVXJpKCkSugIKCGthc19uYW1lGAMgASgJQqcCukijAroBlwIKD2thc19uYW1lX2Zvcm1hdBKzAVJlZ2lzdGVyZWQgS0FTIG5hbWUgbXVzdCBiZSBhbiBhbHBoYW51bWVyaWMgc3RyaW5nLCBhbGxvd2luZyBoeXBoZW5zLCBhbmQgdW5kZXJzY29yZXMgYnV0IG5vdCBhcyB0aGUgZmlyc3Qgb3IgbGFzdCBjaGFyYWN0ZXIuIFRoZSBzdG9yZWQgS0FTIG5hbWUgd2lsbCBiZSBub3JtYWxpemVkIHRvIGxvd2VyIGNhc2UuGk5zaXplKHRoaXMpID09IDAgfHwgdGhpcy5tYXRjaGVzKCdeW2EtekEtWjAtOV0oPzpbYS16QS1aMC05Xy1dKlthLXpBLVowLTldKT8kJynIAQByAxj9ARInCgpwYWdpbmF0aW9uGAogASgLMhMucG9saWN5LlBhZ2VSZXF1ZXN0OgIYASKQAQohTGlzdEtleUFjY2Vzc1NlcnZlckdyYW50c1Jlc3BvbnNlEj0KBmdyYW50cxgBIAMoCzIpLnBvbGljeS5rYXNyZWdpc3RyeS5LZXlBY2Nlc3NTZXJ2ZXJHcmFudHNCAhgBEigKCnBhZ2luYXRpb24YCiABKAsyFC5wb2xpY3kuUGFnZVJlc3BvbnNlOgIYASLmCwoQQ3JlYXRlS2V5UmVxdWVzdBIYCgZrYXNfaWQYASABKAlCCLpIBXIDsAEBEhcKBmtleV9pZBgCIAEoCUIHukgEcgIQARKWAQoNa2V5X2FsZ29yaXRobRgDIAEoDjIRLnBvbGljeS5BbGdvcml0aG1CbLpIaboBZgoVa2V5X2FsZ29yaXRobV9kZWZpbmVkEjRUaGUga2V5X2FsZ29yaXRobSBtdXN0IGJlIG9uZSBvZiB0aGUgZGVmaW5lZCB2YWx1ZXMuGhd0aGlzIGluIFsxLCAyLCAzLCA0LCA1XRKKAQoIa2V5X21vZGUYBCABKA4yDy5wb2xpY3kuS2V5TW9kZUJnukhkugFhChBrZXlfbW9kZV9kZWZpbmVkEjVUaGUga2V5X21vZGUgbXVzdCBiZSBvbmUgb2YgdGhlIGRlZmluZWQgdmFsdWVzICgxLTQpLhoWdGhpcyA+PSAxICYmIHRoaXMgPD0gNBI0Cg5wdWJsaWNfa2V5X2N0eBgFIAEoCzIULnBvbGljeS5QdWJsaWNLZXlDdHhCBrpIA8gBARIuCg9wcml2YXRlX2tleV9jdHgYBiABKAsyFS5wb2xpY3kuUHJpdmF0ZUtleUN0eBIaChJwcm92aWRlcl9jb25maWdfaWQYByABKAkSDgoGbGVnYWN5GAggASgIEikKCG1ldGFkYXRhGGQgASgLMhcuY29tbW9uLk1ldGFkYXRhTXV0YWJsZTq7B7pItwcalwMKI3ByaXZhdGVfa2V5X2N0eF9vcHRpb25hbGx5X3JlcXVpcmVkErwBVGhlIHdyYXBwZWRfa2V5IGlzIHJlcXVpcmVkIGlmIGtleV9tb2RlIGlzIEtFWV9NT0RFX0NPTkZJR19ST09UX0tFWSBvciBLRVlfTU9ERV9QUk9WSURFUl9ST09UX0tFWS4gVGhlIHdyYXBwZWRfa2V5IG11c3QgYmUgZW1wdHkgaWYga2V5X21vZGUgaXMgS0VZX01PREVfUkVNT1RFIG9yIEtFWV9NT0RFX1BVQkxJQ19LRVlfT05MWS4asAEoKHRoaXMua2V5X21vZGUgPT0gMSB8fCB0aGlzLmtleV9tb2RlID09IDIpICYmIHRoaXMucHJpdmF0ZV9rZXlfY3R4LndyYXBwZWRfa2V5ICE9ICcnKSB8fCAoKHRoaXMua2V5X21vZGUgPT0gMyB8fCB0aGlzLmtleV9tb2RlID09IDQpICYmIHRoaXMucHJpdmF0ZV9rZXlfY3R4LndyYXBwZWRfa2V5ID09ICcnKRr0AgomcHJvdmlkZXJfY29uZmlnX2lkX29wdGlvbmFsbHlfcmVxdWlyZWQSqAFQcm92aWRlciBjb25maWcgaWQgaXMgcmVxdWlyZWQgaWYga2V5X21vZGUgaXMgS0VZX01PREVfUFJPVklERVJfUk9PVF9LRVkgb3IgS0VZX01PREVfUkVNT1RFLiBJdCBtdXN0IGJlIGVtcHR5IGZvciBLRVlfTU9ERV9DT05GSUdfUk9PVF9LRVkgYW5kIEtFWV9NT0RFX1BVQkxJQ19LRVlfT05MWS4angEoKHRoaXMua2V5X21vZGUgPT0gMSB8fCB0aGlzLmtleV9tb2RlID09IDQpICYmIHRoaXMucHJvdmlkZXJfY29uZmlnX2lkID09ICcnKSB8fCAoKHRoaXMua2V5X21vZGUgPT0gMiB8fCB0aGlzLmtleV9tb2RlID09IDMpICYmIHRoaXMucHJvdmlkZXJfY29uZmlnX2lkICE9ICcnKRqjAQojcHJpdmF0ZV9rZXlfY3R4X2Zvcl9wdWJsaWNfa2V5X29ubHkSSHByaXZhdGVfa2V5X2N0eCBtdXN0IG5vdCBiZSBzZXQgaWYga2V5X21vZGUgaXMgS0VZX01PREVfUFVCTElDX0tFWV9PTkxZLhoyISh0aGlzLmtleV9tb2RlID09IDQgJiYgaGFzKHRoaXMucHJpdmF0ZV9rZXlfY3R4KSkiNAoRQ3JlYXRlS2V5UmVzcG9uc2USHwoHa2FzX2tleRgBIAEoCzIOLnBvbGljeS5LYXNLZXkicQoNR2V0S2V5UmVxdWVzdBIWCgJpZBgCIAEoCUIIukgFcgOwAQFIABIzCgNrZXkYAyABKAsyJC5wb2xpY3kua2FzcmVnaXN0cnkuS2FzS2V5SWRlbnRpZmllckgAQhMKCmlkZW50aWZpZXISBbpIAggBIjEKDkdldEtleVJlc3BvbnNlEh8KB2thc19rZXkYASABKAsyDi5wb2xpY3kuS2FzS2V5ItwCCg9MaXN0S2V5c1JlcXVlc3QSmQEKDWtleV9hbGdvcml0aG0YASABKA4yES5wb2xpY3kuQWxnb3JpdGhtQm+6SGy6AWkKFWtleV9hbGdvcml0aG1fZGVmaW5lZBI0VGhlIGtleV9hbGdvcml0aG0gbXVzdCBiZSBvbmUgb2YgdGhlIGRlZmluZWQgdmFsdWVzLhoadGhpcyBpbiBbMCwgMSwgMiwgMywgNCwgNV0SGgoGa2FzX2lkGAIgASgJQgi6SAVyA7ABAUgAEhsKCGthc19uYW1lGAMgASgJQge6SARyAhABSAASHQoHa2FzX3VyaRgEIAEoCUIKukgHcgUQAYgBAUgAEhMKBmxlZ2FjeRgIIAEoCEgBiAEBEicKCnBhZ2luYXRpb24YCiABKAsyEy5wb2xpY3kuUGFnZVJlcXVlc3RCDAoKa2FzX2ZpbHRlckIJCgdfbGVnYWN5Il4KEExpc3RLZXlzUmVzcG9uc2USIAoIa2FzX2tleXMYASADKAsyDi5wb2xpY3kuS2FzS2V5EigKCnBhZ2luYXRpb24YCiABKAsyFC5wb2xpY3kuUGFnZVJlc3BvbnNlIuACChBVcGRhdGVLZXlSZXF1ZXN0EhQKAmlkGAEgASgJQgi6SAVyA7ABARIpCghtZXRhZGF0YRhkIAEoCzIXLmNvbW1vbi5NZXRhZGF0YU11dGFibGUSPAoYbWV0YWRhdGFfdXBkYXRlX2JlaGF2aW9yGGUgASgOMhouY29tbW9uLk1ldGFkYXRhVXBkYXRlRW51bTrMAbpIyAEaxQEKGG1ldGFkYXRhX3VwZGF0ZV9iZWhhdmlvchJSTWV0YWRhdGEgdXBkYXRlIGJlaGF2aW9yIG11c3QgYmUgZWl0aGVyIEFQUEVORCBvciBSRVBMQUNFLCB3aGVuIHVwZGF0aW5nIG1ldGFkYXRhLhpVKCghaGFzKHRoaXMubWV0YWRhdGEpKSB8fCAoaGFzKHRoaXMubWV0YWRhdGEpICYmIHRoaXMubWV0YWRhdGFfdXBkYXRlX2JlaGF2aW9yICE9IDApKSI0ChFVcGRhdGVLZXlSZXNwb25zZRIfCgdrYXNfa2V5GAEgASgLMg4ucG9saWN5Lkthc0tleSKNAQoQS2FzS2V5SWRlbnRpZmllchIaCgZrYXNfaWQYAiABKAlCCLpIBXIDsAEBSAASFwoEbmFtZRgDIAEoCUIHukgEcgIQAUgAEhkKA3VyaRgEIAEoCUIKukgHcgUQAYgBAUgAEhQKA2tpZBgFIAEoCUIHukgEcgIQAUITCgppZGVudGlmaWVyEgW6SAIIASKADgoQUm90YXRlS2V5UmVxdWVzdBIWCgJpZBgBIAEoCUIIukgFcgOwAQFIABIzCgNrZXkYAiABKAsyJC5wb2xpY3kua2FzcmVnaXN0cnkuS2FzS2V5SWRlbnRpZmllckgAEjwKB25ld19rZXkYAyABKAsyKy5wb2xpY3kua2FzcmVnaXN0cnkuUm90YXRlS2V5UmVxdWVzdC5OZXdLZXka+wMKBk5ld0tleRIXCgZrZXlfaWQYASABKAlCB7pIBHICEAESkgEKCWFsZ29yaXRobRgCIAEoDjIRLnBvbGljeS5BbGdvcml0aG1CbLpIaboBZgoVa2V5X2FsZ29yaXRobV9kZWZpbmVkEjRUaGUga2V5X2FsZ29yaXRobSBtdXN0IGJlIG9uZSBvZiB0aGUgZGVmaW5lZCB2YWx1ZXMuGhd0aGlzIGluIFsxLCAyLCAzLCA0LCA1XRKVAQoIa2V5X21vZGUYAyABKA4yDy5wb2xpY3kuS2V5TW9kZUJyukhvugFnChRuZXdfa2V5X21vZGVfZGVmaW5lZBI5VGhlIG5ldyBrZXlfbW9kZSBtdXN0IGJlIG9uZSBvZiB0aGUgZGVmaW5lZCB2YWx1ZXMgKDEtNCkuGhR0aGlzIGluIFsxLCAyLCAzLCA0XYIBAhABEjQKDnB1YmxpY19rZXlfY3R4GAQgASgLMhQucG9saWN5LlB1YmxpY0tleUN0eEIGukgDyAEBEi4KD3ByaXZhdGVfa2V5X2N0eBgFIAEoCzIVLnBvbGljeS5Qcml2YXRlS2V5Q3R4EhoKEnByb3ZpZGVyX2NvbmZpZ19pZBgGIAEoCRIpCghtZXRhZGF0YRhkIAEoCzIXLmNvbW1vbi5NZXRhZGF0YU11dGFibGU6zQi6SMkIGtgDCiNwcml2YXRlX2tleV9jdHhfb3B0aW9uYWxseV9yZXF1aXJlZBLNAUZvciB0aGUgbmV3IGtleSwgdGhlIHdyYXBwZWRfa2V5IGlzIHJlcXVpcmVkIGlmIGtleV9tb2RlIGlzIEtFWV9NT0RFX0NPTkZJR19ST09UX0tFWSBvciBLRVlfTU9ERV9QUk9WSURFUl9ST09UX0tFWS4gVGhlIHdyYXBwZWRfa2V5IG11c3QgYmUgZW1wdHkgaWYga2V5X21vZGUgaXMgS0VZX01PREVfUkVNT1RFIG9yIEtFWV9NT0RFX1BVQkxJQ19LRVlfT05MWS4a4AEoKHRoaXMubmV3X2tleS5rZXlfbW9kZSA9PSAxIHx8IHRoaXMubmV3X2tleS5rZXlfbW9kZSA9PSAyKSAmJiB0aGlzLm5ld19rZXkucHJpdmF0ZV9rZXlfY3R4LndyYXBwZWRfa2V5ICE9ICcnKSB8fCAoKHRoaXMubmV3X2tleS5rZXlfbW9kZSA9PSAzIHx8IHRoaXMubmV3X2tleS5rZXlfbW9kZSA9PSA0KSAmJiB0aGlzLm5ld19rZXkucHJpdmF0ZV9rZXlfY3R4LndyYXBwZWRfa2V5ID09ICcnKRq1AwomcHJvdmlkZXJfY29uZmlnX2lkX29wdGlvbmFsbHlfcmVxdWlyZWQSuQFGb3IgdGhlIG5ldyBrZXksIHByb3ZpZGVyIGNvbmZpZyBpZCBpcyByZXF1aXJlZCBpZiBrZXlfbW9kZSBpcyBLRVlfTU9ERV9QUk9WSURFUl9ST09UX0tFWSBvciBLRVlfTU9ERV9SRU1PVEUuIEl0IG11c3QgYmUgZW1wdHkgZm9yIEtFWV9NT0RFX0NPTkZJR19ST09UX0tFWSBhbmQgS0VZX01PREVfUFVCTElDX0tFWV9PTkxZLhrOASgodGhpcy5uZXdfa2V5LmtleV9tb2RlID09IDEgfHwgdGhpcy5uZXdfa2V5LmtleV9tb2RlID09IDQpICYmIHRoaXMubmV3X2tleS5wcm92aWRlcl9jb25maWdfaWQgPT0gJycpIHx8ICgodGhpcy5uZXdfa2V5LmtleV9tb2RlID09IDIgfHwgdGhpcy5uZXdfa2V5LmtleV9tb2RlID09IDMpICYmIHRoaXMubmV3X2tleS5wcm92aWRlcl9jb25maWdfaWQgIT0gJycpGrMBCiNwcml2YXRlX2tleV9jdHhfZm9yX3B1YmxpY19rZXlfb25seRJIcHJpdmF0ZV9rZXlfY3R4IG11c3Qgbm90IGJlIHNldCBpZiBrZXlfbW9kZSBpcyBLRVlfTU9ERV9QVUJMSUNfS0VZX09OTFkuGkIhKHRoaXMubmV3X2tleS5rZXlfbW9kZSA9PSA0ICYmIGhhcyh0aGlzLm5ld19rZXkucHJpdmF0ZV9rZXlfY3R4KSlCEwoKYWN0aXZlX2tleRIFukgCCAEiKQoOQ2hhbmdlTWFwcGluZ3MSCgoCaWQYASABKAkSCwoDZnFuGAIgASgJIowCChBSb3RhdGVkUmVzb3VyY2VzEicKD3JvdGF0ZWRfb3V0X2tleRgBIAEoCzIOLnBvbGljeS5LYXNLZXkSSQodYXR0cmlidXRlX2RlZmluaXRpb25fbWFwcGluZ3MYAiADKAsyIi5wb2xpY3kua2FzcmVnaXN0cnkuQ2hhbmdlTWFwcGluZ3MSRAoYYXR0cmlidXRlX3ZhbHVlX21hcHBpbmdzGAMgAygLMiIucG9saWN5Lmthc3JlZ2lzdHJ5LkNoYW5nZU1hcHBpbmdzEj4KEm5hbWVzcGFjZV9tYXBwaW5ncxgEIAMoCzIiLnBvbGljeS5rYXNyZWdpc3RyeS5DaGFuZ2VNYXBwaW5ncyJ1ChFSb3RhdGVLZXlSZXNwb25zZRIfCgdrYXNfa2V5GAEgASgLMg4ucG9saWN5Lkthc0tleRI/ChFyb3RhdGVkX3Jlc291cmNlcxgCIAEoCzIkLnBvbGljeS5rYXNyZWdpc3RyeS5Sb3RhdGVkUmVzb3VyY2VzInUKEVNldEJhc2VLZXlSZXF1ZXN0EhYKAmlkGAEgASgJQgi6SAVyA7ABAUgAEjMKA2tleRgCIAEoCzIkLnBvbGljeS5rYXNyZWdpc3RyeS5LYXNLZXlJZGVudGlmaWVySABCEwoKYWN0aXZlX2tleRIFukgCCAEiEwoRR2V0QmFzZUtleVJlcXVlc3QiPAoSR2V0QmFzZUtleVJlc3BvbnNlEiYKCGJhc2Vfa2V5GAEgASgLMhQucG9saWN5LlNpbXBsZUthc0tleSJxChJTZXRCYXNlS2V5UmVzcG9uc2USKgoMbmV3X2Jhc2Vfa2V5GAEgASgLMhQucG9saWN5LlNpbXBsZUthc0tleRIvChFwcmV2aW91c19iYXNlX2tleRgCIAEoCzIULnBvbGljeS5TaW1wbGVLYXNLZXkiLQoSTWFwcGVkUG9saWN5T2JqZWN0EgoKAmlkGAEgASgJEgsKA2ZxbhgCIAEoCSLyAQoKS2V5TWFwcGluZxILCgNraWQYASABKAkSDwoHa2FzX3VyaRgCIAEoCRJCChJuYW1lc3BhY2VfbWFwcGluZ3MYAyADKAsyJi5wb2xpY3kua2FzcmVnaXN0cnkuTWFwcGVkUG9saWN5T2JqZWN0EkIKEmF0dHJpYnV0ZV9tYXBwaW5ncxgEIAMoCzImLnBvbGljeS5rYXNyZWdpc3RyeS5NYXBwZWRQb2xpY3lPYmplY3QSPgoOdmFsdWVfbWFwcGluZ3MYBSADKAsyJi5wb2xpY3kua2FzcmVnaXN0cnkuTWFwcGVkUG9saWN5T2JqZWN0IqMBChZMaXN0S2V5TWFwcGluZ3NSZXF1ZXN0EhYKAmlkGAIgASgJQgi6SAVyA7ABAUgAEjMKA2tleRgDIAEoCzIkLnBvbGljeS5rYXNyZWdpc3RyeS5LYXNLZXlJZGVudGlmaWVySAASJwoKcGFnaW5hdGlvbhgKIAEoCzITLnBvbGljeS5QYWdlUmVxdWVzdEITCgppZGVudGlmaWVyEgW6SAIIACJ5ChdMaXN0S2V5TWFwcGluZ3NSZXNwb25zZRI0CgxrZXlfbWFwcGluZ3MYASADKAsyHi5wb2xpY3kua2FzcmVnaXN0cnkuS2V5TWFwcGluZxIoCgpwYWdpbmF0aW9uGAogASgLMhQucG9saWN5LlBhZ2VSZXNwb25zZTK1DAoeS2V5QWNjZXNzU2VydmVyUmVnaXN0cnlTZXJ2aWNlEpkBChRMaXN0S2V5QWNjZXNzU2VydmVycxIvLnBvbGljeS5rYXNyZWdpc3RyeS5MaXN0S2V5QWNjZXNzU2VydmVyc1JlcXVlc3QaMC5wb2xpY3kua2FzcmVnaXN0cnkuTGlzdEtleUFjY2Vzc1NlcnZlcnNSZXNwb25zZSIekAIBgtPkkwIVEhMva2V5LWFjY2Vzcy1zZXJ2ZXJzEngKEkdldEtleUFjY2Vzc1NlcnZlchItLnBvbGljeS5rYXNyZWdpc3RyeS5HZXRLZXlBY2Nlc3NTZXJ2ZXJSZXF1ZXN0Gi4ucG9saWN5Lmthc3JlZ2lzdHJ5LkdldEtleUFjY2Vzc1NlcnZlclJlc3BvbnNlIgOQAgESfgoVQ3JlYXRlS2V5QWNjZXNzU2VydmVyEjAucG9saWN5Lmthc3JlZ2lzdHJ5LkNyZWF0ZUtleUFjY2Vzc1NlcnZlclJlcXVlc3QaMS5wb2xpY3kua2FzcmVnaXN0cnkuQ3JlYXRlS2V5QWNjZXNzU2VydmVyUmVzcG9uc2UiABJ+ChVVcGRhdGVLZXlBY2Nlc3NTZXJ2ZXISMC5wb2xpY3kua2FzcmVnaXN0cnkuVXBkYXRlS2V5QWNjZXNzU2VydmVyUmVxdWVzdBoxLnBvbGljeS5rYXNyZWdpc3RyeS5VcGRhdGVLZXlBY2Nlc3NTZXJ2ZXJSZXNwb25zZSIAEn4KFURlbGV0ZUtleUFjY2Vzc1NlcnZlchIwLnBvbGljeS5rYXNyZWdpc3RyeS5EZWxldGVLZXlBY2Nlc3NTZXJ2ZXJSZXF1ZXN0GjEucG9saWN5Lmthc3JlZ2lzdHJ5LkRlbGV0ZUtleUFjY2Vzc1NlcnZlclJlc3BvbnNlIgASkAEKGUxpc3RLZXlBY2Nlc3NTZXJ2ZXJHcmFudHMSNC5wb2xpY3kua2FzcmVnaXN0cnkuTGlzdEtleUFjY2Vzc1NlcnZlckdyYW50c1JlcXVlc3QaNS5wb2xpY3kua2FzcmVnaXN0cnkuTGlzdEtleUFjY2Vzc1NlcnZlckdyYW50c1Jlc3BvbnNlIgaIAgGQAgESWgoJQ3JlYXRlS2V5EiQucG9saWN5Lmthc3JlZ2lzdHJ5LkNyZWF0ZUtleVJlcXVlc3QaJS5wb2xpY3kua2FzcmVnaXN0cnkuQ3JlYXRlS2V5UmVzcG9uc2UiABJRCgZHZXRLZXkSIS5wb2xpY3kua2FzcmVnaXN0cnkuR2V0S2V5UmVxdWVzdBoiLnBvbGljeS5rYXNyZWdpc3RyeS5HZXRLZXlSZXNwb25zZSIAElcKCExpc3RLZXlzEiMucG9saWN5Lmthc3JlZ2lzdHJ5Lkxpc3RLZXlzUmVxdWVzdBokLnBvbGljeS5rYXNyZWdpc3RyeS5MaXN0S2V5c1Jlc3BvbnNlIgASWgoJVXBkYXRlS2V5EiQucG9saWN5Lmthc3JlZ2lzdHJ5LlVwZGF0ZUtleVJlcXVlc3QaJS5wb2xpY3kua2FzcmVnaXN0cnkuVXBkYXRlS2V5UmVzcG9uc2UiABJaCglSb3RhdGVLZXkSJC5wb2xpY3kua2FzcmVnaXN0cnkuUm90YXRlS2V5UmVxdWVzdBolLnBvbGljeS5rYXNyZWdpc3RyeS5Sb3RhdGVLZXlSZXNwb25zZSIAEl0KClNldEJhc2VLZXkSJS5wb2xpY3kua2FzcmVnaXN0cnkuU2V0QmFzZUtleVJlcXVlc3QaJi5wb2xpY3kua2FzcmVnaXN0cnkuU2V0QmFzZUtleVJlc3BvbnNlIgASXQoKR2V0QmFzZUtleRIlLnBvbGljeS5rYXNyZWdpc3RyeS5HZXRCYXNlS2V5UmVxdWVzdBomLnBvbGljeS5rYXNyZWdpc3RyeS5HZXRCYXNlS2V5UmVzcG9uc2UiABJsCg9MaXN0S2V5TWFwcGluZ3MSKi5wb2xpY3kua2FzcmVnaXN0cnkuTGlzdEtleU1hcHBpbmdzUmVxdWVzdBorLnBvbGljeS5rYXNyZWdpc3RyeS5MaXN0S2V5TWFwcGluZ3NSZXNwb25zZSIAYgZwcm90bzM", [file_buf_validate_validate, file_common_common, file_google_api_annotations, file_policy_objects, file_policy_selectors]); /** * @generated from message policy.kasregistry.GetKeyAccessServerRequest @@ -810,6 +810,7 @@ export const ActivatePublicKeyResponseSchema: GenMessage & { /** @@ -853,6 +854,7 @@ export type ListKeyAccessServerGrantsRequest = Message<"policy.kasregistry.ListK /** * Describes the message policy.kasregistry.ListKeyAccessServerGrantsRequest. * Use `create(ListKeyAccessServerGrantsRequestSchema)` to create a new message. + * @deprecated */ export const ListKeyAccessServerGrantsRequestSchema: GenMessage = /*@__PURE__*/ messageDesc(file_policy_kasregistry_key_access_server_registry, 26); @@ -861,6 +863,7 @@ export const ListKeyAccessServerGrantsRequestSchema: GenMessage & { /** @@ -878,6 +881,7 @@ export type ListKeyAccessServerGrantsResponse = Message<"policy.kasregistry.List /** * Describes the message policy.kasregistry.ListKeyAccessServerGrantsResponse. * Use `create(ListKeyAccessServerGrantsResponseSchema)` to create a new message. + * @deprecated */ export const ListKeyAccessServerGrantsResponseSchema: GenMessage = /*@__PURE__*/ messageDesc(file_policy_kasregistry_key_access_server_registry, 27); @@ -951,6 +955,15 @@ export type CreateKeyRequest = Message<"policy.kasregistry.CreateKeyRequest"> & */ providerConfigId: string; + /** + * Optional + * + * Whether the key is a legacy key + * + * @generated from field: bool legacy = 8; + */ + legacy: boolean; + /** * Common metadata * @@ -1085,6 +1098,15 @@ export type ListKeysRequest = Message<"policy.kasregistry.ListKeysRequest"> & { case: "kasUri"; } | { case: undefined; value?: undefined }; + /** + * Optional + * + * Filter for legacy keys + * + * @generated from field: optional bool legacy = 8; + */ + legacy?: boolean; + /** * Optional * @@ -1530,6 +1552,139 @@ export type SetBaseKeyResponse = Message<"policy.kasregistry.SetBaseKeyResponse" export const SetBaseKeyResponseSchema: GenMessage = /*@__PURE__*/ messageDesc(file_policy_kasregistry_key_access_server_registry, 44); +/** + * @generated from message policy.kasregistry.MappedPolicyObject + */ +export type MappedPolicyObject = Message<"policy.kasregistry.MappedPolicyObject"> & { + /** + * The unique identifier of the policy object + * + * @generated from field: string id = 1; + */ + id: string; + + /** + * The fully qualified name of the policy object + * + * @generated from field: string fqn = 2; + */ + fqn: string; +}; + +/** + * Describes the message policy.kasregistry.MappedPolicyObject. + * Use `create(MappedPolicyObjectSchema)` to create a new message. + */ +export const MappedPolicyObjectSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_kasregistry_key_access_server_registry, 45); + +/** + * @generated from message policy.kasregistry.KeyMapping + */ +export type KeyMapping = Message<"policy.kasregistry.KeyMapping"> & { + /** + * @generated from field: string kid = 1; + */ + kid: string; + + /** + * @generated from field: string kas_uri = 2; + */ + kasUri: string; + + /** + * List of namespaces mapped to the key + * + * @generated from field: repeated policy.kasregistry.MappedPolicyObject namespace_mappings = 3; + */ + namespaceMappings: MappedPolicyObject[]; + + /** + * List of attribute definitions mapped to the key + * + * @generated from field: repeated policy.kasregistry.MappedPolicyObject attribute_mappings = 4; + */ + attributeMappings: MappedPolicyObject[]; + + /** + * List of attribute values mapped to the key + * + * @generated from field: repeated policy.kasregistry.MappedPolicyObject value_mappings = 5; + */ + valueMappings: MappedPolicyObject[]; +}; + +/** + * Describes the message policy.kasregistry.KeyMapping. + * Use `create(KeyMappingSchema)` to create a new message. + */ +export const KeyMappingSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_kasregistry_key_access_server_registry, 46); + +/** + * @generated from message policy.kasregistry.ListKeyMappingsRequest + */ +export type ListKeyMappingsRequest = Message<"policy.kasregistry.ListKeyMappingsRequest"> & { + /** + * @generated from oneof policy.kasregistry.ListKeyMappingsRequest.identifier + */ + identifier: { + /** + * The unique identifier of the key to retrieve + * + * @generated from field: string id = 2; + */ + value: string; + case: "id"; + } | { + /** + * @generated from field: policy.kasregistry.KasKeyIdentifier key = 3; + */ + value: KasKeyIdentifier; + case: "key"; + } | { case: undefined; value?: undefined }; + + /** + * Pagination request for the list of keys + * + * @generated from field: policy.PageRequest pagination = 10; + */ + pagination?: PageRequest; +}; + +/** + * Describes the message policy.kasregistry.ListKeyMappingsRequest. + * Use `create(ListKeyMappingsRequestSchema)` to create a new message. + */ +export const ListKeyMappingsRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_kasregistry_key_access_server_registry, 47); + +/** + * @generated from message policy.kasregistry.ListKeyMappingsResponse + */ +export type ListKeyMappingsResponse = Message<"policy.kasregistry.ListKeyMappingsResponse"> & { + /** + * The list of key mappings + * + * @generated from field: repeated policy.kasregistry.KeyMapping key_mappings = 1; + */ + keyMappings: KeyMapping[]; + + /** + * Pagination response for the list of keys + * + * @generated from field: policy.PageResponse pagination = 10; + */ + pagination?: PageResponse; +}; + +/** + * Describes the message policy.kasregistry.ListKeyMappingsResponse. + * Use `create(ListKeyMappingsResponseSchema)` to create a new message. + */ +export const ListKeyMappingsResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_kasregistry_key_access_server_registry, 48); + /** * @generated from service policy.kasregistry.KeyAccessServerRegistryService */ @@ -1578,6 +1733,7 @@ export const KeyAccessServerRegistryService: GenService<{ * Deprecated * * @generated from rpc policy.kasregistry.KeyAccessServerRegistryService.ListKeyAccessServerGrants + * @deprecated */ listKeyAccessServerGrants: { methodKind: "unary"; @@ -1655,6 +1811,16 @@ export const KeyAccessServerRegistryService: GenService<{ input: typeof GetBaseKeyRequestSchema; output: typeof GetBaseKeyResponseSchema; }, + /** + * Request to list key mappings in the Key Access Service. + * + * @generated from rpc policy.kasregistry.KeyAccessServerRegistryService.ListKeyMappings + */ + listKeyMappings: { + methodKind: "unary"; + input: typeof ListKeyMappingsRequestSchema; + output: typeof ListKeyMappingsResponseSchema; + }, }> = /*@__PURE__*/ serviceDesc(file_policy_kasregistry_key_access_server_registry, 0); diff --git a/lib/src/platform/policy/keymanagement/key_management_pb.ts b/lib/src/platform/policy/keymanagement/key_management_pb.ts index 2edeb916e..6840f1971 100644 --- a/lib/src/platform/policy/keymanagement/key_management_pb.ts +++ b/lib/src/platform/policy/keymanagement/key_management_pb.ts @@ -17,7 +17,7 @@ import type { Message } from "@bufbuild/protobuf"; * Describes the file policy/keymanagement/key_management.proto. */ export const file_policy_keymanagement_key_management: GenFile = /*@__PURE__*/ - fileDesc("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", [file_buf_validate_validate, file_common_common, file_policy_objects, file_policy_selectors]); + fileDesc("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", [file_buf_validate_validate, file_common_common, file_policy_objects, file_policy_selectors]); /** * @@ -28,7 +28,7 @@ export const file_policy_keymanagement_key_management: GenFile = /*@__PURE__*/ export type CreateProviderConfigRequest = Message<"policy.keymanagement.CreateProviderConfigRequest"> & { /** * Required - * The name of the key provider. (e.g. "AWS KMS", "Google Cloud KMS", "Azure Key Vault") + * The name of the key provider. (e.g. "AWS KMS Instance 1", "Google Cloud KMS Instance 2") * * @generated from field: string name = 1; */ @@ -42,6 +42,14 @@ export type CreateProviderConfigRequest = Message<"policy.keymanagement.CreatePr */ configJson: Uint8Array; + /** + * Required + * The type of key manager (e.g. "aws", "gcp", "azure", "opentdf.io/basic") + * + * @generated from field: string manager = 3; + */ + manager: string; + /** * Common metadata * @@ -96,6 +104,13 @@ export type GetProviderConfigRequest = Message<"policy.keymanagement.GetProvider value: string; case: "name"; } | { case: undefined; value?: undefined }; + + /** + * Optional - filter by manager type when searching by name + * + * @generated from field: string manager = 4; + */ + manager: string; }; /** @@ -188,6 +203,13 @@ export type UpdateProviderConfigRequest = Message<"policy.keymanagement.UpdatePr */ configJson: Uint8Array; + /** + * Optional + * + * @generated from field: string manager = 4; + */ + manager: string; + /** * Optional * Common metadata diff --git a/lib/src/platform/policy/namespaces/namespaces_pb.ts b/lib/src/platform/policy/namespaces/namespaces_pb.ts index f18d31bec..c660ad32f 100644 --- a/lib/src/platform/policy/namespaces/namespaces_pb.ts +++ b/lib/src/platform/policy/namespaces/namespaces_pb.ts @@ -17,10 +17,13 @@ import type { Message } from "@bufbuild/protobuf"; * Describes the file policy/namespaces/namespaces.proto. */ export const file_policy_namespaces_namespaces: GenFile = /*@__PURE__*/ - fileDesc("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", [file_buf_validate_validate, file_common_common, file_policy_objects, file_policy_selectors]); + fileDesc("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", [file_buf_validate_validate, file_common_common, file_policy_objects, file_policy_selectors]); /** + * Deprecated + * * @generated from message policy.namespaces.NamespaceKeyAccessServer + * @deprecated */ export type NamespaceKeyAccessServer = Message<"policy.namespaces.NamespaceKeyAccessServer"> & { /** @@ -41,6 +44,7 @@ export type NamespaceKeyAccessServer = Message<"policy.namespaces.NamespaceKeyAc /** * Describes the message policy.namespaces.NamespaceKeyAccessServer. * Use `create(NamespaceKeyAccessServerSchema)` to create a new message. + * @deprecated */ export const NamespaceKeyAccessServerSchema: GenMessage = /*@__PURE__*/ messageDesc(file_policy_namespaces_namespaces, 0); @@ -488,6 +492,7 @@ export const NamespaceService: GenService<{ * --------------------------------------- * * @generated from rpc policy.namespaces.NamespaceService.AssignKeyAccessServerToNamespace + * @deprecated */ assignKeyAccessServerToNamespace: { methodKind: "unary"; @@ -496,6 +501,7 @@ export const NamespaceService: GenService<{ }, /** * @generated from rpc policy.namespaces.NamespaceService.RemoveKeyAccessServerFromNamespace + * @deprecated */ removeKeyAccessServerFromNamespace: { methodKind: "unary"; diff --git a/lib/src/platform/policy/objects_pb.ts b/lib/src/platform/policy/objects_pb.ts index 2c6f55d46..ec8a9f22f 100644 --- a/lib/src/platform/policy/objects_pb.ts +++ b/lib/src/platform/policy/objects_pb.ts @@ -14,7 +14,7 @@ import type { Message } from "@bufbuild/protobuf"; * Describes the file policy/objects.proto. */ export const file_policy_objects: GenFile = /*@__PURE__*/ - fileDesc("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", [file_buf_validate_validate, file_common_common, file_google_protobuf_wrappers]); + fileDesc("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", [file_buf_validate_validate, file_common_common, file_google_protobuf_wrappers]); /** * @generated from message policy.SimpleKasPublicKey @@ -95,6 +95,11 @@ export type KeyProviderConfig = Message<"policy.KeyProviderConfig"> & { */ configJson: Uint8Array; + /** + * @generated from field: string manager = 4; + */ + manager: string; + /** * Common metadata * @@ -147,7 +152,7 @@ export type Namespace = Message<"policy.Namespace"> & { metadata?: Metadata; /** - * KAS grants for the namespace + * Deprecated KAS grants for the namespace. Use kas_keys instead. * * @generated from field: repeated policy.KeyAccessServer grants = 6; */ @@ -204,7 +209,7 @@ export type Attribute = Message<"policy.Attribute"> & { values: Value[]; /** - * Deprecated + * Deprecated KAS grants for the attribute. Use kas_keys instead. * * @generated from field: repeated policy.KeyAccessServer grants = 6; */ @@ -266,8 +271,7 @@ export type Value = Message<"policy.Value"> & { value: string; /** - * Deprecated - * list of key access servers + * Deprecated KAS grants for the value. Use kas_keys instead. * * @generated from field: repeated policy.KeyAccessServer grants = 5; */ @@ -302,6 +306,11 @@ export type Value = Message<"policy.Value"> & { */ resourceMappings: ResourceMapping[]; + /** + * @generated from field: repeated policy.Obligation obligations = 11; + */ + obligations: Obligation[]; + /** * Common metadata * @@ -999,6 +1008,168 @@ export type RegisteredResourceValue_ActionAttributeValue = Message<"policy.Regis export const RegisteredResourceValue_ActionAttributeValueSchema: GenMessage = /*@__PURE__*/ messageDesc(file_policy_objects, 21, 0); +/** + * @generated from message policy.PolicyEnforcementPoint + */ +export type PolicyEnforcementPoint = Message<"policy.PolicyEnforcementPoint"> & { + /** + * @generated from field: string client_id = 1; + */ + clientId: string; +}; + +/** + * Describes the message policy.PolicyEnforcementPoint. + * Use `create(PolicyEnforcementPointSchema)` to create a new message. + */ +export const PolicyEnforcementPointSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_objects, 22); + +/** + * Holds the context needed for obligation fulfillment + * + * @generated from message policy.RequestContext + */ +export type RequestContext = Message<"policy.RequestContext"> & { + /** + * @generated from field: policy.PolicyEnforcementPoint pep = 1; + */ + pep?: PolicyEnforcementPoint; +}; + +/** + * Describes the message policy.RequestContext. + * Use `create(RequestContextSchema)` to create a new message. + */ +export const RequestContextSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_objects, 23); + +/** + * @generated from message policy.Obligation + */ +export type Obligation = Message<"policy.Obligation"> & { + /** + * @generated from field: string id = 1; + */ + id: string; + + /** + * @generated from field: policy.Namespace namespace = 2; + */ + namespace?: Namespace; + + /** + * @generated from field: string name = 3; + */ + name: string; + + /** + * @generated from field: repeated policy.ObligationValue values = 4; + */ + values: ObligationValue[]; + + /** + * @generated from field: string fqn = 5; + */ + fqn: string; + + /** + * @generated from field: common.Metadata metadata = 100; + */ + metadata?: Metadata; +}; + +/** + * Describes the message policy.Obligation. + * Use `create(ObligationSchema)` to create a new message. + */ +export const ObligationSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_objects, 24); + +/** + * @generated from message policy.ObligationValue + */ +export type ObligationValue = Message<"policy.ObligationValue"> & { + /** + * @generated from field: string id = 1; + */ + id: string; + + /** + * @generated from field: policy.Obligation obligation = 2; + */ + obligation?: Obligation; + + /** + * @generated from field: string value = 3; + */ + value: string; + + /** + * @generated from field: repeated policy.ObligationTrigger triggers = 4; + */ + triggers: ObligationTrigger[]; + + /** + * @generated from field: string fqn = 5; + */ + fqn: string; + + /** + * @generated from field: common.Metadata metadata = 100; + */ + metadata?: Metadata; +}; + +/** + * Describes the message policy.ObligationValue. + * Use `create(ObligationValueSchema)` to create a new message. + */ +export const ObligationValueSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_objects, 25); + +/** + * @generated from message policy.ObligationTrigger + */ +export type ObligationTrigger = Message<"policy.ObligationTrigger"> & { + /** + * @generated from field: string id = 1; + */ + id: string; + + /** + * @generated from field: policy.ObligationValue obligation_value = 2; + */ + obligationValue?: ObligationValue; + + /** + * @generated from field: policy.Action action = 3; + */ + action?: Action; + + /** + * @generated from field: policy.Value attribute_value = 4; + */ + attributeValue?: Value; + + /** + * @generated from field: repeated policy.RequestContext context = 5; + */ + context: RequestContext[]; + + /** + * @generated from field: common.Metadata metadata = 100; + */ + metadata?: Metadata; +}; + +/** + * Describes the message policy.ObligationTrigger. + * Use `create(ObligationTriggerSchema)` to create a new message. + */ +export const ObligationTriggerSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_objects, 26); + /** * @generated from message policy.KasKey */ @@ -1024,7 +1195,7 @@ export type KasKey = Message<"policy.KasKey"> & { * Use `create(KasKeySchema)` to create a new message. */ export const KasKeySchema: GenMessage = /*@__PURE__*/ - messageDesc(file_policy_objects, 22); + messageDesc(file_policy_objects, 27); /** * @generated from message policy.PublicKeyCtx @@ -1045,7 +1216,7 @@ export type PublicKeyCtx = Message<"policy.PublicKeyCtx"> & { * Use `create(PublicKeyCtxSchema)` to create a new message. */ export const PublicKeyCtxSchema: GenMessage = /*@__PURE__*/ - messageDesc(file_policy_objects, 23); + messageDesc(file_policy_objects, 28); /** * @generated from message policy.PrivateKeyCtx @@ -1075,7 +1246,7 @@ export type PrivateKeyCtx = Message<"policy.PrivateKeyCtx"> & { * Use `create(PrivateKeyCtxSchema)` to create a new message. */ export const PrivateKeyCtxSchema: GenMessage = /*@__PURE__*/ - messageDesc(file_policy_objects, 24); + messageDesc(file_policy_objects, 29); /** * @generated from message policy.AsymmetricKey @@ -1145,6 +1316,15 @@ export type AsymmetricKey = Message<"policy.AsymmetricKey"> & { */ providerConfig?: KeyProviderConfig; + /** + * Optional + * + * Indicates a key may be found in TDFs without key identifiers + * + * @generated from field: bool legacy = 9; + */ + legacy: boolean; + /** * Common metadata fields * @@ -1158,7 +1338,7 @@ export type AsymmetricKey = Message<"policy.AsymmetricKey"> & { * Use `create(AsymmetricKeySchema)` to create a new message. */ export const AsymmetricKeySchema: GenMessage = /*@__PURE__*/ - messageDesc(file_policy_objects, 25); + messageDesc(file_policy_objects, 30); /** * @generated from message policy.SymmetricKey @@ -1213,7 +1393,7 @@ export type SymmetricKey = Message<"policy.SymmetricKey"> & { * Use `create(SymmetricKeySchema)` to create a new message. */ export const SymmetricKeySchema: GenMessage = /*@__PURE__*/ - messageDesc(file_policy_objects, 26); + messageDesc(file_policy_objects, 31); /** * @generated from enum policy.AttributeRuleTypeEnum diff --git a/lib/src/platform/policy/obligations/obligations_pb.ts b/lib/src/platform/policy/obligations/obligations_pb.ts new file mode 100644 index 000000000..e9e76837e --- /dev/null +++ b/lib/src/platform/policy/obligations/obligations_pb.ts @@ -0,0 +1,788 @@ +// @generated by protoc-gen-es v2.2.5 with parameter "target=ts,import_extension=.js" +// @generated from file policy/obligations/obligations.proto (package policy.obligations, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage, GenService } from "@bufbuild/protobuf/codegenv1"; +import { fileDesc, messageDesc, serviceDesc } from "@bufbuild/protobuf/codegenv1"; +import type { IdFqnIdentifier, IdNameIdentifier, MetadataMutable, MetadataUpdateEnum } from "../../common/common_pb.js"; +import { file_common_common } from "../../common/common_pb.js"; +import type { Obligation, ObligationTrigger, ObligationValue, RequestContext } from "../objects_pb.js"; +import { file_policy_objects } from "../objects_pb.js"; +import type { PageRequest, PageResponse } from "../selectors_pb.js"; +import { file_policy_selectors } from "../selectors_pb.js"; +import { file_buf_validate_validate } from "../../buf/validate/validate_pb.js"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file policy/obligations/obligations.proto. + */ +export const file_policy_obligations_obligations: GenFile = /*@__PURE__*/ + fileDesc("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", [file_common_common, file_policy_objects, file_policy_selectors, file_buf_validate_validate]); + +/** + * Definitions + * + * @generated from message policy.obligations.GetObligationRequest + */ +export type GetObligationRequest = Message<"policy.obligations.GetObligationRequest"> & { + /** + * @generated from field: string id = 1; + */ + id: string; + + /** + * @generated from field: string fqn = 2; + */ + fqn: string; +}; + +/** + * Describes the message policy.obligations.GetObligationRequest. + * Use `create(GetObligationRequestSchema)` to create a new message. + */ +export const GetObligationRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_obligations_obligations, 0); + +/** + * @generated from message policy.obligations.ValueTriggerRequest + */ +export type ValueTriggerRequest = Message<"policy.obligations.ValueTriggerRequest"> & { + /** + * Required. The ID of the action that will trigger this obligation value policy decisioning. + * + * @generated from field: common.IdNameIdentifier action = 1; + */ + action?: IdNameIdentifier; + + /** + * Required. The attribute value ID that will trigger this obligation value policy decisioning. + * + * @generated from field: common.IdFqnIdentifier attribute_value = 2; + */ + attributeValue?: IdFqnIdentifier; + + /** + * Optional. The request context for this obligation value policy decisioning. + * + * @generated from field: policy.RequestContext context = 3; + */ + context?: RequestContext; +}; + +/** + * Describes the message policy.obligations.ValueTriggerRequest. + * Use `create(ValueTriggerRequestSchema)` to create a new message. + */ +export const ValueTriggerRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_obligations_obligations, 1); + +/** + * @generated from message policy.obligations.GetObligationResponse + */ +export type GetObligationResponse = Message<"policy.obligations.GetObligationResponse"> & { + /** + * @generated from field: policy.Obligation obligation = 1; + */ + obligation?: Obligation; +}; + +/** + * Describes the message policy.obligations.GetObligationResponse. + * Use `create(GetObligationResponseSchema)` to create a new message. + */ +export const GetObligationResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_obligations_obligations, 2); + +/** + * @generated from message policy.obligations.GetObligationsByFQNsRequest + */ +export type GetObligationsByFQNsRequest = Message<"policy.obligations.GetObligationsByFQNsRequest"> & { + /** + * @generated from field: repeated string fqns = 1; + */ + fqns: string[]; +}; + +/** + * Describes the message policy.obligations.GetObligationsByFQNsRequest. + * Use `create(GetObligationsByFQNsRequestSchema)` to create a new message. + */ +export const GetObligationsByFQNsRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_obligations_obligations, 3); + +/** + * @generated from message policy.obligations.GetObligationsByFQNsResponse + */ +export type GetObligationsByFQNsResponse = Message<"policy.obligations.GetObligationsByFQNsResponse"> & { + /** + * @generated from field: map fqn_obligation_map = 1; + */ + fqnObligationMap: { [key: string]: Obligation }; +}; + +/** + * Describes the message policy.obligations.GetObligationsByFQNsResponse. + * Use `create(GetObligationsByFQNsResponseSchema)` to create a new message. + */ +export const GetObligationsByFQNsResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_obligations_obligations, 4); + +/** + * @generated from message policy.obligations.CreateObligationRequest + */ +export type CreateObligationRequest = Message<"policy.obligations.CreateObligationRequest"> & { + /** + * @generated from field: string namespace_id = 1; + */ + namespaceId: string; + + /** + * @generated from field: string namespace_fqn = 2; + */ + namespaceFqn: string; + + /** + * @generated from field: string name = 3; + */ + name: string; + + /** + * Optional + * + * @generated from field: repeated string values = 4; + */ + values: string[]; + + /** + * Optional + * Common metadata + * + * @generated from field: common.MetadataMutable metadata = 100; + */ + metadata?: MetadataMutable; +}; + +/** + * Describes the message policy.obligations.CreateObligationRequest. + * Use `create(CreateObligationRequestSchema)` to create a new message. + */ +export const CreateObligationRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_obligations_obligations, 5); + +/** + * @generated from message policy.obligations.CreateObligationResponse + */ +export type CreateObligationResponse = Message<"policy.obligations.CreateObligationResponse"> & { + /** + * @generated from field: policy.Obligation obligation = 1; + */ + obligation?: Obligation; +}; + +/** + * Describes the message policy.obligations.CreateObligationResponse. + * Use `create(CreateObligationResponseSchema)` to create a new message. + */ +export const CreateObligationResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_obligations_obligations, 6); + +/** + * @generated from message policy.obligations.UpdateObligationRequest + */ +export type UpdateObligationRequest = Message<"policy.obligations.UpdateObligationRequest"> & { + /** + * Required + * + * @generated from field: string id = 1; + */ + id: string; + + /** + * Optional + * + * @generated from field: string name = 2; + */ + name: string; + + /** + * @generated from field: common.MetadataMutable metadata = 100; + */ + metadata?: MetadataMutable; + + /** + * @generated from field: common.MetadataUpdateEnum metadata_update_behavior = 101; + */ + metadataUpdateBehavior: MetadataUpdateEnum; +}; + +/** + * Describes the message policy.obligations.UpdateObligationRequest. + * Use `create(UpdateObligationRequestSchema)` to create a new message. + */ +export const UpdateObligationRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_obligations_obligations, 7); + +/** + * @generated from message policy.obligations.UpdateObligationResponse + */ +export type UpdateObligationResponse = Message<"policy.obligations.UpdateObligationResponse"> & { + /** + * @generated from field: policy.Obligation obligation = 1; + */ + obligation?: Obligation; +}; + +/** + * Describes the message policy.obligations.UpdateObligationResponse. + * Use `create(UpdateObligationResponseSchema)` to create a new message. + */ +export const UpdateObligationResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_obligations_obligations, 8); + +/** + * @generated from message policy.obligations.DeleteObligationRequest + */ +export type DeleteObligationRequest = Message<"policy.obligations.DeleteObligationRequest"> & { + /** + * @generated from field: string id = 1; + */ + id: string; + + /** + * @generated from field: string fqn = 2; + */ + fqn: string; +}; + +/** + * Describes the message policy.obligations.DeleteObligationRequest. + * Use `create(DeleteObligationRequestSchema)` to create a new message. + */ +export const DeleteObligationRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_obligations_obligations, 9); + +/** + * @generated from message policy.obligations.DeleteObligationResponse + */ +export type DeleteObligationResponse = Message<"policy.obligations.DeleteObligationResponse"> & { + /** + * @generated from field: policy.Obligation obligation = 1; + */ + obligation?: Obligation; +}; + +/** + * Describes the message policy.obligations.DeleteObligationResponse. + * Use `create(DeleteObligationResponseSchema)` to create a new message. + */ +export const DeleteObligationResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_obligations_obligations, 10); + +/** + * @generated from message policy.obligations.ListObligationsRequest + */ +export type ListObligationsRequest = Message<"policy.obligations.ListObligationsRequest"> & { + /** + * @generated from field: string namespace_id = 1; + */ + namespaceId: string; + + /** + * @generated from field: string namespace_fqn = 2; + */ + namespaceFqn: string; + + /** + * Optional + * + * @generated from field: policy.PageRequest pagination = 10; + */ + pagination?: PageRequest; +}; + +/** + * Describes the message policy.obligations.ListObligationsRequest. + * Use `create(ListObligationsRequestSchema)` to create a new message. + */ +export const ListObligationsRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_obligations_obligations, 11); + +/** + * @generated from message policy.obligations.ListObligationsResponse + */ +export type ListObligationsResponse = Message<"policy.obligations.ListObligationsResponse"> & { + /** + * @generated from field: repeated policy.Obligation obligations = 1; + */ + obligations: Obligation[]; + + /** + * @generated from field: policy.PageResponse pagination = 10; + */ + pagination?: PageResponse; +}; + +/** + * Describes the message policy.obligations.ListObligationsResponse. + * Use `create(ListObligationsResponseSchema)` to create a new message. + */ +export const ListObligationsResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_obligations_obligations, 12); + +/** + * Values + * + * @generated from message policy.obligations.GetObligationValueRequest + */ +export type GetObligationValueRequest = Message<"policy.obligations.GetObligationValueRequest"> & { + /** + * @generated from field: string id = 1; + */ + id: string; + + /** + * @generated from field: string fqn = 2; + */ + fqn: string; +}; + +/** + * Describes the message policy.obligations.GetObligationValueRequest. + * Use `create(GetObligationValueRequestSchema)` to create a new message. + */ +export const GetObligationValueRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_obligations_obligations, 13); + +/** + * @generated from message policy.obligations.GetObligationValueResponse + */ +export type GetObligationValueResponse = Message<"policy.obligations.GetObligationValueResponse"> & { + /** + * @generated from field: policy.ObligationValue value = 1; + */ + value?: ObligationValue; +}; + +/** + * Describes the message policy.obligations.GetObligationValueResponse. + * Use `create(GetObligationValueResponseSchema)` to create a new message. + */ +export const GetObligationValueResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_obligations_obligations, 14); + +/** + * @generated from message policy.obligations.GetObligationValuesByFQNsRequest + */ +export type GetObligationValuesByFQNsRequest = Message<"policy.obligations.GetObligationValuesByFQNsRequest"> & { + /** + * @generated from field: repeated string fqns = 1; + */ + fqns: string[]; +}; + +/** + * Describes the message policy.obligations.GetObligationValuesByFQNsRequest. + * Use `create(GetObligationValuesByFQNsRequestSchema)` to create a new message. + */ +export const GetObligationValuesByFQNsRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_obligations_obligations, 15); + +/** + * @generated from message policy.obligations.GetObligationValuesByFQNsResponse + */ +export type GetObligationValuesByFQNsResponse = Message<"policy.obligations.GetObligationValuesByFQNsResponse"> & { + /** + * @generated from field: map fqn_value_map = 1; + */ + fqnValueMap: { [key: string]: ObligationValue }; +}; + +/** + * Describes the message policy.obligations.GetObligationValuesByFQNsResponse. + * Use `create(GetObligationValuesByFQNsResponseSchema)` to create a new message. + */ +export const GetObligationValuesByFQNsResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_obligations_obligations, 16); + +/** + * @generated from message policy.obligations.CreateObligationValueRequest + */ +export type CreateObligationValueRequest = Message<"policy.obligations.CreateObligationValueRequest"> & { + /** + * @generated from field: string obligation_id = 1; + */ + obligationId: string; + + /** + * @generated from field: string obligation_fqn = 2; + */ + obligationFqn: string; + + /** + * @generated from field: string value = 3; + */ + value: string; + + /** + * Optional + * Combination of action and attribute_value that will trigger this obligation value policy decisioning. + * + * @generated from field: repeated policy.obligations.ValueTriggerRequest triggers = 4; + */ + triggers: ValueTriggerRequest[]; + + /** + * Optional + * Common metadata + * + * @generated from field: common.MetadataMutable metadata = 100; + */ + metadata?: MetadataMutable; +}; + +/** + * Describes the message policy.obligations.CreateObligationValueRequest. + * Use `create(CreateObligationValueRequestSchema)` to create a new message. + */ +export const CreateObligationValueRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_obligations_obligations, 17); + +/** + * @generated from message policy.obligations.CreateObligationValueResponse + */ +export type CreateObligationValueResponse = Message<"policy.obligations.CreateObligationValueResponse"> & { + /** + * @generated from field: policy.ObligationValue value = 1; + */ + value?: ObligationValue; +}; + +/** + * Describes the message policy.obligations.CreateObligationValueResponse. + * Use `create(CreateObligationValueResponseSchema)` to create a new message. + */ +export const CreateObligationValueResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_obligations_obligations, 18); + +/** + * @generated from message policy.obligations.UpdateObligationValueRequest + */ +export type UpdateObligationValueRequest = Message<"policy.obligations.UpdateObligationValueRequest"> & { + /** + * Required + * + * @generated from field: string id = 1; + */ + id: string; + + /** + * Optional + * + * @generated from field: string value = 2; + */ + value: string; + + /** + * Optional + * Obligation Triggers provided here will replace all existing records in the database. + * + * @generated from field: repeated policy.obligations.ValueTriggerRequest triggers = 3; + */ + triggers: ValueTriggerRequest[]; + + /** + * Optional + * Common metadata + * + * @generated from field: common.MetadataMutable metadata = 100; + */ + metadata?: MetadataMutable; + + /** + * @generated from field: common.MetadataUpdateEnum metadata_update_behavior = 101; + */ + metadataUpdateBehavior: MetadataUpdateEnum; +}; + +/** + * Describes the message policy.obligations.UpdateObligationValueRequest. + * Use `create(UpdateObligationValueRequestSchema)` to create a new message. + */ +export const UpdateObligationValueRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_obligations_obligations, 19); + +/** + * @generated from message policy.obligations.UpdateObligationValueResponse + */ +export type UpdateObligationValueResponse = Message<"policy.obligations.UpdateObligationValueResponse"> & { + /** + * @generated from field: policy.ObligationValue value = 1; + */ + value?: ObligationValue; +}; + +/** + * Describes the message policy.obligations.UpdateObligationValueResponse. + * Use `create(UpdateObligationValueResponseSchema)` to create a new message. + */ +export const UpdateObligationValueResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_obligations_obligations, 20); + +/** + * @generated from message policy.obligations.DeleteObligationValueRequest + */ +export type DeleteObligationValueRequest = Message<"policy.obligations.DeleteObligationValueRequest"> & { + /** + * @generated from field: string id = 1; + */ + id: string; + + /** + * @generated from field: string fqn = 2; + */ + fqn: string; +}; + +/** + * Describes the message policy.obligations.DeleteObligationValueRequest. + * Use `create(DeleteObligationValueRequestSchema)` to create a new message. + */ +export const DeleteObligationValueRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_obligations_obligations, 21); + +/** + * @generated from message policy.obligations.DeleteObligationValueResponse + */ +export type DeleteObligationValueResponse = Message<"policy.obligations.DeleteObligationValueResponse"> & { + /** + * @generated from field: policy.ObligationValue value = 1; + */ + value?: ObligationValue; +}; + +/** + * Describes the message policy.obligations.DeleteObligationValueResponse. + * Use `create(DeleteObligationValueResponseSchema)` to create a new message. + */ +export const DeleteObligationValueResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_obligations_obligations, 22); + +/** + * Triggers + * + * @generated from message policy.obligations.AddObligationTriggerRequest + */ +export type AddObligationTriggerRequest = Message<"policy.obligations.AddObligationTriggerRequest"> & { + /** + * Required + * + * @generated from field: common.IdFqnIdentifier obligation_value = 1; + */ + obligationValue?: IdFqnIdentifier; + + /** + * Required + * + * @generated from field: common.IdNameIdentifier action = 2; + */ + action?: IdNameIdentifier; + + /** + * Required + * + * @generated from field: common.IdFqnIdentifier attribute_value = 3; + */ + attributeValue?: IdFqnIdentifier; + + /** + * Optional + * The request context for this obligation value policy decisioning. + * + * @generated from field: policy.RequestContext context = 4; + */ + context?: RequestContext; + + /** + * Optional + * Common metadata + * + * @generated from field: common.MetadataMutable metadata = 100; + */ + metadata?: MetadataMutable; +}; + +/** + * Describes the message policy.obligations.AddObligationTriggerRequest. + * Use `create(AddObligationTriggerRequestSchema)` to create a new message. + */ +export const AddObligationTriggerRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_obligations_obligations, 23); + +/** + * @generated from message policy.obligations.AddObligationTriggerResponse + */ +export type AddObligationTriggerResponse = Message<"policy.obligations.AddObligationTriggerResponse"> & { + /** + * @generated from field: policy.ObligationTrigger trigger = 1; + */ + trigger?: ObligationTrigger; +}; + +/** + * Describes the message policy.obligations.AddObligationTriggerResponse. + * Use `create(AddObligationTriggerResponseSchema)` to create a new message. + */ +export const AddObligationTriggerResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_obligations_obligations, 24); + +/** + * @generated from message policy.obligations.RemoveObligationTriggerRequest + */ +export type RemoveObligationTriggerRequest = Message<"policy.obligations.RemoveObligationTriggerRequest"> & { + /** + * Required + * + * @generated from field: string id = 1; + */ + id: string; +}; + +/** + * Describes the message policy.obligations.RemoveObligationTriggerRequest. + * Use `create(RemoveObligationTriggerRequestSchema)` to create a new message. + */ +export const RemoveObligationTriggerRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_obligations_obligations, 25); + +/** + * @generated from message policy.obligations.RemoveObligationTriggerResponse + */ +export type RemoveObligationTriggerResponse = Message<"policy.obligations.RemoveObligationTriggerResponse"> & { + /** + * @generated from field: policy.ObligationTrigger trigger = 1; + */ + trigger?: ObligationTrigger; +}; + +/** + * Describes the message policy.obligations.RemoveObligationTriggerResponse. + * Use `create(RemoveObligationTriggerResponseSchema)` to create a new message. + */ +export const RemoveObligationTriggerResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_policy_obligations_obligations, 26); + +/** + * / + * / Obligation Service + * / + * + * @generated from service policy.obligations.Service + */ +export const Service: GenService<{ + /** + * @generated from rpc policy.obligations.Service.ListObligations + */ + listObligations: { + methodKind: "unary"; + input: typeof ListObligationsRequestSchema; + output: typeof ListObligationsResponseSchema; + }, + /** + * @generated from rpc policy.obligations.Service.GetObligation + */ + getObligation: { + methodKind: "unary"; + input: typeof GetObligationRequestSchema; + output: typeof GetObligationResponseSchema; + }, + /** + * @generated from rpc policy.obligations.Service.GetObligationsByFQNs + */ + getObligationsByFQNs: { + methodKind: "unary"; + input: typeof GetObligationsByFQNsRequestSchema; + output: typeof GetObligationsByFQNsResponseSchema; + }, + /** + * @generated from rpc policy.obligations.Service.CreateObligation + */ + createObligation: { + methodKind: "unary"; + input: typeof CreateObligationRequestSchema; + output: typeof CreateObligationResponseSchema; + }, + /** + * @generated from rpc policy.obligations.Service.UpdateObligation + */ + updateObligation: { + methodKind: "unary"; + input: typeof UpdateObligationRequestSchema; + output: typeof UpdateObligationResponseSchema; + }, + /** + * @generated from rpc policy.obligations.Service.DeleteObligation + */ + deleteObligation: { + methodKind: "unary"; + input: typeof DeleteObligationRequestSchema; + output: typeof DeleteObligationResponseSchema; + }, + /** + * @generated from rpc policy.obligations.Service.GetObligationValue + */ + getObligationValue: { + methodKind: "unary"; + input: typeof GetObligationValueRequestSchema; + output: typeof GetObligationValueResponseSchema; + }, + /** + * @generated from rpc policy.obligations.Service.GetObligationValuesByFQNs + */ + getObligationValuesByFQNs: { + methodKind: "unary"; + input: typeof GetObligationValuesByFQNsRequestSchema; + output: typeof GetObligationValuesByFQNsResponseSchema; + }, + /** + * @generated from rpc policy.obligations.Service.CreateObligationValue + */ + createObligationValue: { + methodKind: "unary"; + input: typeof CreateObligationValueRequestSchema; + output: typeof CreateObligationValueResponseSchema; + }, + /** + * @generated from rpc policy.obligations.Service.UpdateObligationValue + */ + updateObligationValue: { + methodKind: "unary"; + input: typeof UpdateObligationValueRequestSchema; + output: typeof UpdateObligationValueResponseSchema; + }, + /** + * @generated from rpc policy.obligations.Service.DeleteObligationValue + */ + deleteObligationValue: { + methodKind: "unary"; + input: typeof DeleteObligationValueRequestSchema; + output: typeof DeleteObligationValueResponseSchema; + }, + /** + * @generated from rpc policy.obligations.Service.AddObligationTrigger + */ + addObligationTrigger: { + methodKind: "unary"; + input: typeof AddObligationTriggerRequestSchema; + output: typeof AddObligationTriggerResponseSchema; + }, + /** + * @generated from rpc policy.obligations.Service.RemoveObligationTrigger + */ + removeObligationTrigger: { + methodKind: "unary"; + input: typeof RemoveObligationTriggerRequestSchema; + output: typeof RemoveObligationTriggerResponseSchema; + }, +}> = /*@__PURE__*/ + serviceDesc(file_policy_obligations_obligations, 0); + diff --git a/lib/src/platform/policy/selectors_pb.ts b/lib/src/platform/policy/selectors_pb.ts index 44409e754..764b4cc50 100644 --- a/lib/src/platform/policy/selectors_pb.ts +++ b/lib/src/platform/policy/selectors_pb.ts @@ -34,6 +34,8 @@ export const AttributeNamespaceSelectorSchema: GenMessage & { /** + * Deprecated + * * @generated from field: bool with_key_access_grants = 1; */ withKeyAccessGrants: boolean; @@ -56,6 +58,8 @@ export const AttributeNamespaceSelector_AttributeSelectorSchema: GenMessage & { /** + * Deprecated + * * @generated from field: bool with_key_access_grants = 1; */ withKeyAccessGrants: boolean; @@ -83,6 +87,8 @@ export const AttributeNamespaceSelector_AttributeSelector_ValueSelectorSchema: G */ export type AttributeDefinitionSelector = Message<"policy.AttributeDefinitionSelector"> & { /** + * Deprecated + * * @generated from field: bool with_key_access_grants = 1; */ withKeyAccessGrants: boolean; @@ -123,6 +129,8 @@ export const AttributeDefinitionSelector_NamespaceSelectorSchema: GenMessage & { /** + * Deprecated + * * @generated from field: bool with_key_access_grants = 1; */ withKeyAccessGrants: boolean; @@ -150,6 +158,8 @@ export const AttributeDefinitionSelector_ValueSelectorSchema: GenMessage & { /** + * Deprecated + * * @generated from field: bool with_key_access_grants = 1; */ withKeyAccessGrants: boolean; @@ -182,6 +192,8 @@ export const AttributeValueSelectorSchema: GenMessage = */ export type AttributeValueSelector_AttributeSelector = Message<"policy.AttributeValueSelector.AttributeSelector"> & { /** + * Deprecated + * * @generated from field: bool with_key_access_grants = 1; */ withKeyAccessGrants: boolean; diff --git a/lib/src/platform/policy/unsafe/unsafe_pb.ts b/lib/src/platform/policy/unsafe/unsafe_pb.ts index fd8469955..760a04336 100644 --- a/lib/src/platform/policy/unsafe/unsafe_pb.ts +++ b/lib/src/platform/policy/unsafe/unsafe_pb.ts @@ -5,7 +5,7 @@ import type { GenFile, GenMessage, GenService } from "@bufbuild/protobuf/codegenv1"; import { fileDesc, messageDesc, serviceDesc } from "@bufbuild/protobuf/codegenv1"; import { file_buf_validate_validate } from "../../buf/validate/validate_pb.js"; -import type { Attribute, AttributeRuleTypeEnum, Key, Namespace, Value } from "../objects_pb.js"; +import type { Attribute, AttributeRuleTypeEnum, KasKey, Namespace, Value } from "../objects_pb.js"; import { file_policy_objects } from "../objects_pb.js"; import type { Message } from "@bufbuild/protobuf"; @@ -13,7 +13,7 @@ import type { Message } from "@bufbuild/protobuf"; * Describes the file policy/unsafe/unsafe.proto. */ export const file_policy_unsafe_unsafe: GenFile = /*@__PURE__*/ - fileDesc("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", [file_buf_validate_validate, file_policy_objects]); + fileDesc("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", [file_buf_validate_validate, file_policy_objects]); /** * WARNING!! @@ -445,6 +445,7 @@ export const UnsafeDeleteAttributeValueResponseSchema: GenMessage & { /** - * @generated from field: policy.Key key = 1; + * @generated from field: policy.KasKey key = 1; */ - key?: Key; + key?: KasKey; }; /**