/// Message representing a period of time between two timestamps.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TimestampRange {
/// Begin of the period (inclusive).
#[prost(message, optional, tag = "1")]
pub start_time: ::core::option::Option<::prost_types::Timestamp>,
/// End of the period (exclusive).
#[prost(message, optional, tag = "2")]
pub end_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// A resource that represents a location with full geographic information.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Location {
/// The type of a location, which corresponds to the address lines field of
/// \[google.type.PostalAddress][google.type.PostalAddress\]. For example, "Downtown, Atlanta, GA, USA"
/// has a type of \[LocationType.NEIGHBORHOOD][google.cloud.talent.v4beta1.Location.LocationType.NEIGHBORHOOD\], and "Kansas City, KS, USA"
/// has a type of \[LocationType.LOCALITY][google.cloud.talent.v4beta1.Location.LocationType.LOCALITY\].
#[prost(enumeration = "location::LocationType", tag = "1")]
pub location_type: i32,
/// Postal address of the location that includes human readable information,
/// such as postal delivery and payments addresses. Given a postal address,
/// a postal service can deliver items to a premises, P.O. Box, or other
/// delivery location.
#[prost(message, optional, tag = "2")]
pub postal_address: ::core::option::Option<super::super::super::r#type::PostalAddress>,
/// An object representing a latitude/longitude pair.
#[prost(message, optional, tag = "3")]
pub lat_lng: ::core::option::Option<super::super::super::r#type::LatLng>,
/// Radius in miles of the job location. This value is derived from the
/// location bounding box in which a circle with the specified radius
/// centered from \[google.type.LatLng][google.type.LatLng\] covers the area associated with the
/// job location.
/// For example, currently, "Mountain View, CA, USA" has a radius of
/// 6.17 miles.
#[prost(double, tag = "4")]
pub radius_miles: f64,
}
/// Nested message and enum types in `Location`.
pub mod location {
/// An enum which represents the type of a location.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum LocationType {
/// Default value if the type isn't specified.
Unspecified = 0,
/// A country level location.
Country = 1,
/// A state or equivalent level location.
AdministrativeArea = 2,
/// A county or equivalent level location.
SubAdministrativeArea = 3,
/// A city or equivalent level location.
Locality = 4,
/// A postal code level location.
PostalCode = 5,
/// A sublocality is a subdivision of a locality, for example a city borough,
/// ward, or arrondissement. Sublocalities are usually recognized by a local
/// political authority. For example, Manhattan and Brooklyn are recognized
/// as boroughs by the City of New York, and are therefore modeled as
/// sublocalities.
SubLocality = 6,
/// A district or equivalent level location.
SubLocality1 = 7,
/// A smaller district or equivalent level display.
SubLocality2 = 8,
/// A neighborhood level location.
Neighborhood = 9,
/// A street address level location.
StreetAddress = 10,
}
}
/// Meta information related to the job searcher or entity
/// conducting the job search. This information is used to improve the
/// performance of the service.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RequestMetadata {
/// Required if \[allow_missing_ids][google.cloud.talent.v4beta1.RequestMetadata.allow_missing_ids\] is unset or `false`.
///
/// The client-defined scope or source of the service call, which typically
/// is the domain on
/// which the service has been implemented and is currently being run.
///
/// For example, if the service is being run by client <em>Foo, Inc.</em>, on
/// job board www.foo.com and career site www.bar.com, then this field is
/// set to "foo.com" for use on the job board, and "bar.com" for use on the
/// career site.
///
/// Note that any improvements to the model for a particular tenant site rely
/// on this field being set correctly to a unique domain.
///
/// The maximum number of allowed characters is 255.
#[prost(string, tag = "1")]
pub domain: ::prost::alloc::string::String,
/// Required if \[allow_missing_ids][google.cloud.talent.v4beta1.RequestMetadata.allow_missing_ids\] is unset or `false`.
///
/// A unique session identification string. A session is defined as the
/// duration of an end user's interaction with the service over a certain
/// period.
/// Obfuscate this field for privacy concerns before
/// providing it to the service.
///
/// Note that any improvements to the model for a particular tenant site rely
/// on this field being set correctly to a unique session ID.
///
/// The maximum number of allowed characters is 255.
#[prost(string, tag = "2")]
pub session_id: ::prost::alloc::string::String,
/// Required if \[allow_missing_ids][google.cloud.talent.v4beta1.RequestMetadata.allow_missing_ids\] is unset or `false`.
///
/// A unique user identification string, as determined by the client.
/// To have the strongest positive impact on search quality
/// make sure the client-level is unique.
/// Obfuscate this field for privacy concerns before
/// providing it to the service.
///
/// Note that any improvements to the model for a particular tenant site rely
/// on this field being set correctly to a unique user ID.
///
/// The maximum number of allowed characters is 255.
#[prost(string, tag = "3")]
pub user_id: ::prost::alloc::string::String,
/// Only set when any of \[domain][google.cloud.talent.v4beta1.RequestMetadata.domain\], \[session_id][google.cloud.talent.v4beta1.RequestMetadata.session_id\] and \[user_id][google.cloud.talent.v4beta1.RequestMetadata.user_id\] isn't
/// available for some reason. It is highly recommended not to set this field
/// and provide accurate \[domain][google.cloud.talent.v4beta1.RequestMetadata.domain\], \[session_id][google.cloud.talent.v4beta1.RequestMetadata.session_id\] and \[user_id][google.cloud.talent.v4beta1.RequestMetadata.user_id\] for the
/// best service experience.
#[prost(bool, tag = "4")]
pub allow_missing_ids: bool,
/// The type of device used by the job seeker at the time of the call to the
/// service.
#[prost(message, optional, tag = "5")]
pub device_info: ::core::option::Option<DeviceInfo>,
}
/// Additional information returned to client, such as debugging information.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResponseMetadata {
/// A unique id associated with this call.
/// This id is logged for tracking purposes.
#[prost(string, tag = "1")]
pub request_id: ::prost::alloc::string::String,
}
/// Device information collected from the job seeker, candidate, or
/// other entity conducting the job search. Providing this information improves
/// the quality of the search results across devices.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeviceInfo {
/// Type of the device.
#[prost(enumeration = "device_info::DeviceType", tag = "1")]
pub device_type: i32,
/// A device-specific ID. The ID must be a unique identifier that
/// distinguishes the device from other devices.
#[prost(string, tag = "2")]
pub id: ::prost::alloc::string::String,
}
/// Nested message and enum types in `DeviceInfo`.
pub mod device_info {
/// An enumeration describing an API access portal and exposure mechanism.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum DeviceType {
/// The device type isn't specified.
Unspecified = 0,
/// A desktop web browser, such as, Chrome, Firefox, Safari, or Internet
/// Explorer)
Web = 1,
/// A mobile device web browser, such as a phone or tablet with a Chrome
/// browser.
MobileWeb = 2,
/// An Android device native application.
Android = 3,
/// An iOS device native application.
Ios = 4,
/// A bot, as opposed to a device operated by human beings, such as a web
/// crawler.
Bot = 5,
/// Other devices types.
Other = 6,
}
}
/// Custom attribute values that are either filterable or non-filterable.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CustomAttribute {
/// Exactly one of \[string_values][google.cloud.talent.v4beta1.CustomAttribute.string_values\] or \[long_values][google.cloud.talent.v4beta1.CustomAttribute.long_values\] must be specified.
///
/// This field is used to perform a string match (`CASE_SENSITIVE_MATCH` or
/// `CASE_INSENSITIVE_MATCH`) search.
/// For filterable `string_value`s, a maximum total number of 200 values
/// is allowed, with each `string_value` has a byte size of no more than
/// 500B. For unfilterable `string_values`, the maximum total byte size of
/// unfilterable `string_values` is 50KB.
///
/// Empty string isn't allowed.
#[prost(string, repeated, tag = "1")]
pub string_values: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
/// Exactly one of \[string_values][google.cloud.talent.v4beta1.CustomAttribute.string_values\] or \[long_values][google.cloud.talent.v4beta1.CustomAttribute.long_values\] must be specified.
///
/// This field is used to perform number range search.
/// (`EQ`, `GT`, `GE`, `LE`, `LT`) over filterable `long_value`.
///
/// Currently at most 1 \[long_values][google.cloud.talent.v4beta1.CustomAttribute.long_values\] is supported.
#[prost(int64, repeated, tag = "2")]
pub long_values: ::prost::alloc::vec::Vec<i64>,
/// If the `filterable` flag is true, custom field values are searchable.
/// If false, values are not searchable.
///
/// Default is false.
#[prost(bool, tag = "3")]
pub filterable: bool,
}
/// Spell check result.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SpellingCorrection {
/// Indicates if the query was corrected by the spell checker.
#[prost(bool, tag = "1")]
pub corrected: bool,
/// Correction output consisting of the corrected keyword string.
#[prost(string, tag = "2")]
pub corrected_text: ::prost::alloc::string::String,
/// Corrected output with html tags to highlight the corrected words.
/// Corrected words are called out with the "<b><i>...</i></b>" html tags.
///
/// For example, the user input query is "software enginear", where the second
/// word, "enginear," is incorrect. It should be "engineer". When spelling
/// correction is enabled, this value is
/// "software <b><i>engineer</i></b>".
#[prost(string, tag = "3")]
pub corrected_html: ::prost::alloc::string::String,
}
/// Job compensation details.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CompensationInfo {
/// Job compensation information.
///
/// At most one entry can be of type
/// \[CompensationInfo.CompensationType.BASE][google.cloud.talent.v4beta1.CompensationInfo.CompensationType.BASE\], which is
/// referred as **base compensation entry** for the job.
#[prost(message, repeated, tag = "1")]
pub entries: ::prost::alloc::vec::Vec<compensation_info::CompensationEntry>,
/// Output only. Annualized base compensation range. Computed as base compensation entry's
/// \[CompensationEntry.amount][google.cloud.talent.v4beta1.CompensationInfo.CompensationEntry.amount\] times
/// \[CompensationEntry.expected_units_per_year][google.cloud.talent.v4beta1.CompensationInfo.CompensationEntry.expected_units_per_year\].
///
/// See \[CompensationEntry][google.cloud.talent.v4beta1.CompensationInfo.CompensationEntry\] for explanation on compensation annualization.
#[prost(message, optional, tag = "2")]
pub annualized_base_compensation_range:
::core::option::Option<compensation_info::CompensationRange>,
/// Output only. Annualized total compensation range. Computed as all compensation entries'
/// \[CompensationEntry.amount][google.cloud.talent.v4beta1.CompensationInfo.CompensationEntry.amount\] times
/// \[CompensationEntry.expected_units_per_year][google.cloud.talent.v4beta1.CompensationInfo.CompensationEntry.expected_units_per_year\].
///
/// See \[CompensationEntry][google.cloud.talent.v4beta1.CompensationInfo.CompensationEntry\] for explanation on compensation annualization.
#[prost(message, optional, tag = "3")]
pub annualized_total_compensation_range:
::core::option::Option<compensation_info::CompensationRange>,
}
/// Nested message and enum types in `CompensationInfo`.
pub mod compensation_info {
/// A compensation entry that represents one component of compensation, such
/// as base pay, bonus, or other compensation type.
///
/// Annualization: One compensation entry can be annualized if
/// - it contains valid \[amount][google.cloud.talent.v4beta1.CompensationInfo.CompensationEntry.amount\] or \[range][google.cloud.talent.v4beta1.CompensationInfo.CompensationEntry.range\].
/// - and its \[expected_units_per_year][google.cloud.talent.v4beta1.CompensationInfo.CompensationEntry.expected_units_per_year\] is set or can be derived.
/// Its annualized range is determined as (\[amount][google.cloud.talent.v4beta1.CompensationInfo.CompensationEntry.amount\] or \[range][google.cloud.talent.v4beta1.CompensationInfo.CompensationEntry.range\]) times
/// \[expected_units_per_year][google.cloud.talent.v4beta1.CompensationInfo.CompensationEntry.expected_units_per_year\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CompensationEntry {
/// Compensation type.
///
/// Default is \[CompensationType.COMPENSATION_TYPE_UNSPECIFIED][google.cloud.talent.v4beta1.CompensationInfo.CompensationType.COMPENSATION_TYPE_UNSPECIFIED\].
#[prost(enumeration = "CompensationType", tag = "1")]
pub r#type: i32,
/// Frequency of the specified amount.
///
/// Default is \[CompensationUnit.COMPENSATION_UNIT_UNSPECIFIED][google.cloud.talent.v4beta1.CompensationInfo.CompensationUnit.COMPENSATION_UNIT_UNSPECIFIED\].
#[prost(enumeration = "CompensationUnit", tag = "2")]
pub unit: i32,
/// Compensation description. For example, could
/// indicate equity terms or provide additional context to an estimated
/// bonus.
#[prost(string, tag = "5")]
pub description: ::prost::alloc::string::String,
/// Expected number of units paid each year. If not specified, when
/// \[Job.employment_types][google.cloud.talent.v4beta1.Job.employment_types\] is FULLTIME, a default value is inferred
/// based on \[unit][google.cloud.talent.v4beta1.CompensationInfo.CompensationEntry.unit\]. Default values:
/// - HOURLY: 2080
/// - DAILY: 260
/// - WEEKLY: 52
/// - MONTHLY: 12
/// - ANNUAL: 1
#[prost(message, optional, tag = "6")]
pub expected_units_per_year: ::core::option::Option<f64>,
/// Compensation amount. It could be a fixed amount or a floating range.
#[prost(oneof = "compensation_entry::CompensationAmount", tags = "3, 4")]
pub compensation_amount: ::core::option::Option<compensation_entry::CompensationAmount>,
}
/// Nested message and enum types in `CompensationEntry`.
pub mod compensation_entry {
/// Compensation amount. It could be a fixed amount or a floating range.
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum CompensationAmount {
/// Compensation amount.
#[prost(message, tag = "3")]
Amount(super::super::super::super::super::r#type::Money),
/// Compensation range.
#[prost(message, tag = "4")]
Range(super::CompensationRange),
}
}
/// Compensation range.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CompensationRange {
/// The maximum amount of compensation. If left empty, the value is set
/// to a maximal compensation value and the currency code is set to
/// match the [currency code]\[google.type.Money.currency_code\] of
/// min_compensation.
#[prost(message, optional, tag = "2")]
pub max_compensation: ::core::option::Option<super::super::super::super::r#type::Money>,
/// The minimum amount of compensation. If left empty, the value is set
/// to zero and the currency code is set to match the
/// [currency code]\[google.type.Money.currency_code\] of max_compensation.
#[prost(message, optional, tag = "1")]
pub min_compensation: ::core::option::Option<super::super::super::super::r#type::Money>,
}
/// The type of compensation.
///
/// For compensation amounts specified in non-monetary amounts,
/// describe the compensation scheme in the \[CompensationEntry.description][google.cloud.talent.v4beta1.CompensationInfo.CompensationEntry.description\].
///
/// For example, tipping format is described in
/// \[CompensationEntry.description][google.cloud.talent.v4beta1.CompensationInfo.CompensationEntry.description\] (for example, "expect 15-20% tips based
/// on customer bill.") and an estimate of the tips provided in
/// \[CompensationEntry.amount][google.cloud.talent.v4beta1.CompensationInfo.CompensationEntry.amount\] or \[CompensationEntry.range][google.cloud.talent.v4beta1.CompensationInfo.CompensationEntry.range\] ($10 per hour).
///
/// For example, equity is described in \[CompensationEntry.description][google.cloud.talent.v4beta1.CompensationInfo.CompensationEntry.description\]
/// (for example, "1% - 2% equity vesting over 4 years, 1 year cliff") and
/// value estimated in \[CompensationEntry.amount][google.cloud.talent.v4beta1.CompensationInfo.CompensationEntry.amount\] or
/// \[CompensationEntry.range][google.cloud.talent.v4beta1.CompensationInfo.CompensationEntry.range\]. If no value estimate is possible, units are
/// \[CompensationUnit.COMPENSATION_UNIT_UNSPECIFIED][google.cloud.talent.v4beta1.CompensationInfo.CompensationUnit.COMPENSATION_UNIT_UNSPECIFIED\] and then further
/// clarified in \[CompensationEntry.description][google.cloud.talent.v4beta1.CompensationInfo.CompensationEntry.description\] field.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum CompensationType {
/// Default value.
Unspecified = 0,
/// Base compensation: Refers to the fixed amount of money paid to an
/// employee by an employer in return for work performed. Base compensation
/// does not include benefits, bonuses or any other potential compensation
/// from an employer.
Base = 1,
/// Bonus.
Bonus = 2,
/// Signing bonus.
SigningBonus = 3,
/// Equity.
Equity = 4,
/// Profit sharing.
ProfitSharing = 5,
/// Commission.
Commissions = 6,
/// Tips.
Tips = 7,
/// Other compensation type.
OtherCompensationType = 8,
}
/// Pay frequency.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum CompensationUnit {
/// Default value.
Unspecified = 0,
/// Hourly.
Hourly = 1,
/// Daily.
Daily = 2,
/// Weekly
Weekly = 3,
/// Monthly.
Monthly = 4,
/// Yearly.
Yearly = 5,
/// One time.
OneTime = 6,
/// Other compensation units.
OtherCompensationUnit = 7,
}
}
/// Resource that represents a license or certification.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Certification {
/// Name of license or certification.
///
/// Number of characters allowed is 100.
#[prost(string, tag = "1")]
pub display_name: ::prost::alloc::string::String,
/// Acquisition date or effective date of license or certification.
#[prost(message, optional, tag = "2")]
pub acquire_date: ::core::option::Option<super::super::super::r#type::Date>,
/// Expiration date of license of certification.
#[prost(message, optional, tag = "3")]
pub expire_date: ::core::option::Option<super::super::super::r#type::Date>,
/// Authority of license, such as government.
///
/// Number of characters allowed is 100.
#[prost(string, tag = "4")]
pub authority: ::prost::alloc::string::String,
/// Description of license or certification.
///
/// Number of characters allowed is 100,000.
#[prost(string, tag = "5")]
pub description: ::prost::alloc::string::String,
}
/// Resource that represents a skill of a candidate.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Skill {
/// Skill display name.
///
/// For example, "Java", "Python".
///
/// Number of characters allowed is 100.
#[prost(string, tag = "1")]
pub display_name: ::prost::alloc::string::String,
/// The last time this skill was used.
#[prost(message, optional, tag = "2")]
pub last_used_date: ::core::option::Option<super::super::super::r#type::Date>,
/// Skill proficiency level which indicates how proficient the candidate is at
/// this skill.
#[prost(enumeration = "SkillProficiencyLevel", tag = "3")]
pub level: i32,
/// A paragraph describes context of this skill.
///
/// Number of characters allowed is 100,000.
#[prost(string, tag = "4")]
pub context: ::prost::alloc::string::String,
/// Output only. Skill name snippet shows how the \[display_name][google.cloud.talent.v4beta1.Skill.display_name\] is related to a search
/// query. It's empty if the \[display_name][google.cloud.talent.v4beta1.Skill.display_name\] isn't related to the search
/// query.
#[prost(string, tag = "5")]
pub skill_name_snippet: ::prost::alloc::string::String,
}
/// Details of an interview.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Interview {
/// The rating on this interview.
#[prost(message, optional, tag = "6")]
pub rating: ::core::option::Option<Rating>,
/// Required. The overall decision resulting from this interview (positive, negative,
/// nuetral).
#[prost(enumeration = "Outcome", tag = "7")]
pub outcome: i32,
}
/// The details of the score received for an assessment or interview.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Rating {
/// Overall score.
#[prost(double, tag = "1")]
pub overall: f64,
/// The minimum value for the score.
#[prost(double, tag = "2")]
pub min: f64,
/// The maximum value for the score.
#[prost(double, tag = "3")]
pub max: f64,
/// The steps within the score (for example, interval = 1 max = 5
/// min = 1 indicates that the score can be 1, 2, 3, 4, or 5)
#[prost(double, tag = "4")]
pub interval: f64,
}
/// Metadata used for long running operations returned by CTS batch APIs.
/// It's used to replace \[google.longrunning.Operation.metadata][google.longrunning.Operation.metadata\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchOperationMetadata {
/// The state of a long running operation.
#[prost(enumeration = "batch_operation_metadata::State", tag = "1")]
pub state: i32,
/// More detailed information about operation state.
#[prost(string, tag = "2")]
pub state_description: ::prost::alloc::string::String,
/// Count of successful item(s) inside an operation.
#[prost(int32, tag = "3")]
pub success_count: i32,
/// Count of failed item(s) inside an operation.
#[prost(int32, tag = "4")]
pub failure_count: i32,
/// Count of total item(s) inside an operation.
#[prost(int32, tag = "5")]
pub total_count: i32,
/// The time when the batch operation is created.
#[prost(message, optional, tag = "6")]
pub create_time: ::core::option::Option<::prost_types::Timestamp>,
/// The time when the batch operation status is updated. The metadata and the
/// \[update_time][google.cloud.talent.v4beta1.BatchOperationMetadata.update_time\] is refreshed every minute otherwise cached data is
/// returned.
#[prost(message, optional, tag = "7")]
pub update_time: ::core::option::Option<::prost_types::Timestamp>,
/// The time when the batch operation is finished and
/// \[google.longrunning.Operation.done][google.longrunning.Operation.done\] is set to `true`.
#[prost(message, optional, tag = "8")]
pub end_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Nested message and enum types in `BatchOperationMetadata`.
pub mod batch_operation_metadata {
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum State {
/// Default value.
Unspecified = 0,
/// The batch operation is being prepared for processing.
Initializing = 1,
/// The batch operation is actively being processed.
Processing = 2,
/// The batch operation is processed, and at least one item has been
/// successfully processed.
Succeeded = 3,
/// The batch operation is done and no item has been successfully processed.
Failed = 4,
/// The batch operation is in the process of cancelling after
/// \[google.longrunning.Operations.CancelOperation][google.longrunning.Operations.CancelOperation\] is called.
Cancelling = 5,
/// The batch operation is done after
/// \[google.longrunning.Operations.CancelOperation][google.longrunning.Operations.CancelOperation\] is called. Any items
/// processed before cancelling are returned in the response.
Cancelled = 6,
}
}
/// An enum that represents the size of the company.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum CompanySize {
/// Default value if the size isn't specified.
Unspecified = 0,
/// The company has less than 50 employees.
Mini = 1,
/// The company has between 50 and 99 employees.
Small = 2,
/// The company has between 100 and 499 employees.
Smedium = 3,
/// The company has between 500 and 999 employees.
Medium = 4,
/// The company has between 1,000 and 4,999 employees.
Big = 5,
/// The company has between 5,000 and 9,999 employees.
Bigger = 6,
/// The company has 10,000 or more employees.
Giant = 7,
}
/// An enum that represents employee benefits included with the job.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum JobBenefit {
/// Default value if the type isn't specified.
Unspecified = 0,
/// The job includes access to programs that support child care, such
/// as daycare.
ChildCare = 1,
/// The job includes dental services covered by a dental
/// insurance plan.
Dental = 2,
/// The job offers specific benefits to domestic partners.
DomesticPartner = 3,
/// The job allows for a flexible work schedule.
FlexibleHours = 4,
/// The job includes health services covered by a medical insurance plan.
Medical = 5,
/// The job includes a life insurance plan provided by the employer or
/// available for purchase by the employee.
LifeInsurance = 6,
/// The job allows for a leave of absence to a parent to care for a newborn
/// child.
ParentalLeave = 7,
/// The job includes a workplace retirement plan provided by the
/// employer or available for purchase by the employee.
RetirementPlan = 8,
/// The job allows for paid time off due to illness.
SickDays = 9,
/// The job includes paid time off for vacation.
Vacation = 10,
/// The job includes vision services covered by a vision
/// insurance plan.
Vision = 11,
}
/// Educational degree level defined in International Standard Classification
/// of Education (ISCED).
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum DegreeType {
/// Default value. Represents no degree, or early childhood education.
/// Maps to ISCED code 0.
/// Ex) Kindergarten
Unspecified = 0,
/// Primary education which is typically the first stage of compulsory
/// education. ISCED code 1.
/// Ex) Elementary school
PrimaryEducation = 1,
/// Lower secondary education; First stage of secondary education building on
/// primary education, typically with a more subject-oriented curriculum.
/// ISCED code 2.
/// Ex) Middle school
LowerSecondaryEducation = 2,
/// Middle education; Second/final stage of secondary education preparing for
/// tertiary education and/or providing skills relevant to employment.
/// Usually with an increased range of subject options and streams. ISCED
/// code 3.
/// Ex) High school
UpperSecondaryEducation = 3,
/// Adult Remedial Education; Programmes providing learning experiences that
/// build on secondary education and prepare for labour market entry and/or
/// tertiary education. The content is broader than secondary but not as
/// complex as tertiary education. ISCED code 4.
AdultRemedialEducation = 4,
/// Associate's or equivalent; Short first tertiary programmes that are
/// typically practically-based, occupationally-specific and prepare for
/// labour market entry. These programmes may also provide a pathway to other
/// tertiary programmes. ISCED code 5.
AssociatesOrEquivalent = 5,
/// Bachelor's or equivalent; Programmes designed to provide intermediate
/// academic and/or professional knowledge, skills and competencies leading
/// to a first tertiary degree or equivalent qualification. ISCED code 6.
BachelorsOrEquivalent = 6,
/// Master's or equivalent; Programmes designed to provide advanced academic
/// and/or professional knowledge, skills and competencies leading to a
/// second tertiary degree or equivalent qualification. ISCED code 7.
MastersOrEquivalent = 7,
/// Doctoral or equivalent; Programmes designed primarily to lead to an
/// advanced research qualification, usually concluding with the submission
/// and defense of a substantive dissertation of publishable quality based on
/// original research. ISCED code 8.
DoctoralOrEquivalent = 8,
}
/// An enum that represents the employment type of a job.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum EmploymentType {
/// The default value if the employment type isn't specified.
Unspecified = 0,
/// The job requires working a number of hours that constitute full
/// time employment, typically 40 or more hours per week.
FullTime = 1,
/// The job entails working fewer hours than a full time job,
/// typically less than 40 hours a week.
PartTime = 2,
/// The job is offered as a contracted, as opposed to a salaried employee,
/// position.
Contractor = 3,
/// The job is offered as a contracted position with the understanding
/// that it's converted into a full-time position at the end of the
/// contract. Jobs of this type are also returned by a search for
/// \[EmploymentType.CONTRACTOR][google.cloud.talent.v4beta1.EmploymentType.CONTRACTOR\] jobs.
ContractToHire = 4,
/// The job is offered as a temporary employment opportunity, usually
/// a short-term engagement.
Temporary = 5,
/// The job is a fixed-term opportunity for students or entry-level job
/// seekers to obtain on-the-job training, typically offered as a summer
/// position.
Intern = 6,
/// The is an opportunity for an individual to volunteer, where there's no
/// expectation of compensation for the provided services.
Volunteer = 7,
/// The job requires an employee to work on an as-needed basis with a
/// flexible schedule.
PerDiem = 8,
/// The job involves employing people in remote areas and flying them
/// temporarily to the work site instead of relocating employees and their
/// families permanently.
FlyInFlyOut = 9,
/// The job does not fit any of the other listed types.
OtherEmploymentType = 10,
}
/// An enum that represents the required experience level required for the job.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum JobLevel {
/// The default value if the level isn't specified.
Unspecified = 0,
/// Entry-level individual contributors, typically with less than 2 years of
/// experience in a similar role. Includes interns.
EntryLevel = 1,
/// Experienced individual contributors, typically with 2+ years of
/// experience in a similar role.
Experienced = 2,
/// Entry- to mid-level managers responsible for managing a team of people.
Manager = 3,
/// Senior-level managers responsible for managing teams of managers.
Director = 4,
/// Executive-level managers and above, including C-level positions.
Executive = 5,
}
/// An enum that represents the categorization or primary focus of specific
/// role. This value is different than the "industry" associated with a role,
/// which is related to the categorization of the company listing the job.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum JobCategory {
/// The default value if the category isn't specified.
Unspecified = 0,
/// An accounting and finance job, such as an Accountant.
AccountingAndFinance = 1,
/// An administrative and office job, such as an Administrative Assistant.
AdministrativeAndOffice = 2,
/// An advertising and marketing job, such as Marketing Manager.
AdvertisingAndMarketing = 3,
/// An animal care job, such as Veterinarian.
AnimalCare = 4,
/// An art, fashion, or design job, such as Designer.
ArtFashionAndDesign = 5,
/// A business operations job, such as Business Operations Manager.
BusinessOperations = 6,
/// A cleaning and facilities job, such as Custodial Staff.
CleaningAndFacilities = 7,
/// A computer and IT job, such as Systems Administrator.
ComputerAndIt = 8,
/// A construction job, such as General Laborer.
Construction = 9,
/// A customer service job, such s Cashier.
CustomerService = 10,
/// An education job, such as School Teacher.
Education = 11,
/// An entertainment and travel job, such as Flight Attendant.
EntertainmentAndTravel = 12,
/// A farming or outdoor job, such as Park Ranger.
FarmingAndOutdoors = 13,
/// A healthcare job, such as Registered Nurse.
Healthcare = 14,
/// A human resources job, such as Human Resources Director.
HumanResources = 15,
/// An installation, maintenance, or repair job, such as Electrician.
InstallationMaintenanceAndRepair = 16,
/// A legal job, such as Law Clerk.
Legal = 17,
/// A management job, often used in conjunction with another category,
/// such as Store Manager.
Management = 18,
/// A manufacturing or warehouse job, such as Assembly Technician.
ManufacturingAndWarehouse = 19,
/// A media, communications, or writing job, such as Media Relations.
MediaCommunicationsAndWriting = 20,
/// An oil, gas or mining job, such as Offshore Driller.
OilGasAndMining = 21,
/// A personal care and services job, such as Hair Stylist.
PersonalCareAndServices = 22,
/// A protective services job, such as Security Guard.
ProtectiveServices = 23,
/// A real estate job, such as Buyer's Agent.
RealEstate = 24,
/// A restaurant and hospitality job, such as Restaurant Server.
RestaurantAndHospitality = 25,
/// A sales and/or retail job, such Sales Associate.
SalesAndRetail = 26,
/// A science and engineering job, such as Lab Technician.
ScienceAndEngineering = 27,
/// A social services or non-profit job, such as Case Worker.
SocialServicesAndNonProfit = 28,
/// A sports, fitness, or recreation job, such as Personal Trainer.
SportsFitnessAndRecreation = 29,
/// A transportation or logistics job, such as Truck Driver.
TransportationAndLogistics = 30,
}
/// An enum that represents the job posting region. In most cases, job postings
/// don't need to specify a region. If a region is given, jobs are
/// eligible for searches in the specified region.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum PostingRegion {
/// If the region is unspecified, the job is only returned if it
/// matches the \[LocationFilter][google.cloud.talent.v4beta1.LocationFilter\].
Unspecified = 0,
/// In addition to exact location matching, job posting is returned when the
/// \[LocationFilter][google.cloud.talent.v4beta1.LocationFilter\] in the search query is in the same administrative area
/// as the returned job posting. For example, if a `ADMINISTRATIVE_AREA` job
/// is posted in "CA, USA", it's returned if \[LocationFilter][google.cloud.talent.v4beta1.LocationFilter\] has
/// "Mountain View".
///
/// Administrative area refers to top-level administrative subdivision of this
/// country. For example, US state, IT region, UK constituent nation and
/// JP prefecture.
AdministrativeArea = 1,
/// In addition to exact location matching, job is returned when
/// \[LocationFilter][google.cloud.talent.v4beta1.LocationFilter\] in search query is in the same country as this job.
/// For example, if a `NATION_WIDE` job is posted in "USA", it's
/// returned if \[LocationFilter][google.cloud.talent.v4beta1.LocationFilter\] has 'Mountain View'.
Nation = 2,
/// Job allows employees to work remotely (telecommute).
/// If locations are provided with this value, the job is
/// considered as having a location, but telecommuting is allowed.
Telecommute = 3,
}
/// Deprecated. All resources are only visible to the owner.
///
/// An enum that represents who has view access to the resource.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum Visibility {
/// Default value.
Unspecified = 0,
/// The resource is only visible to the GCP account who owns it.
AccountOnly = 1,
/// The resource is visible to the owner and may be visible to other
/// applications and processes at Google.
SharedWithGoogle = 2,
/// The resource is visible to the owner and may be visible to all other API
/// clients.
SharedWithPublic = 3,
}
/// Enum that represents the usage of the contact information.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ContactInfoUsage {
/// Default value.
Unspecified = 0,
/// Personal use.
Personal = 1,
/// Work use.
Work = 2,
/// School use.
School = 3,
}
/// Option for HTML content sanitization on user input fields, for example, job
/// description. By setting this option, user can determine whether and how
/// sanitization is performed on these fields.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum HtmlSanitization {
/// Default value.
Unspecified = 0,
/// Disables sanitization on HTML input.
Disabled = 1,
/// Sanitizes HTML input, only accepts bold, italic, ordered list, and
/// unordered list markup tags.
SimpleFormattingOnly = 2,
}
/// Method for commute.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum CommuteMethod {
/// Commute method isn't specified.
Unspecified = 0,
/// Commute time is calculated based on driving time.
Driving = 1,
/// Commute time is calculated based on public transit including bus, metro,
/// subway, and so on.
Transit = 2,
/// Commute time is calculated based on walking time.
Walking = 3,
/// Commute time is calculated based on biking time.
Cycling = 4,
}
/// Enum that represents the skill proficiency level.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SkillProficiencyLevel {
/// Default value.
Unspecified = 0,
/// Lacks any proficiency in this skill.
Unskilled = 6,
/// Have a common knowledge or an understanding of basic techniques and
/// concepts.
FundamentalAwareness = 1,
/// Have the level of experience gained in a classroom and/or experimental
/// scenarios or as a trainee on-the-job.
Novice = 2,
/// Be able to successfully complete tasks in this skill as requested. Help
/// from an expert may be required from time to time, but can usually perform
/// skill independently.
Intermediate = 3,
/// Can perform the actions associated with this skill without assistance.
Advanced = 4,
/// Known as an expert in this area.
Expert = 5,
}
/// The overall outcome /decision / result indicator.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum Outcome {
/// Default value.
Unspecified = 0,
/// A positive outcome / passing indicator (for example, candidate was
/// recommended for hiring or to be moved forward in the hiring process,
/// candidate passed a test).
Positive = 1,
/// A neutral outcome / no clear indicator (for example, no strong
/// reccommendation either to move forward / not move forward, neutral score).
Neutral = 2,
/// A negative outcome / failing indicator (for example, candidate was
/// recommended to NOT move forward in the hiring process, failed a test).
Negative = 3,
/// The assessment outcome is not available or otherwise unknown (for example,
/// candidate did not complete assessment).
NotAvailable = 4,
}
/// The type of candidate availability signal.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum AvailabilitySignalType {
/// Default value.
Unspecified = 0,
/// Job application signal.
///
/// In the context of \[Profile.availability_signals][google.cloud.talent.v4beta1.Profile.availability_signals\], this signal is related
/// to the candidate's most recent application.
/// \[last_update_time][google.cloud.talent.v4beta1.AvailabilitySignal.last_update_time\] is
/// calculated from max(\[Application.create_time][google.cloud.talent.v4beta1.Application.create_time\]) from all \[Application][google.cloud.talent.v4beta1.Application\]
/// records where \[Application.source][google.cloud.talent.v4beta1.Application.source\] is any of the following:
/// \[APPLY_DIRECT_WEB][google.cloud.talent.v4beta1.Application.ApplicationSource.APPLY_DIRECT_WEB\]
/// \[APPLY_DIRECT_MOBILE_WEB][google.cloud.talent.v4beta1.Application.ApplicationSource.APPLY_DIRECT_MOBILE_WEB\]
/// \[APPLY_DIRECT_MOBILE_APP][google.cloud.talent.v4beta1.Application.ApplicationSource.APPLY_DIRECT_MOBILE_APP\]
/// \[APPLY_DIRECT_IN_PERSON][google.cloud.talent.v4beta1.Application.ApplicationSource.APPLY_DIRECT_IN_PERSON\]
/// \[APPLY_INDIRECT][google.cloud.talent.v4beta1.Application.ApplicationSource.APPLY_INDIRECT\]
///
/// In the context of \[AvailabilityFilter][google.cloud.talent.v4beta1.AvailabilityFilter\], the filter is applied on
/// \[Profile.availability_signals][google.cloud.talent.v4beta1.Profile.availability_signals\] where
/// \[type][google.cloud.talent.v4beta1.AvailabilitySignal.type\] is JOB_APPLICATION.
JobApplication = 1,
/// Resume update signal.
///
/// In the context of \[Profile.availability_signals][google.cloud.talent.v4beta1.Profile.availability_signals\], this signal is related
/// to the candidate's most recent update to their resume.
/// For a \[SummarizedProfile.summary][google.cloud.talent.v4beta1.SummarizedProfile.summary\],
/// \[last_update_time][google.cloud.talent.v4beta1.AvailabilitySignal.last_update_time\] is
/// calculated from max(\[Profile.resume_update_time][google.cloud.talent.v4beta1.Profile.resume_update_time\]) from all
/// \[SummarizedProfile.profiles][google.cloud.talent.v4beta1.SummarizedProfile.profiles\].
///
/// In the context of \[AvailabilityFilter][google.cloud.talent.v4beta1.AvailabilityFilter\], the filter is applied on
/// \[Profile.availability_signals][google.cloud.talent.v4beta1.Profile.availability_signals\] where
/// \[type][google.cloud.talent.v4beta1.AvailabilitySignal.type\] is RESUME_UPDATE.
ResumeUpdate = 2,
/// Candidate update signal.
///
/// In the context of \[Profile.availability_signals][google.cloud.talent.v4beta1.Profile.availability_signals\], this signal is related
/// to the candidate's most recent update to their profile.
/// For a \[SummarizedProfile.summary][google.cloud.talent.v4beta1.SummarizedProfile.summary\],
/// \[last_update_time][google.cloud.talent.v4beta1.AvailabilitySignal.last_update_time\] is
/// calculated from max(\[Profile.candidate_update_time][google.cloud.talent.v4beta1.Profile.candidate_update_time\]) from all
/// \[SummarizedProfile.profiles][google.cloud.talent.v4beta1.SummarizedProfile.profiles\].
///
/// In the context of \[AvailabilityFilter][google.cloud.talent.v4beta1.AvailabilityFilter\], the filter is applied on
/// \[Profile.availability_signals][google.cloud.talent.v4beta1.Profile.availability_signals\] where
/// \[type][google.cloud.talent.v4beta1.AvailabilitySignal.type\] is CANDIDATE_UPDATE.
CandidateUpdate = 3,
/// Client submission signal.
///
/// In the context of \[Profile.availability_signals][google.cloud.talent.v4beta1.Profile.availability_signals\], this signal is related
/// to the candidate's most recent submission.
/// \[last_update_time][google.cloud.talent.v4beta1.AvailabilitySignal.last_update_time\] is
/// calculated from max(\[Application.create_time][google.cloud.talent.v4beta1.Application.create_time\]) from all \[Application][google.cloud.talent.v4beta1.Application\]
/// records where \[Application.stage][google.cloud.talent.v4beta1.Application.stage\] is any of the following:
/// \[HIRING_MANAGER_REVIEW][google.cloud.talent.v4beta1.Application.ApplicationStage.HIRING_MANAGER_REVIEW\]
/// \[INTERVIEW][google.cloud.talent.v4beta1.Application.ApplicationStage.INTERVIEW\]
/// \[OFFER_EXTENDED][google.cloud.talent.v4beta1.Application.ApplicationStage.OFFER_EXTENDED\]
/// \[OFFER_ACCEPTED][google.cloud.talent.v4beta1.Application.ApplicationStage.OFFER_ACCEPTED\]
/// \[STARTED][google.cloud.talent.v4beta1.Application.ApplicationStage.STARTED\]
///
/// In the context of \[AvailabilityFilter][google.cloud.talent.v4beta1.AvailabilityFilter\], the filter is applied on
/// \[Profile.availability_signals][google.cloud.talent.v4beta1.Profile.availability_signals\] where
/// \[type][google.cloud.talent.v4beta1.AvailabilitySignal.type\] is CLIENT_SUBMISSION.
ClientSubmission = 4,
}
/// Resource that represents a job application record of a candidate.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Application {
/// Required during application update.
///
/// Resource name assigned to an application by the API.
///
/// The format is
/// "projects/{project_id}/tenants/{tenant_id}/profiles/{profile_id}/applications/{application_id}".
/// For example, "projects/foo/tenants/bar/profiles/baz/applications/qux".
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
/// Required. Client side application identifier, used to uniquely identify the
/// application.
///
/// The maximum number of allowed characters is 255.
#[prost(string, tag = "31")]
pub external_id: ::prost::alloc::string::String,
/// Output only. Resource name of the candidate of this application.
///
/// The format is
/// "projects/{project_id}/tenants/{tenant_id}/profiles/{profile_id}".
/// For example, "projects/foo/tenants/bar/profiles/baz".
#[prost(string, tag = "2")]
pub profile: ::prost::alloc::string::String,
/// Required. Resource name of the job which the candidate applied for.
///
/// The format is
/// "projects/{project_id}/tenants/{tenant_id}/jobs/{job_id}". For example,
/// "projects/foo/tenants/bar/jobs/baz".
#[prost(string, tag = "4")]
pub job: ::prost::alloc::string::String,
/// Resource name of the company which the candidate applied for.
///
/// The format is
/// "projects/{project_id}/tenants/{tenant_id}/companies/{company_id}".
/// For example, "projects/foo/tenants/bar/companies/baz".
#[prost(string, tag = "5")]
pub company: ::prost::alloc::string::String,
/// The application date.
#[prost(message, optional, tag = "7")]
pub application_date: ::core::option::Option<super::super::super::r#type::Date>,
/// Required. What is the most recent stage of the application (that is, new,
/// screen, send cv, hired, finished work)? This field is intentionally not
/// comprehensive of every possible status, but instead, represents statuses
/// that would be used to indicate to the ML models good / bad matches.
#[prost(enumeration = "application::ApplicationStage", tag = "11")]
pub stage: i32,
/// The application state.
#[prost(enumeration = "application::ApplicationState", tag = "13")]
pub state: i32,
/// All interviews (screen, onsite, and so on) conducted as part of this
/// application (includes details such as user conducting the interview,
/// timestamp, feedback, and so on).
#[prost(message, repeated, tag = "16")]
pub interviews: ::prost::alloc::vec::Vec<Interview>,
/// If the candidate is referred by a employee.
#[prost(message, optional, tag = "18")]
pub referral: ::core::option::Option<bool>,
/// Required. Reflects the time that the application was created.
#[prost(message, optional, tag = "19")]
pub create_time: ::core::option::Option<::prost_types::Timestamp>,
/// The last update timestamp.
#[prost(message, optional, tag = "20")]
pub update_time: ::core::option::Option<::prost_types::Timestamp>,
/// Free text reason behind the recruitement outcome (for example, reason for
/// withdraw / reject, reason for an unsuccessful finish, and so on).
///
/// Number of characters allowed is 100.
#[prost(string, tag = "21")]
pub outcome_notes: ::prost::alloc::string::String,
/// Outcome positiveness shows how positive the outcome is.
#[prost(enumeration = "Outcome", tag = "22")]
pub outcome: i32,
/// Output only. Indicates whether this job application is a match to
/// application related filters. This value is only applicable in profile
/// search response.
#[prost(message, optional, tag = "28")]
pub is_match: ::core::option::Option<bool>,
/// Output only. Job title snippet shows how the job title is related to a
/// search query. It's empty if the job title isn't related to the search
/// query.
#[prost(string, tag = "29")]
pub job_title_snippet: ::prost::alloc::string::String,
}
/// Nested message and enum types in `Application`.
pub mod application {
/// Enum that represents the application status.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ApplicationState {
/// Default value.
Unspecified = 0,
/// The current stage is in progress or pending, for example, interviews in
/// progress.
InProgress = 1,
/// The current stage was terminated by a candidate decision.
CandidateWithdrew = 2,
/// The current stage was terminated by an employer or agency decision.
EmployerWithdrew = 3,
/// The current stage is successfully completed, but the next stage (if
/// applicable) has not begun.
Completed = 4,
/// The current stage was closed without an exception, or terminated for
/// reasons unrealated to the candidate.
Closed = 5,
}
/// The stage of the application.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ApplicationStage {
/// Default value.
Unspecified = 0,
/// Candidate has applied or a recruiter put candidate into consideration but
/// candidate is not yet screened / no decision has been made to move or not
/// move the candidate to the next stage.
New = 1,
/// A recruiter decided to screen the candidate for this role.
Screen = 2,
/// Candidate is being / was sent to the customer / hiring manager for
/// detailed review.
HiringManagerReview = 3,
/// Candidate was approved by the client / hiring manager and is being / was
/// interviewed for the role.
Interview = 4,
/// Candidate will be / has been given an offer of employment.
OfferExtended = 5,
/// Candidate has accepted their offer of employment.
OfferAccepted = 6,
/// Candidate has begun (or completed) their employment or assignment with
/// the employer.
Started = 7,
}
}
/// The Request of the CreateApplication method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateApplicationRequest {
/// Required. Resource name of the profile under which the application is created.
///
/// The format is
/// "projects/{project_id}/tenants/{tenant_id}/profiles/{profile_id}".
/// For example, "projects/foo/tenants/bar/profiles/baz".
#[prost(string, tag = "1")]
pub parent: ::prost::alloc::string::String,
/// Required. The application to be created.
#[prost(message, optional, tag = "2")]
pub application: ::core::option::Option<Application>,
}
/// Request for getting a application by name.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetApplicationRequest {
/// Required. The resource name of the application to be retrieved.
///
/// The format is
/// "projects/{project_id}/tenants/{tenant_id}/profiles/{profile_id}/applications/{application_id}".
/// For example, "projects/foo/tenants/bar/profiles/baz/applications/qux".
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
}
/// Request for updating a specified application.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateApplicationRequest {
/// Required. The application resource to replace the current resource in the system.
#[prost(message, optional, tag = "1")]
pub application: ::core::option::Option<Application>,
/// Strongly recommended for the best service experience.
///
/// If \[update_mask][google.cloud.talent.v4beta1.UpdateApplicationRequest.update_mask\] is provided, only the specified fields in
/// \[application][google.cloud.talent.v4beta1.UpdateApplicationRequest.application\] are updated. Otherwise all the fields are updated.
///
/// A field mask to specify the application fields to be updated. Only
/// top level fields of \[Application][google.cloud.talent.v4beta1.Application\] are supported.
#[prost(message, optional, tag = "2")]
pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request to delete a application.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteApplicationRequest {
/// Required. The resource name of the application to be deleted.
///
/// The format is
/// "projects/{project_id}/tenants/{tenant_id}/profiles/{profile_id}/applications/{application_id}".
/// For example, "projects/foo/tenants/bar/profiles/baz/applications/qux".
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
}
/// List applications for which the client has ACL visibility.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListApplicationsRequest {
/// Required. Resource name of the profile under which the application is created.
///
/// The format is
/// "projects/{project_id}/tenants/{tenant_id}/profiles/{profile_id}", for
/// example, "projects/foo/tenants/bar/profiles/baz".
#[prost(string, tag = "1")]
pub parent: ::prost::alloc::string::String,
/// The starting indicator from which to return results.
#[prost(string, tag = "2")]
pub page_token: ::prost::alloc::string::String,
/// The maximum number of applications to be returned, at most 100.
/// Default is 100 if a non-positive number is provided.
#[prost(int32, tag = "3")]
pub page_size: i32,
}
/// The List applications response object.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListApplicationsResponse {
/// Applications for the current client.
#[prost(message, repeated, tag = "1")]
pub applications: ::prost::alloc::vec::Vec<Application>,
/// A token to retrieve the next page of results.
#[prost(string, tag = "2")]
pub next_page_token: ::prost::alloc::string::String,
/// Additional information for the API invocation, such as the request
/// tracking id.
#[prost(message, optional, tag = "3")]
pub metadata: ::core::option::Option<ResponseMetadata>,
}
#[doc = r" Generated client implementations."]
pub mod application_service_client {
#![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
use tonic::codegen::*;
#[doc = " A service that handles application management, including CRUD and"]
#[doc = " enumeration."]
#[derive(Debug, Clone)]
pub struct ApplicationServiceClient<T> {
inner: tonic::client::Grpc<T>,
}
impl<T> ApplicationServiceClient<T>
where
T: tonic::client::GrpcService<tonic::body::BoxBody>,
T::ResponseBody: Body + Send + 'static,
T::Error: Into<StdError>,
<T::ResponseBody as Body>::Error: Into<StdError> + Send,
{
pub fn new(inner: T) -> Self {
let inner = tonic::client::Grpc::new(inner);
Self { inner }
}
pub fn with_interceptor<F>(
inner: T,
interceptor: F,
) -> ApplicationServiceClient<InterceptedService<T, F>>
where
F: tonic::service::Interceptor,
T: tonic::codegen::Service<
http::Request<tonic::body::BoxBody>,
Response = http::Response<
<T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
>,
>,
<T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
Into<StdError> + Send + Sync,
{
ApplicationServiceClient::new(InterceptedService::new(inner, interceptor))
}
#[doc = r" Compress requests with `gzip`."]
#[doc = r""]
#[doc = r" This requires the server to support it otherwise it might respond with an"]
#[doc = r" error."]
pub fn send_gzip(mut self) -> Self {
self.inner = self.inner.send_gzip();
self
}
#[doc = r" Enable decompressing responses with `gzip`."]
pub fn accept_gzip(mut self) -> Self {
self.inner = self.inner.accept_gzip();
self
}
#[doc = " Creates a new application entity."]
pub async fn create_application(
&mut self,
request: impl tonic::IntoRequest<super::CreateApplicationRequest>,
) -> Result<tonic::Response<super::Application>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.talent.v4beta1.ApplicationService/CreateApplication",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Retrieves specified application."]
pub async fn get_application(
&mut self,
request: impl tonic::IntoRequest<super::GetApplicationRequest>,
) -> Result<tonic::Response<super::Application>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.talent.v4beta1.ApplicationService/GetApplication",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Updates specified application."]
pub async fn update_application(
&mut self,
request: impl tonic::IntoRequest<super::UpdateApplicationRequest>,
) -> Result<tonic::Response<super::Application>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.talent.v4beta1.ApplicationService/UpdateApplication",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Deletes specified application."]
pub async fn delete_application(
&mut self,
request: impl tonic::IntoRequest<super::DeleteApplicationRequest>,
) -> Result<tonic::Response<()>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.talent.v4beta1.ApplicationService/DeleteApplication",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Lists all applications associated with the profile."]
pub async fn list_applications(
&mut self,
request: impl tonic::IntoRequest<super::ListApplicationsRequest>,
) -> Result<tonic::Response<super::ListApplicationsResponse>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.talent.v4beta1.ApplicationService/ListApplications",
);
self.inner.unary(request.into_request(), path, codec).await
}
}
}
/// A Company resource represents a company in the service. A company is the
/// entity that owns job postings, that is, the hiring entity responsible for
/// employing applicants for the job position.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Company {
/// Required during company update.
///
/// The resource name for a company. This is generated by the service when a
/// company is created.
///
/// The format is
/// "projects/{project_id}/tenants/{tenant_id}/companies/{company_id}", for
/// example, "projects/foo/tenants/bar/companies/baz".
///
/// If tenant id is unspecified, the default tenant is used. For
/// example, "projects/foo/companies/bar".
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
/// Required. The display name of the company, for example, "Google LLC".
#[prost(string, tag = "2")]
pub display_name: ::prost::alloc::string::String,
/// Required. Client side company identifier, used to uniquely identify the
/// company.
///
/// The maximum number of allowed characters is 255.
#[prost(string, tag = "3")]
pub external_id: ::prost::alloc::string::String,
/// The employer's company size.
#[prost(enumeration = "CompanySize", tag = "4")]
pub size: i32,
/// The street address of the company's main headquarters, which may be
/// different from the job location. The service attempts
/// to geolocate the provided address, and populates a more specific
/// location wherever possible in \[DerivedInfo.headquarters_location][google.cloud.talent.v4beta1.Company.DerivedInfo.headquarters_location\].
#[prost(string, tag = "5")]
pub headquarters_address: ::prost::alloc::string::String,
/// Set to true if it is the hiring agency that post jobs for other
/// employers.
///
/// Defaults to false if not provided.
#[prost(bool, tag = "6")]
pub hiring_agency: bool,
/// Equal Employment Opportunity legal disclaimer text to be
/// associated with all jobs, and typically to be displayed in all
/// roles.
///
/// The maximum number of allowed characters is 500.
#[prost(string, tag = "7")]
pub eeo_text: ::prost::alloc::string::String,
/// The URI representing the company's primary web site or home page,
/// for example, "<https://www.google.com".>
///
/// The maximum number of allowed characters is 255.
#[prost(string, tag = "8")]
pub website_uri: ::prost::alloc::string::String,
/// The URI to employer's career site or careers page on the employer's web
/// site, for example, "<https://careers.google.com".>
#[prost(string, tag = "9")]
pub career_site_uri: ::prost::alloc::string::String,
/// A URI that hosts the employer's company logo.
#[prost(string, tag = "10")]
pub image_uri: ::prost::alloc::string::String,
/// A list of keys of filterable \[Job.custom_attributes][google.cloud.talent.v4beta1.Job.custom_attributes\], whose
/// corresponding `string_values` are used in keyword searches. Jobs with
/// `string_values` under these specified field keys are returned if any
/// of the values match the search keyword. Custom field values with
/// parenthesis, brackets and special symbols are not searchable as-is,
/// and those keyword queries must be surrounded by quotes.
#[prost(string, repeated, tag = "11")]
pub keyword_searchable_job_custom_attributes:
::prost::alloc::vec::Vec<::prost::alloc::string::String>,
/// Output only. Derived details about the company.
#[prost(message, optional, tag = "12")]
pub derived_info: ::core::option::Option<company::DerivedInfo>,
/// Output only. Indicates whether a company is flagged to be suspended from
/// public availability by the service when job content appears suspicious,
/// abusive, or spammy.
#[prost(bool, tag = "13")]
pub suspended: bool,
}
/// Nested message and enum types in `Company`.
pub mod company {
/// Derived details about the company.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DerivedInfo {
/// A structured headquarters location of the company, resolved from
/// \[Company.headquarters_address][google.cloud.talent.v4beta1.Company.headquarters_address\] if provided.
#[prost(message, optional, tag = "1")]
pub headquarters_location: ::core::option::Option<super::Location>,
}
}
/// The Request of the CreateCompany method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateCompanyRequest {
/// Required. Resource name of the tenant under which the company is created.
///
/// The format is "projects/{project_id}/tenants/{tenant_id}", for example,
/// "projects/foo/tenant/bar". If tenant id is unspecified, a default tenant
/// is created, for example, "projects/foo".
#[prost(string, tag = "1")]
pub parent: ::prost::alloc::string::String,
/// Required. The company to be created.
#[prost(message, optional, tag = "2")]
pub company: ::core::option::Option<Company>,
}
/// Request for getting a company by name.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetCompanyRequest {
/// Required. The resource name of the company to be retrieved.
///
/// The format is
/// "projects/{project_id}/tenants/{tenant_id}/companies/{company_id}", for
/// example, "projects/api-test-project/tenants/foo/companies/bar".
///
/// If tenant id is unspecified, the default tenant is used, for
/// example, "projects/api-test-project/companies/bar".
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
}
/// Request for updating a specified company.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateCompanyRequest {
/// Required. The company resource to replace the current resource in the system.
#[prost(message, optional, tag = "1")]
pub company: ::core::option::Option<Company>,
/// Strongly recommended for the best service experience.
///
/// If \[update_mask][google.cloud.talent.v4beta1.UpdateCompanyRequest.update_mask\] is provided, only the specified fields in
/// \[company][google.cloud.talent.v4beta1.UpdateCompanyRequest.company\] are updated. Otherwise all the fields are updated.
///
/// A field mask to specify the company fields to be updated. Only
/// top level fields of \[Company][google.cloud.talent.v4beta1.Company\] are supported.
#[prost(message, optional, tag = "2")]
pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request to delete a company.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteCompanyRequest {
/// Required. The resource name of the company to be deleted.
///
/// The format is
/// "projects/{project_id}/tenants/{tenant_id}/companies/{company_id}", for
/// example, "projects/foo/tenants/bar/companies/baz".
///
/// If tenant id is unspecified, the default tenant is used, for
/// example, "projects/foo/companies/bar".
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
}
/// List companies for which the client has ACL visibility.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListCompaniesRequest {
/// Required. Resource name of the tenant under which the company is created.
///
/// The format is "projects/{project_id}/tenants/{tenant_id}", for example,
/// "projects/foo/tenant/bar".
///
/// If tenant id is unspecified, the default tenant will be used, for
/// example, "projects/foo".
#[prost(string, tag = "1")]
pub parent: ::prost::alloc::string::String,
/// The starting indicator from which to return results.
#[prost(string, tag = "2")]
pub page_token: ::prost::alloc::string::String,
/// The maximum number of companies to be returned, at most 100.
/// Default is 100 if a non-positive number is provided.
#[prost(int32, tag = "3")]
pub page_size: i32,
/// Set to true if the companies requested must have open jobs.
///
/// Defaults to false.
///
/// If true, at most \[page_size][google.cloud.talent.v4beta1.ListCompaniesRequest.page_size\] of companies are fetched, among which
/// only those with open jobs are returned.
#[prost(bool, tag = "4")]
pub require_open_jobs: bool,
}
/// The List companies response object.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListCompaniesResponse {
/// Companies for the current client.
#[prost(message, repeated, tag = "1")]
pub companies: ::prost::alloc::vec::Vec<Company>,
/// A token to retrieve the next page of results.
#[prost(string, tag = "2")]
pub next_page_token: ::prost::alloc::string::String,
/// Additional information for the API invocation, such as the request
/// tracking id.
#[prost(message, optional, tag = "3")]
pub metadata: ::core::option::Option<ResponseMetadata>,
}
#[doc = r" Generated client implementations."]
pub mod company_service_client {
#![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
use tonic::codegen::*;
#[doc = " A service that handles company management, including CRUD and enumeration."]
#[derive(Debug, Clone)]
pub struct CompanyServiceClient<T> {
inner: tonic::client::Grpc<T>,
}
impl<T> CompanyServiceClient<T>
where
T: tonic::client::GrpcService<tonic::body::BoxBody>,
T::ResponseBody: Body + Send + 'static,
T::Error: Into<StdError>,
<T::ResponseBody as Body>::Error: Into<StdError> + Send,
{
pub fn new(inner: T) -> Self {
let inner = tonic::client::Grpc::new(inner);
Self { inner }
}
pub fn with_interceptor<F>(
inner: T,
interceptor: F,
) -> CompanyServiceClient<InterceptedService<T, F>>
where
F: tonic::service::Interceptor,
T: tonic::codegen::Service<
http::Request<tonic::body::BoxBody>,
Response = http::Response<
<T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
>,
>,
<T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
Into<StdError> + Send + Sync,
{
CompanyServiceClient::new(InterceptedService::new(inner, interceptor))
}
#[doc = r" Compress requests with `gzip`."]
#[doc = r""]
#[doc = r" This requires the server to support it otherwise it might respond with an"]
#[doc = r" error."]
pub fn send_gzip(mut self) -> Self {
self.inner = self.inner.send_gzip();
self
}
#[doc = r" Enable decompressing responses with `gzip`."]
pub fn accept_gzip(mut self) -> Self {
self.inner = self.inner.accept_gzip();
self
}
#[doc = " Creates a new company entity."]
pub async fn create_company(
&mut self,
request: impl tonic::IntoRequest<super::CreateCompanyRequest>,
) -> Result<tonic::Response<super::Company>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.talent.v4beta1.CompanyService/CreateCompany",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Retrieves specified company."]
pub async fn get_company(
&mut self,
request: impl tonic::IntoRequest<super::GetCompanyRequest>,
) -> Result<tonic::Response<super::Company>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.talent.v4beta1.CompanyService/GetCompany",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Updates specified company."]
pub async fn update_company(
&mut self,
request: impl tonic::IntoRequest<super::UpdateCompanyRequest>,
) -> Result<tonic::Response<super::Company>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.talent.v4beta1.CompanyService/UpdateCompany",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Deletes specified company."]
#[doc = " Prerequisite: The company has no jobs associated with it."]
pub async fn delete_company(
&mut self,
request: impl tonic::IntoRequest<super::DeleteCompanyRequest>,
) -> Result<tonic::Response<()>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.talent.v4beta1.CompanyService/DeleteCompany",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Lists all companies associated with the project."]
pub async fn list_companies(
&mut self,
request: impl tonic::IntoRequest<super::ListCompaniesRequest>,
) -> Result<tonic::Response<super::ListCompaniesResponse>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.talent.v4beta1.CompanyService/ListCompanies",
);
self.inner.unary(request.into_request(), path, codec).await
}
}
}
/// Auto-complete parameters.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CompleteQueryRequest {
/// Required. Resource name of tenant the completion is performed within.
///
/// The format is "projects/{project_id}/tenants/{tenant_id}", for example,
/// "projects/foo/tenant/bar".
///
/// If tenant id is unspecified, the default tenant is used, for
/// example, "projects/foo".
#[prost(string, tag = "1")]
pub parent: ::prost::alloc::string::String,
/// Required. The query used to generate suggestions.
///
/// The maximum number of allowed characters is 255.
#[prost(string, tag = "2")]
pub query: ::prost::alloc::string::String,
/// The list of languages of the query. This is
/// the BCP-47 language code, such as "en-US" or "sr-Latn".
/// For more information, see
/// [Tags for Identifying Languages](<https://tools.ietf.org/html/bcp47>).
///
/// The maximum number of allowed characters is 255.
#[prost(string, repeated, tag = "3")]
pub language_codes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
/// Required. Completion result count.
///
/// The maximum allowed page size is 10.
#[prost(int32, tag = "4")]
pub page_size: i32,
/// If provided, restricts completion to specified company.
///
/// The format is
/// "projects/{project_id}/tenants/{tenant_id}/companies/{company_id}", for
/// example, "projects/foo/tenants/bar/companies/baz".
///
/// If tenant id is unspecified, the default tenant is used, for
/// example, "projects/foo".
#[prost(string, tag = "5")]
pub company: ::prost::alloc::string::String,
/// The scope of the completion. The defaults is \[CompletionScope.PUBLIC][google.cloud.talent.v4beta1.CompleteQueryRequest.CompletionScope.PUBLIC\].
#[prost(enumeration = "complete_query_request::CompletionScope", tag = "6")]
pub scope: i32,
/// The completion topic. The default is \[CompletionType.COMBINED][google.cloud.talent.v4beta1.CompleteQueryRequest.CompletionType.COMBINED\].
#[prost(enumeration = "complete_query_request::CompletionType", tag = "7")]
pub r#type: i32,
}
/// Nested message and enum types in `CompleteQueryRequest`.
pub mod complete_query_request {
/// Enum to specify the scope of completion.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum CompletionScope {
/// Default value.
Unspecified = 0,
/// Suggestions are based only on the data provided by the client.
Tenant = 1,
/// Suggestions are based on all jobs data in the system that's visible to
/// the client
Public = 2,
}
/// Enum to specify auto-completion topics.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum CompletionType {
/// Default value.
Unspecified = 0,
/// Suggest job titles for jobs autocomplete.
///
/// For \[CompletionType.JOB_TITLE][google.cloud.talent.v4beta1.CompleteQueryRequest.CompletionType.JOB_TITLE\] type, only open jobs with the same
/// \[language_codes][google.cloud.talent.v4beta1.CompleteQueryRequest.language_codes\] are returned.
JobTitle = 1,
/// Suggest company names for jobs autocomplete.
///
/// For \[CompletionType.COMPANY_NAME][google.cloud.talent.v4beta1.CompleteQueryRequest.CompletionType.COMPANY_NAME\] type,
/// only companies having open jobs with the same \[language_codes][google.cloud.talent.v4beta1.CompleteQueryRequest.language_codes\] are
/// returned.
CompanyName = 2,
/// Suggest both job titles and company names for jobs autocomplete.
///
/// For \[CompletionType.COMBINED][google.cloud.talent.v4beta1.CompleteQueryRequest.CompletionType.COMBINED\] type, only open jobs with the same
/// \[language_codes][google.cloud.talent.v4beta1.CompleteQueryRequest.language_codes\] or companies having open jobs with the same
/// \[language_codes][google.cloud.talent.v4beta1.CompleteQueryRequest.language_codes\] are returned.
Combined = 3,
}
}
/// Response of auto-complete query.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CompleteQueryResponse {
/// Results of the matching job/company candidates.
#[prost(message, repeated, tag = "1")]
pub completion_results: ::prost::alloc::vec::Vec<complete_query_response::CompletionResult>,
/// Additional information for the API invocation, such as the request
/// tracking id.
#[prost(message, optional, tag = "2")]
pub metadata: ::core::option::Option<ResponseMetadata>,
}
/// Nested message and enum types in `CompleteQueryResponse`.
pub mod complete_query_response {
/// Resource that represents completion results.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CompletionResult {
/// The suggestion for the query.
#[prost(string, tag = "1")]
pub suggestion: ::prost::alloc::string::String,
/// The completion topic.
#[prost(enumeration = "super::complete_query_request::CompletionType", tag = "2")]
pub r#type: i32,
/// The URI of the company image for
/// \[COMPANY_NAME][google.cloud.talent.v4beta1.CompleteQueryRequest.CompletionType.COMPANY_NAME\].
#[prost(string, tag = "3")]
pub image_uri: ::prost::alloc::string::String,
}
}
#[doc = r" Generated client implementations."]
pub mod completion_client {
#![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
use tonic::codegen::*;
#[doc = " A service handles auto completion."]
#[derive(Debug, Clone)]
pub struct CompletionClient<T> {
inner: tonic::client::Grpc<T>,
}
impl<T> CompletionClient<T>
where
T: tonic::client::GrpcService<tonic::body::BoxBody>,
T::ResponseBody: Body + Send + 'static,
T::Error: Into<StdError>,
<T::ResponseBody as Body>::Error: Into<StdError> + Send,
{
pub fn new(inner: T) -> Self {
let inner = tonic::client::Grpc::new(inner);
Self { inner }
}
pub fn with_interceptor<F>(
inner: T,
interceptor: F,
) -> CompletionClient<InterceptedService<T, F>>
where
F: tonic::service::Interceptor,
T: tonic::codegen::Service<
http::Request<tonic::body::BoxBody>,
Response = http::Response<
<T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
>,
>,
<T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
Into<StdError> + Send + Sync,
{
CompletionClient::new(InterceptedService::new(inner, interceptor))
}
#[doc = r" Compress requests with `gzip`."]
#[doc = r""]
#[doc = r" This requires the server to support it otherwise it might respond with an"]
#[doc = r" error."]
pub fn send_gzip(mut self) -> Self {
self.inner = self.inner.send_gzip();
self
}
#[doc = r" Enable decompressing responses with `gzip`."]
pub fn accept_gzip(mut self) -> Self {
self.inner = self.inner.accept_gzip();
self
}
#[doc = " Completes the specified prefix with keyword suggestions."]
#[doc = " Intended for use by a job search auto-complete search box."]
pub async fn complete_query(
&mut self,
request: impl tonic::IntoRequest<super::CompleteQueryRequest>,
) -> Result<tonic::Response<super::CompleteQueryResponse>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.talent.v4beta1.Completion/CompleteQuery",
);
self.inner.unary(request.into_request(), path, codec).await
}
}
}
/// An event issued when an end user interacts with the application that
/// implements Cloud Talent Solution. Providing this information improves the
/// quality of results for the API clients, enabling the
/// service to perform optimally. The number of events sent must be consistent
/// with other calls, such as job searches, issued to the service by the client.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ClientEvent {
/// Strongly recommended for the best service experience.
///
/// A unique ID generated in the API responses. It can be found in
/// \[ResponseMetadata.request_id][google.cloud.talent.v4beta1.ResponseMetadata.request_id\].
#[prost(string, tag = "1")]
pub request_id: ::prost::alloc::string::String,
/// Required. A unique identifier, generated by the client application.
#[prost(string, tag = "2")]
pub event_id: ::prost::alloc::string::String,
/// Required. The timestamp of the event.
#[prost(message, optional, tag = "4")]
pub create_time: ::core::option::Option<::prost_types::Timestamp>,
/// Notes about the event provided by recruiters or other users, for example,
/// feedback on why a profile was bookmarked.
#[prost(string, tag = "9")]
pub event_notes: ::prost::alloc::string::String,
/// Required.
///
/// The detail information of a specific event type.
#[prost(oneof = "client_event::Event", tags = "5, 6")]
pub event: ::core::option::Option<client_event::Event>,
}
/// Nested message and enum types in `ClientEvent`.
pub mod client_event {
/// Required.
///
/// The detail information of a specific event type.
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum Event {
/// An event issued when a job seeker interacts with the application that
/// implements Cloud Talent Solution.
#[prost(message, tag = "5")]
JobEvent(super::JobEvent),
/// An event issued when a profile searcher interacts with the application
/// that implements Cloud Talent Solution.
#[prost(message, tag = "6")]
ProfileEvent(super::ProfileEvent),
}
}
/// An event issued when a job seeker interacts with the application that
/// implements Cloud Talent Solution.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct JobEvent {
/// Required. The type of the event (see \[JobEventType][google.cloud.talent.v4beta1.JobEvent.JobEventType\]).
#[prost(enumeration = "job_event::JobEventType", tag = "1")]
pub r#type: i32,
/// Required. The [job name(s)]\[google.cloud.talent.v4beta1.Job.name\] associated with this event.
/// For example, if this is an \[impression][google.cloud.talent.v4beta1.JobEvent.JobEventType.IMPRESSION\] event,
/// this field contains the identifiers of all jobs shown to the job seeker.
/// If this was a \[view][google.cloud.talent.v4beta1.JobEvent.JobEventType.VIEW\] event, this field contains the
/// identifier of the viewed job.
///
/// The format is
/// "projects/{project_id}/tenants/{tenant_id}/jobs/{job_id}", for
/// example, "projects/foo/tenants/bar/jobs/baz".
#[prost(string, repeated, tag = "2")]
pub jobs: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
/// The [profile name]\[google.cloud.talent.v4beta1.Profile.name\] associated with this client event.
///
/// The format is
/// "projects/{project_id}/tenants/{tenant_id}/profiles/{profile_id}",
/// for example, "projects/foo/tenants/bar/profiles/baz".
#[prost(string, tag = "3")]
pub profile: ::prost::alloc::string::String,
}
/// Nested message and enum types in `JobEvent`.
pub mod job_event {
/// An enumeration of an event attributed to the behavior of the end user,
/// such as a job seeker.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum JobEventType {
/// The event is unspecified by other provided values.
Unspecified = 0,
/// The job seeker or other entity interacting with the service has
/// had a job rendered in their view, such as in a list of search results in
/// a compressed or clipped format. This event is typically associated with
/// the viewing of a jobs list on a single page by a job seeker.
Impression = 1,
/// The job seeker, or other entity interacting with the service, has
/// viewed the details of a job, including the full description. This
/// event doesn't apply to the viewing a snippet of a job appearing as a
/// part of the job search results. Viewing a snippet is associated with an
/// \[impression][google.cloud.talent.v4beta1.JobEvent.JobEventType.IMPRESSION\]).
View = 2,
/// The job seeker or other entity interacting with the service
/// performed an action to view a job and was redirected to a different
/// website for job.
ViewRedirect = 3,
/// The job seeker or other entity interacting with the service
/// began the process or demonstrated the intention of applying for a job.
ApplicationStart = 4,
/// The job seeker or other entity interacting with the service
/// submitted an application for a job.
ApplicationFinish = 5,
/// The job seeker or other entity interacting with the service
/// submitted an application for a job with a single click without
/// entering information. If a job seeker performs this action, send only
/// this event to the service. Do not also send
/// \[JobEventType.APPLICATION_START][google.cloud.talent.v4beta1.JobEvent.JobEventType.APPLICATION_START\] or \[JobEventType.APPLICATION_FINISH][google.cloud.talent.v4beta1.JobEvent.JobEventType.APPLICATION_FINISH\]
/// events.
ApplicationQuickSubmission = 6,
/// The job seeker or other entity interacting with the service
/// performed an action to apply to a job and was redirected to a different
/// website to complete the application.
ApplicationRedirect = 7,
/// The job seeker or other entity interacting with the service began the
/// process or demonstrated the intention of applying for a job from the
/// search results page without viewing the details of the job posting.
/// If sending this event, JobEventType.VIEW event shouldn't be sent.
ApplicationStartFromSearch = 8,
/// The job seeker, or other entity interacting with the service, performs an
/// action with a single click from the search results page to apply to a job
/// (without viewing the details of the job posting), and is redirected
/// to a different website to complete the application. If a candidate
/// performs this action, send only this event to the service. Do not also
/// send \[JobEventType.APPLICATION_START][google.cloud.talent.v4beta1.JobEvent.JobEventType.APPLICATION_START\],
/// \[JobEventType.APPLICATION_FINISH][google.cloud.talent.v4beta1.JobEvent.JobEventType.APPLICATION_FINISH\] or \[JobEventType.VIEW][google.cloud.talent.v4beta1.JobEvent.JobEventType.VIEW\] events.
ApplicationRedirectFromSearch = 9,
/// This event should be used when a company submits an application
/// on behalf of a job seeker. This event is intended for use by staffing
/// agencies attempting to place candidates.
ApplicationCompanySubmit = 10,
/// The job seeker or other entity interacting with the service demonstrated
/// an interest in a job by bookmarking or saving it.
Bookmark = 11,
/// The job seeker or other entity interacting with the service was
/// sent a notification, such as an email alert or device notification,
/// containing one or more jobs listings generated by the service.
Notification = 12,
/// The job seeker or other entity interacting with the service was
/// employed by the hiring entity (employer). Send this event
/// only if the job seeker was hired through an application that was
/// initiated by a search conducted through the Cloud Talent Solution
/// service.
Hired = 13,
/// A recruiter or staffing agency submitted an application on behalf of the
/// candidate after interacting with the service to identify a suitable job
/// posting.
SentCv = 14,
/// The entity interacting with the service (for example, the job seeker),
/// was granted an initial interview by the hiring entity (employer). This
/// event should only be sent if the job seeker was granted an interview as
/// part of an application that was initiated by a search conducted through /
/// recommendation provided by the Cloud Talent Solution service.
InterviewGranted = 15,
}
}
/// An event issued when a profile searcher interacts with the application
/// that implements Cloud Talent Solution.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ProfileEvent {
/// Required. Type of event.
#[prost(enumeration = "profile_event::ProfileEventType", tag = "1")]
pub r#type: i32,
/// Required. The [profile name(s)]\[google.cloud.talent.v4beta1.Profile.name\] associated with this client event.
///
/// The format is
/// "projects/{project_id}/tenants/{tenant_id}/profiles/{profile_id}",
/// for example, "projects/foo/tenants/bar/profiles/baz".
#[prost(string, repeated, tag = "2")]
pub profiles: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
/// The [job name(s)]\[google.cloud.talent.v4beta1.Job.name\] associated with this client event. Leave it
/// empty if the event isn't associated with a job.
///
/// The format is
/// "projects/{project_id}/tenants/{tenant_id}/jobs/{job_id}", for
/// example, "projects/foo/tenants/bar/jobs/baz".
#[prost(string, repeated, tag = "6")]
pub jobs: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Nested message and enum types in `ProfileEvent`.
pub mod profile_event {
/// The enum represents types of client events for a candidate profile.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ProfileEventType {
/// Default value.
Unspecified = 0,
/// Send this event when a \[ProfileEvent.profiles][google.cloud.talent.v4beta1.ProfileEvent.profiles\] was sent as a part of
/// a result set for a CTS API call and was rendered in the end user's UI
/// (that is, the \[ProfileEvent.recruiter][google.cloud.talent.v4beta1.ProfileEvent.recruiter\]).
Impression = 1,
/// The VIEW event records the action of a candidate's profile being
/// viewed by an end user. This is critical to tracking product metrics and
/// should be sent for every profile VIEW that happens in your system,
/// whether the event is associated with an API call (for example, a
/// recruiter making a request for a result set and clicking on a profile)
/// or not (a recruiter using the system to view profile details without
/// making a request).
///
/// For a VIEW events associated with API calls, the
/// \[ClientEvent.request_id][google.cloud.talent.v4beta1.ClientEvent.request_id\] should be populated. If the VIEW is not
/// associated with an API call, \[request_id][google.cloud.talent.v4beta1.ClientEvent.request_id\] should
/// not be populated.
///
/// This event requires a valid recruiter and one valid ID in profiles.
View = 2,
/// The profile is bookmarked.
Bookmark = 3,
}
}
/// The report event request.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateClientEventRequest {
/// Required. Resource name of the tenant under which the event is created.
///
/// The format is "projects/{project_id}/tenants/{tenant_id}", for example,
/// "projects/foo/tenant/bar". If tenant id is unspecified, a default tenant
/// is created, for example, "projects/foo".
#[prost(string, tag = "1")]
pub parent: ::prost::alloc::string::String,
/// Required. Events issued when end user interacts with customer's application that
/// uses Cloud Talent Solution.
#[prost(message, optional, tag = "2")]
pub client_event: ::core::option::Option<ClientEvent>,
}
#[doc = r" Generated client implementations."]
pub mod event_service_client {
#![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
use tonic::codegen::*;
#[doc = " A service handles client event report."]
#[derive(Debug, Clone)]
pub struct EventServiceClient<T> {
inner: tonic::client::Grpc<T>,
}
impl<T> EventServiceClient<T>
where
T: tonic::client::GrpcService<tonic::body::BoxBody>,
T::ResponseBody: Body + Send + 'static,
T::Error: Into<StdError>,
<T::ResponseBody as Body>::Error: Into<StdError> + Send,
{
pub fn new(inner: T) -> Self {
let inner = tonic::client::Grpc::new(inner);
Self { inner }
}
pub fn with_interceptor<F>(
inner: T,
interceptor: F,
) -> EventServiceClient<InterceptedService<T, F>>
where
F: tonic::service::Interceptor,
T: tonic::codegen::Service<
http::Request<tonic::body::BoxBody>,
Response = http::Response<
<T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
>,
>,
<T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
Into<StdError> + Send + Sync,
{
EventServiceClient::new(InterceptedService::new(inner, interceptor))
}
#[doc = r" Compress requests with `gzip`."]
#[doc = r""]
#[doc = r" This requires the server to support it otherwise it might respond with an"]
#[doc = r" error."]
pub fn send_gzip(mut self) -> Self {
self.inner = self.inner.send_gzip();
self
}
#[doc = r" Enable decompressing responses with `gzip`."]
pub fn accept_gzip(mut self) -> Self {
self.inner = self.inner.accept_gzip();
self
}
#[doc = " Report events issued when end user interacts with customer's application"]
#[doc = " that uses Cloud Talent Solution. You may inspect the created events in"]
#[doc = " [self service"]
#[doc = " tools](https://console.cloud.google.com/talent-solution/overview)."]
#[doc = " [Learn"]
#[doc = " more](https://cloud.google.com/talent-solution/docs/management-tools)"]
#[doc = " about self service tools."]
pub async fn create_client_event(
&mut self,
request: impl tonic::IntoRequest<super::CreateClientEventRequest>,
) -> Result<tonic::Response<super::ClientEvent>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.talent.v4beta1.EventService/CreateClientEvent",
);
self.inner.unary(request.into_request(), path, codec).await
}
}
}
/// The query required to perform a search query.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct JobQuery {
/// The query string that matches against the job title, description, and
/// location fields.
///
/// The maximum number of allowed characters is 255.
#[prost(string, tag = "1")]
pub query: ::prost::alloc::string::String,
/// The language code of \[query][google.cloud.talent.v4beta1.JobQuery.query\]. For example, "en-US". This field helps to
/// better interpret the query.
///
/// If a value isn't specified, the query language code is automatically
/// detected, which may not be accurate.
///
/// Language code should be in BCP-47 format, such as "en-US" or "sr-Latn".
/// For more information, see
/// [Tags for Identifying Languages](<https://tools.ietf.org/html/bcp47>).
#[prost(string, tag = "14")]
pub query_language_code: ::prost::alloc::string::String,
/// This filter specifies the company entities to search against.
///
/// If a value isn't specified, jobs are searched for against all
/// companies.
///
/// If multiple values are specified, jobs are searched against the
/// companies specified.
///
/// The format is
/// "projects/{project_id}/tenants/{tenant_id}/companies/{company_id}". For
/// example, "projects/foo/tenants/bar/companies/baz".
///
/// If tenant id is unspecified, the default tenant is used. For
/// example, "projects/foo/companies/bar".
///
/// At most 20 company filters are allowed.
#[prost(string, repeated, tag = "2")]
pub companies: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
/// The location filter specifies geo-regions containing the jobs to
/// search against. See \[LocationFilter][google.cloud.talent.v4beta1.LocationFilter\] for more information.
///
/// If a location value isn't specified, jobs fitting the other search
/// criteria are retrieved regardless of where they're located.
///
/// If multiple values are specified, jobs are retrieved from any of the
/// specified locations. If different values are specified for the
/// \[LocationFilter.distance_in_miles][google.cloud.talent.v4beta1.LocationFilter.distance_in_miles\] parameter, the maximum provided
/// distance is used for all locations.
///
/// At most 5 location filters are allowed.
#[prost(message, repeated, tag = "3")]
pub location_filters: ::prost::alloc::vec::Vec<LocationFilter>,
/// The category filter specifies the categories of jobs to search against.
/// See \[JobCategory][google.cloud.talent.v4beta1.JobCategory\] for more information.
///
/// If a value isn't specified, jobs from any category are searched against.
///
/// If multiple values are specified, jobs from any of the specified
/// categories are searched against.
#[prost(enumeration = "JobCategory", repeated, tag = "4")]
pub job_categories: ::prost::alloc::vec::Vec<i32>,
/// Allows filtering jobs by commute time with different travel methods (for
/// example, driving or public transit).
///
/// Note: This only works when you specify a \[CommuteMethod][google.cloud.talent.v4beta1.CommuteMethod\]. In this case,
/// \[location_filters][google.cloud.talent.v4beta1.JobQuery.location_filters\] is ignored.
///
/// Currently we don't support sorting by commute time.
#[prost(message, optional, tag = "5")]
pub commute_filter: ::core::option::Option<CommuteFilter>,
/// This filter specifies the exact company \[Company.display_name][google.cloud.talent.v4beta1.Company.display_name\]
/// of the jobs to search against.
///
/// If a value isn't specified, jobs within the search results are
/// associated with any company.
///
/// If multiple values are specified, jobs within the search results may be
/// associated with any of the specified companies.
///
/// At most 20 company display name filters are allowed.
#[prost(string, repeated, tag = "6")]
pub company_display_names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
/// This search filter is applied only to
/// \[Job.compensation_info][google.cloud.talent.v4beta1.Job.compensation_info\]. For example, if the filter is specified
/// as "Hourly job with per-hour compensation > $15", only jobs meeting
/// these criteria are searched. If a filter isn't defined, all open jobs
/// are searched.
#[prost(message, optional, tag = "7")]
pub compensation_filter: ::core::option::Option<CompensationFilter>,
/// This filter specifies a structured syntax to match against the
/// \[Job.custom_attributes][google.cloud.talent.v4beta1.Job.custom_attributes\] marked as `filterable`.
///
/// The syntax for this expression is a subset of SQL syntax.
///
/// Supported operators are: `=`, `!=`, `<`, `<=`, `>`, and `>=` where the
/// left of the operator is a custom field key and the right of the operator
/// is a number or a quoted string. You must escape backslash (\\) and
/// quote (\") characters.
///
/// Supported functions are `LOWER(\[field_name\])` to
/// perform a case insensitive match and `EMPTY(\[field_name\])` to filter on the
/// existence of a key.
///
/// Boolean expressions (AND/OR/NOT) are supported up to 3 levels of
/// nesting (for example, "((A AND B AND C) OR NOT D) AND E"), a maximum of 100
/// comparisons or functions are allowed in the expression. The expression
/// must be < 6000 bytes in length.
///
/// Sample Query:
/// `(LOWER(driving_license)="class \"a\"" OR EMPTY(driving_license)) AND
/// driving_years > 10`
#[prost(string, tag = "8")]
pub custom_attribute_filter: ::prost::alloc::string::String,
/// This flag controls the spell-check feature. If false, the
/// service attempts to correct a misspelled query,
/// for example, "enginee" is corrected to "engineer".
///
/// Defaults to false: a spell check is performed.
#[prost(bool, tag = "9")]
pub disable_spell_check: bool,
/// The employment type filter specifies the employment type of jobs to
/// search against, such as \[EmploymentType.FULL_TIME][google.cloud.talent.v4beta1.EmploymentType.FULL_TIME\].
///
/// If a value isn't specified, jobs in the search results includes any
/// employment type.
///
/// If multiple values are specified, jobs in the search results include
/// any of the specified employment types.
#[prost(enumeration = "EmploymentType", repeated, tag = "10")]
pub employment_types: ::prost::alloc::vec::Vec<i32>,
/// This filter specifies the locale of jobs to search against,
/// for example, "en-US".
///
/// If a value isn't specified, the search results can contain jobs in any
/// locale.
///
///
/// Language codes should be in BCP-47 format, such as "en-US" or "sr-Latn".
/// For more information, see
/// [Tags for Identifying Languages](<https://tools.ietf.org/html/bcp47>).
///
/// At most 10 language code filters are allowed.
#[prost(string, repeated, tag = "11")]
pub language_codes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
/// Jobs published within a range specified by this filter are searched
/// against.
#[prost(message, optional, tag = "12")]
pub publish_time_range: ::core::option::Option<TimestampRange>,
/// This filter specifies a list of job names to be excluded during search.
///
/// At most 400 excluded job names are allowed.
#[prost(string, repeated, tag = "13")]
pub excluded_jobs: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Filters to apply when performing the search query.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ProfileQuery {
/// Keywords to match any text fields of profiles.
///
/// For example, "software engineer in Palo Alto".
#[prost(string, tag = "1")]
pub query: ::prost::alloc::string::String,
/// The location filter specifies geo-regions containing the profiles to
/// search against.
///
/// One of \[LocationFilter.address][google.cloud.talent.v4beta1.LocationFilter.address\] or \[LocationFilter.lat_lng][google.cloud.talent.v4beta1.LocationFilter.lat_lng\] must be
/// provided or an error is thrown. If both \[LocationFilter.address][google.cloud.talent.v4beta1.LocationFilter.address\] and
/// \[LocationFilter.lat_lng][google.cloud.talent.v4beta1.LocationFilter.lat_lng\] are provided, an error is thrown.
///
/// The following logic is used to determine which locations in
/// the profile to filter against:
///
/// 1. All of the profile's geocoded \[Profile.addresses][google.cloud.talent.v4beta1.Profile.addresses\] where
/// \[Address.usage][google.cloud.talent.v4beta1.Address.usage\] is PERSONAL and \[Address.current][google.cloud.talent.v4beta1.Address.current\] is true.
///
/// 2. If the above set of locations is empty, all of the profile's geocoded
/// \[Profile.addresses][google.cloud.talent.v4beta1.Profile.addresses\] where \[Address.usage][google.cloud.talent.v4beta1.Address.usage\] is
/// CONTACT_INFO_USAGE_UNSPECIFIED and \[Address.current][google.cloud.talent.v4beta1.Address.current\] is true.
///
/// 3. If the above set of locations is empty, all of the profile's geocoded
/// \[Profile.addresses][google.cloud.talent.v4beta1.Profile.addresses\] where \[Address.usage][google.cloud.talent.v4beta1.Address.usage\] is PERSONAL or
/// CONTACT_INFO_USAGE_UNSPECIFIED and \[Address.current][google.cloud.talent.v4beta1.Address.current\] is not set.
///
/// This means that any profiles without any \[Profile.addresses][google.cloud.talent.v4beta1.Profile.addresses\] that match
/// any of the above criteria will not be included in a search with location
/// filter. Furthermore, any \[Profile.addresses][google.cloud.talent.v4beta1.Profile.addresses\] where \[Address.usage][google.cloud.talent.v4beta1.Address.usage\] is
/// WORK or SCHOOL or where \[Address.current][google.cloud.talent.v4beta1.Address.current\] is false are not considered for
/// location filter.
///
/// If a location filter isn't specified, profiles fitting the other search
/// criteria are retrieved regardless of where they're located.
///
/// If \[LocationFilter.negated][google.cloud.talent.v4beta1.LocationFilter.negated\] is specified, the result doesn't contain
/// profiles from that location.
///
/// If \[LocationFilter.address][google.cloud.talent.v4beta1.LocationFilter.address\] is provided, the
/// \[LocationType][google.cloud.talent.v4beta1.Location.LocationType\], center
/// point (latitude and longitude), and radius are automatically detected by
/// the Google Maps Geocoding API and included as well. If
/// \[LocationFilter.address][google.cloud.talent.v4beta1.LocationFilter.address\] cannot be geocoded, the filter
/// falls back to keyword search.
///
/// If the detected
/// \[LocationType][google.cloud.talent.v4beta1.Location.LocationType\] is
/// \[LocationType.SUB_ADMINISTRATIVE_AREA][google.cloud.talent.v4beta1.Location.LocationType.SUB_ADMINISTRATIVE_AREA\],
/// \[LocationType.ADMINISTRATIVE_AREA][google.cloud.talent.v4beta1.Location.LocationType.ADMINISTRATIVE_AREA\],
/// or
/// \[LocationType.COUNTRY][google.cloud.talent.v4beta1.Location.LocationType.COUNTRY\],
/// the filter is performed against the detected location name (using exact
/// text matching). Otherwise, the filter is performed against the detected
/// center point and a radius of detected location radius +
/// \[LocationFilter.distance_in_miles][google.cloud.talent.v4beta1.LocationFilter.distance_in_miles\].
///
/// If \[LocationFilter.address][google.cloud.talent.v4beta1.LocationFilter.address\] is provided,
/// \[LocationFilter.distance_in_miles][google.cloud.talent.v4beta1.LocationFilter.distance_in_miles\] is the additional radius on top of the
/// radius of the location geocoded from \[LocationFilter.address][google.cloud.talent.v4beta1.LocationFilter.address\]. If
/// \[LocationFilter.lat_lng][google.cloud.talent.v4beta1.LocationFilter.lat_lng\] is provided,
/// \[LocationFilter.distance_in_miles][google.cloud.talent.v4beta1.LocationFilter.distance_in_miles\] is the only radius that is used.
///
/// \[LocationFilter.distance_in_miles][google.cloud.talent.v4beta1.LocationFilter.distance_in_miles\] is 10 by default. Note that the value
/// of \[LocationFilter.distance_in_miles][google.cloud.talent.v4beta1.LocationFilter.distance_in_miles\] is 0 if it is unset, so the server
/// does not differentiate \[LocationFilter.distance_in_miles][google.cloud.talent.v4beta1.LocationFilter.distance_in_miles\] that is
/// explicitly set to 0 and \[LocationFilter.distance_in_miles][google.cloud.talent.v4beta1.LocationFilter.distance_in_miles\] that is not
/// set. Which means that if \[LocationFilter.distance_in_miles][google.cloud.talent.v4beta1.LocationFilter.distance_in_miles\] is explicitly
/// set to 0, the server will use the default value of
/// \[LocationFilter.distance_in_miles][google.cloud.talent.v4beta1.LocationFilter.distance_in_miles\] which is 10. To work around this and
/// effectively set \[LocationFilter.distance_in_miles][google.cloud.talent.v4beta1.LocationFilter.distance_in_miles\] to 0, we recommend
/// setting \[LocationFilter.distance_in_miles][google.cloud.talent.v4beta1.LocationFilter.distance_in_miles\] to a very small decimal number
/// (such as 0.00001).
///
/// If \[LocationFilter.distance_in_miles][google.cloud.talent.v4beta1.LocationFilter.distance_in_miles\] is negative, an error is thrown.
#[prost(message, repeated, tag = "2")]
pub location_filters: ::prost::alloc::vec::Vec<LocationFilter>,
/// Job title filter specifies job titles of profiles to match on.
///
/// If a job title isn't specified, profiles with any titles are retrieved.
///
/// If multiple values are specified, profiles are retrieved with any of the
/// specified job titles.
///
/// If \[JobTitleFilter.negated][google.cloud.talent.v4beta1.JobTitleFilter.negated\] is specified, the result won't contain
/// profiles with the job titles.
///
/// For example, search for profiles with a job title "Product Manager".
#[prost(message, repeated, tag = "3")]
pub job_title_filters: ::prost::alloc::vec::Vec<JobTitleFilter>,
/// Employer filter specifies employers of profiles to match on.
///
/// If an employer filter isn't specified, profiles with any employers are
/// retrieved.
///
/// If multiple employer filters are specified, profiles with any matching
/// employers are retrieved.
///
/// If \[EmployerFilter.negated][google.cloud.talent.v4beta1.EmployerFilter.negated\] is specified, the result won't contain
/// profiles that match the employers.
///
/// For example, search for profiles that have working experience at "Google
/// LLC".
#[prost(message, repeated, tag = "4")]
pub employer_filters: ::prost::alloc::vec::Vec<EmployerFilter>,
/// Education filter specifies education of profiles to match on.
///
/// If an education filter isn't specified, profiles with any education are
/// retrieved.
///
/// If multiple education filters are specified, profiles that match any
/// education filters are retrieved.
///
/// If \[EducationFilter.negated][google.cloud.talent.v4beta1.EducationFilter.negated\] is specified, the result won't contain
/// profiles that match the educations.
///
/// For example, search for profiles with a master degree.
#[prost(message, repeated, tag = "5")]
pub education_filters: ::prost::alloc::vec::Vec<EducationFilter>,
/// Skill filter specifies skill of profiles to match on.
///
/// If a skill filter isn't specified, profiles with any skills are retrieved.
///
/// If multiple skill filters are specified, profiles that match any skill
/// filters are retrieved.
///
/// If \[SkillFilter.negated][google.cloud.talent.v4beta1.SkillFilter.negated\] is specified, the result won't contain profiles
/// that match the skills.
///
/// For example, search for profiles that have "Java" and "Python" in skill
/// list.
#[prost(message, repeated, tag = "6")]
pub skill_filters: ::prost::alloc::vec::Vec<SkillFilter>,
/// Work experience filter specifies the total working experience of profiles
/// to match on.
///
/// If a work experience filter isn't specified, profiles with any
/// professional experience are retrieved.
///
/// If multiple work experience filters are specified, profiles that match any
/// work experience filters are retrieved.
///
/// For example, search for profiles with 10 years of work experience.
#[prost(message, repeated, tag = "7")]
pub work_experience_filter: ::prost::alloc::vec::Vec<WorkExperienceFilter>,
/// Time filter specifies the create/update timestamp of the profiles to match
/// on.
///
/// For example, search for profiles created since "2018-1-1".
#[prost(message, repeated, tag = "8")]
pub time_filters: ::prost::alloc::vec::Vec<TimeFilter>,
/// The hirable filter specifies the profile's hirable status to match on.
#[prost(message, optional, tag = "9")]
pub hirable_filter: ::core::option::Option<bool>,
/// The application date filters specify application date ranges to match on.
#[prost(message, repeated, tag = "10")]
pub application_date_filters: ::prost::alloc::vec::Vec<ApplicationDateFilter>,
/// The application outcome notes filters specify the notes for the outcome of
/// the job application.
#[prost(message, repeated, tag = "11")]
pub application_outcome_notes_filters: ::prost::alloc::vec::Vec<ApplicationOutcomeNotesFilter>,
/// The application job filters specify the job applied for in the application.
#[prost(message, repeated, tag = "13")]
pub application_job_filters: ::prost::alloc::vec::Vec<ApplicationJobFilter>,
/// This filter specifies a structured syntax to match against the
/// \[Profile.custom_attributes][google.cloud.talent.v4beta1.Profile.custom_attributes\] that are marked as `filterable`.
///
/// The syntax for this expression is a subset of Google SQL syntax.
///
/// String custom attributes: supported operators are =, != where the left of
/// the operator is a custom field key and the right of the operator is a
/// string (surrounded by quotes) value.
///
/// Numeric custom attributes: Supported operators are '>', '<' or '='
/// operators where the left of the operator is a custom field key and the
/// right of the operator is a numeric value.
///
/// Supported functions are LOWER(<field_name>) to
/// perform case insensitive match and EMPTY(<field_name>) to filter on the
/// existence of a key.
///
/// Boolean expressions (AND/OR/NOT) are supported up to 3 levels of
/// nesting (for example "((A AND B AND C) OR NOT D) AND E"), and there can be
/// a maximum of 50 comparisons/functions in the expression. The expression
/// must be < 2000 characters in length.
///
/// Sample Query:
/// (key1 = "TEST" OR LOWER(key1)="test" OR NOT EMPTY(key1))
#[prost(string, tag = "15")]
pub custom_attribute_filter: ::prost::alloc::string::String,
/// Deprecated. Use availability_filters instead.
///
/// The candidate availability filter which filters based on availability
/// signals.
///
/// Signal 1: Number of days since most recent job application. See
/// \[Availability.JobApplicationAvailabilitySignal][google.cloud.talent.v4beta1.Availability.JobApplicationAvailabilitySignal\] for the details of this
/// signal.
///
/// Signal 2: Number of days since last profile update. See
/// \[Availability.ProfileUpdateAvailabilitySignal][google.cloud.talent.v4beta1.Availability.ProfileUpdateAvailabilitySignal\]
/// for the details of this signal.
///
/// The candidate availability filter helps a recruiter understand if a
/// specific candidate is likely to be actively seeking new job opportunities
/// based on an aggregated set of signals. Specifically, the intent is NOT to
/// indicate the candidate's potential qualification / interest / close ability
/// for a specific job.
#[deprecated]
#[prost(message, optional, tag = "16")]
pub candidate_availability_filter: ::core::option::Option<CandidateAvailabilityFilter>,
/// The availability filter which filters based on
/// \[Profile.availability_signals][google.cloud.talent.v4beta1.Profile.availability_signals\].
///
/// The availability filter helps a recruiter understand if a
/// specific candidate is likely to be actively seeking new job opportunities
/// based on an aggregated set of signals. Specifically, the intent is NOT to
/// indicate the candidate's potential qualification / interest / close ability
/// for a specific job.
///
/// There can be at most one \[AvailabilityFilter][google.cloud.talent.v4beta1.AvailabilityFilter\] per
/// \[signal_type][google.cloud.talent.v4beta1.AvailabilityFilter.signal_type\]. If there are multiple
/// \[AvailabilityFilter][google.cloud.talent.v4beta1.AvailabilityFilter\] for a \[signal_type][google.cloud.talent.v4beta1.AvailabilityFilter.signal_type\],
/// an error is thrown.
#[prost(message, repeated, tag = "18")]
pub availability_filters: ::prost::alloc::vec::Vec<AvailabilityFilter>,
/// Person name filter specifies person name of profiles to match on.
///
/// If multiple person name filters are specified, profiles that match any
/// person name filters are retrieved.
///
/// For example, search for profiles of candidates with name "John Smith".
#[prost(message, repeated, tag = "17")]
pub person_name_filters: ::prost::alloc::vec::Vec<PersonNameFilter>,
}
/// Geographic region of the search.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LocationFilter {
/// The address name, such as "Mountain View" or "Bay Area".
#[prost(string, tag = "1")]
pub address: ::prost::alloc::string::String,
/// CLDR region code of the country/region of the address. This is used
/// to address ambiguity of the user-input location, for example, "Liverpool"
/// against "Liverpool, NY, US" or "Liverpool, UK".
///
/// Set this field to bias location resolution toward a specific country
/// or territory. If this field is not set, application behavior is biased
/// toward the United States by default.
///
/// See
/// <https://www.unicode.org/cldr/charts/30/supplemental/territory_information.html>
/// for details. Example: "CH" for Switzerland.
/// Note that this filter is not applicable for Profile Search related queries.
#[prost(string, tag = "2")]
pub region_code: ::prost::alloc::string::String,
/// The latitude and longitude of the geographic center to search from. This
/// field is ignored if `address` is provided.
#[prost(message, optional, tag = "3")]
pub lat_lng: ::core::option::Option<super::super::super::r#type::LatLng>,
/// The distance_in_miles is applied when the location being searched for is
/// identified as a city or smaller. This field is ignored if the location
/// being searched for is a state or larger.
#[prost(double, tag = "4")]
pub distance_in_miles: f64,
/// Allows the client to return jobs without a
/// set location, specifically, telecommuting jobs (telecommuting is considered
/// by the service as a special location.
/// \[Job.posting_region][google.cloud.talent.v4beta1.Job.posting_region\] indicates if a job permits telecommuting.
/// If this field is set to \[TelecommutePreference.TELECOMMUTE_ALLOWED][google.cloud.talent.v4beta1.LocationFilter.TelecommutePreference.TELECOMMUTE_ALLOWED\],
/// telecommuting jobs are searched, and \[address][google.cloud.talent.v4beta1.LocationFilter.address\] and \[lat_lng][google.cloud.talent.v4beta1.LocationFilter.lat_lng\] are
/// ignored. If not set or set to
/// \[TelecommutePreference.TELECOMMUTE_EXCLUDED][google.cloud.talent.v4beta1.LocationFilter.TelecommutePreference.TELECOMMUTE_EXCLUDED\], telecommute job are not
/// searched.
///
/// This filter can be used by itself to search exclusively for telecommuting
/// jobs, or it can be combined with another location
/// filter to search for a combination of job locations,
/// such as "Mountain View" or "telecommuting" jobs. However, when used in
/// combination with other location filters, telecommuting jobs can be
/// treated as less relevant than other jobs in the search response.
///
/// This field is only used for job search requests.
#[prost(enumeration = "location_filter::TelecommutePreference", tag = "5")]
pub telecommute_preference: i32,
/// Whether to apply negation to the filter so profiles matching the filter
/// are excluded.
///
/// Currently only supported in profile search.
#[prost(bool, tag = "6")]
pub negated: bool,
}
/// Nested message and enum types in `LocationFilter`.
pub mod location_filter {
/// Specify whether to include telecommute jobs.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum TelecommutePreference {
/// Default value if the telecommute preference isn't specified.
Unspecified = 0,
/// Exclude telecommute jobs.
TelecommuteExcluded = 1,
/// Allow telecommute jobs.
TelecommuteAllowed = 2,
}
}
/// Filter on job compensation type and amount.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CompensationFilter {
/// Required. Type of filter.
#[prost(enumeration = "compensation_filter::FilterType", tag = "1")]
pub r#type: i32,
/// Required. Specify desired `base compensation entry's`
/// \[CompensationInfo.CompensationUnit][google.cloud.talent.v4beta1.CompensationInfo.CompensationUnit\].
#[prost(
enumeration = "compensation_info::CompensationUnit",
repeated,
packed = "false",
tag = "2"
)]
pub units: ::prost::alloc::vec::Vec<i32>,
/// Compensation range.
#[prost(message, optional, tag = "3")]
pub range: ::core::option::Option<compensation_info::CompensationRange>,
/// If set to true, jobs with unspecified compensation range fields are
/// included.
#[prost(bool, tag = "4")]
pub include_jobs_with_unspecified_compensation_range: bool,
}
/// Nested message and enum types in `CompensationFilter`.
pub mod compensation_filter {
/// Specify the type of filtering.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum FilterType {
/// Filter type unspecified. Position holder, INVALID, should never be used.
Unspecified = 0,
/// Filter by `base compensation entry's` unit. A job is a match if and
/// only if the job contains a base CompensationEntry and the base
/// CompensationEntry's unit matches provided \[units][google.cloud.talent.v4beta1.CompensationFilter.units\].
/// Populate one or more \[units][google.cloud.talent.v4beta1.CompensationFilter.units\].
///
/// See \[CompensationInfo.CompensationEntry][google.cloud.talent.v4beta1.CompensationInfo.CompensationEntry\] for definition of
/// base compensation entry.
UnitOnly = 1,
/// Filter by `base compensation entry's` unit and amount / range. A job
/// is a match if and only if the job contains a base CompensationEntry, and
/// the base entry's unit matches provided
/// \[CompensationUnit][google.cloud.talent.v4beta1.CompensationInfo.CompensationUnit\] and
/// amount or range overlaps with provided
/// \[CompensationRange][google.cloud.talent.v4beta1.CompensationInfo.CompensationRange\].
///
/// See \[CompensationInfo.CompensationEntry][google.cloud.talent.v4beta1.CompensationInfo.CompensationEntry\] for definition of
/// base compensation entry.
///
/// Set exactly one \[units][google.cloud.talent.v4beta1.CompensationFilter.units\] and populate \[range][google.cloud.talent.v4beta1.CompensationFilter.range\].
UnitAndAmount = 2,
/// Filter by annualized base compensation amount and `base compensation
/// entry's` unit. Populate \[range][google.cloud.talent.v4beta1.CompensationFilter.range\] and zero or more \[units][google.cloud.talent.v4beta1.CompensationFilter.units\].
AnnualizedBaseAmount = 3,
/// Filter by annualized total compensation amount and `base compensation
/// entry's` unit . Populate \[range][google.cloud.talent.v4beta1.CompensationFilter.range\] and zero or more \[units][google.cloud.talent.v4beta1.CompensationFilter.units\].
AnnualizedTotalAmount = 4,
}
}
/// Parameters needed for commute search.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CommuteFilter {
/// Required. The method of transportation to calculate the commute time for.
#[prost(enumeration = "CommuteMethod", tag = "1")]
pub commute_method: i32,
/// Required. The latitude and longitude of the location to calculate the
/// commute time from.
#[prost(message, optional, tag = "2")]
pub start_coordinates: ::core::option::Option<super::super::super::r#type::LatLng>,
/// Required. The maximum travel time in seconds. The maximum allowed value is `3600s`
/// (one hour). Format is `123s`.
#[prost(message, optional, tag = "3")]
pub travel_duration: ::core::option::Option<::prost_types::Duration>,
/// If `true`, jobs without street level addresses may also be returned.
/// For city level addresses, the city center is used. For state and coarser
/// level addresses, text matching is used.
/// If this field is set to `false` or isn't specified, only jobs that include
/// street level addresses will be returned by commute search.
#[prost(bool, tag = "4")]
pub allow_imprecise_addresses: bool,
/// Traffic factor to take into account while searching by commute.
#[prost(oneof = "commute_filter::TrafficOption", tags = "5, 6")]
pub traffic_option: ::core::option::Option<commute_filter::TrafficOption>,
}
/// Nested message and enum types in `CommuteFilter`.
pub mod commute_filter {
/// The traffic density to use when calculating commute time.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum RoadTraffic {
/// Road traffic situation isn't specified.
Unspecified = 0,
/// Optimal commute time without considering any traffic impact.
TrafficFree = 1,
/// Commute time calculation takes in account the peak traffic impact.
BusyHour = 2,
}
/// Traffic factor to take into account while searching by commute.
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum TrafficOption {
/// Specifies the traffic density to use when calculating commute time.
#[prost(enumeration = "RoadTraffic", tag = "5")]
RoadTraffic(i32),
/// The departure time used to calculate traffic impact, represented as
/// \[google.type.TimeOfDay][google.type.TimeOfDay\] in local time zone.
///
/// Currently traffic model is restricted to hour level resolution.
#[prost(message, tag = "6")]
DepartureTime(super::super::super::super::r#type::TimeOfDay),
}
}
/// Job title of the search.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct JobTitleFilter {
/// Required. The job title. For example, "Software engineer", or "Product manager".
#[prost(string, tag = "1")]
pub job_title: ::prost::alloc::string::String,
/// Whether to apply negation to the filter so profiles matching the filter
/// are excluded.
#[prost(bool, tag = "2")]
pub negated: bool,
}
/// Skill filter of the search.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SkillFilter {
/// Required. The skill name. For example, "java", "j2ee", and so on.
#[prost(string, tag = "1")]
pub skill: ::prost::alloc::string::String,
/// Whether to apply negation to the filter so profiles matching the filter
/// are excluded.
#[prost(bool, tag = "2")]
pub negated: bool,
}
/// Employer filter of the search.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EmployerFilter {
/// Required. The name of the employer, for example "Google", "Alphabet".
#[prost(string, tag = "1")]
pub employer: ::prost::alloc::string::String,
/// Define set of \[EmploymentRecord][google.cloud.talent.v4beta1.EmploymentRecord\]s to search against.
///
/// Defaults to \[EmployerFilterMode.ALL_EMPLOYMENT_RECORDS][google.cloud.talent.v4beta1.EmployerFilter.EmployerFilterMode.ALL_EMPLOYMENT_RECORDS\].
#[prost(enumeration = "employer_filter::EmployerFilterMode", tag = "2")]
pub mode: i32,
/// Whether to apply negation to the filter so profiles matching the filter
/// is excluded.
#[prost(bool, tag = "3")]
pub negated: bool,
}
/// Nested message and enum types in `EmployerFilter`.
pub mod employer_filter {
/// Enum indicating which set of \[Profile.employment_records][google.cloud.talent.v4beta1.Profile.employment_records\] to search
/// against.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum EmployerFilterMode {
/// Default value.
Unspecified = 0,
/// Apply to all employers in \[Profile.employment_records][google.cloud.talent.v4beta1.Profile.employment_records\].
AllEmploymentRecords = 1,
/// Apply only to current employer in \[Profile.employment_records][google.cloud.talent.v4beta1.Profile.employment_records\].
CurrentEmploymentRecordsOnly = 2,
/// Apply only to past (not current) employers in
/// \[Profile.employment_records][google.cloud.talent.v4beta1.Profile.employment_records\].
PastEmploymentRecordsOnly = 3,
}
}
/// Education filter of the search.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EducationFilter {
/// The school name. For example "MIT", "University of California, Berkeley".
#[prost(string, tag = "1")]
pub school: ::prost::alloc::string::String,
/// The field of study. This is to search against value provided in
/// \[Degree.fields_of_study][google.cloud.talent.v4beta1.Degree.fields_of_study\].
/// For example "Computer Science", "Mathematics".
#[prost(string, tag = "2")]
pub field_of_study: ::prost::alloc::string::String,
/// Education degree in ISCED code. Each value in degree covers a specific
/// level of education, without any expansion to upper nor lower levels of
/// education degree.
#[prost(enumeration = "DegreeType", tag = "3")]
pub degree_type: i32,
/// Whether to apply negation to the filter so profiles matching the filter
/// is excluded.
#[prost(bool, tag = "6")]
pub negated: bool,
}
/// Work experience filter.
///
/// This filter is used to search for profiles with working experience length
/// between \[min_experience][google.cloud.talent.v4beta1.WorkExperienceFilter.min_experience\] and \[max_experience][google.cloud.talent.v4beta1.WorkExperienceFilter.max_experience\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WorkExperienceFilter {
/// The minimum duration of the work experience (inclusive).
#[prost(message, optional, tag = "1")]
pub min_experience: ::core::option::Option<::prost_types::Duration>,
/// The maximum duration of the work experience (exclusive).
#[prost(message, optional, tag = "2")]
pub max_experience: ::core::option::Option<::prost_types::Duration>,
}
/// Application Date Range Filter.
///
/// The API matches profiles with \[Application.application_date][google.cloud.talent.v4beta1.Application.application_date\] between
/// start date and end date (both boundaries are inclusive). The filter is
/// ignored if both \[start_date][google.cloud.talent.v4beta1.ApplicationDateFilter.start_date\] and \[end_date][google.cloud.talent.v4beta1.ApplicationDateFilter.end_date\] are missing.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ApplicationDateFilter {
/// Start date. If it's missing, The API matches profiles with application date
/// not after the end date.
#[prost(message, optional, tag = "1")]
pub start_date: ::core::option::Option<super::super::super::r#type::Date>,
/// End date. If it's missing, The API matches profiles with application date
/// not before the start date.
#[prost(message, optional, tag = "2")]
pub end_date: ::core::option::Option<super::super::super::r#type::Date>,
}
/// Outcome Notes Filter.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ApplicationOutcomeNotesFilter {
/// Required. User entered or selected outcome reason. The API does an exact match on the
/// \[Application.outcome_notes][google.cloud.talent.v4beta1.Application.outcome_notes\] in profiles.
#[prost(string, tag = "1")]
pub outcome_notes: ::prost::alloc::string::String,
/// If true, The API excludes all candidates with any
/// \[Application.outcome_notes][google.cloud.talent.v4beta1.Application.outcome_notes\] matching the outcome reason specified in
/// the filter.
#[prost(bool, tag = "2")]
pub negated: bool,
}
/// Filter on the job information of Application.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ApplicationJobFilter {
/// The job requisition id in the application. The API does an exact match on
/// the \[Job.requisition_id][google.cloud.talent.v4beta1.Job.requisition_id\] of \[Application.job][google.cloud.talent.v4beta1.Application.job\] in profiles.
#[prost(string, tag = "2")]
pub job_requisition_id: ::prost::alloc::string::String,
/// The job title in the application. The API does an exact match on the
/// \[Job.title][google.cloud.talent.v4beta1.Job.title\] of \[Application.job][google.cloud.talent.v4beta1.Application.job\] in profiles.
#[prost(string, tag = "3")]
pub job_title: ::prost::alloc::string::String,
/// If true, the API excludes all profiles with any \[Application.job][google.cloud.talent.v4beta1.Application.job\]
/// matching the filters.
#[prost(bool, tag = "4")]
pub negated: bool,
}
/// Filter on create timestamp or update timestamp of profiles.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TimeFilter {
/// Start timestamp, matching profiles with the start time. If this field
/// missing, The API matches profiles with create / update timestamp before the
/// end timestamp.
#[prost(message, optional, tag = "1")]
pub start_time: ::core::option::Option<::prost_types::Timestamp>,
/// End timestamp, matching profiles with the end time. If this field
/// missing, The API matches profiles with create / update timestamp after the
/// start timestamp.
#[prost(message, optional, tag = "2")]
pub end_time: ::core::option::Option<::prost_types::Timestamp>,
/// Specifies which time field to filter profiles.
///
/// Defaults to \[TimeField.CREATE_TIME][google.cloud.talent.v4beta1.TimeFilter.TimeField.CREATE_TIME\].
#[prost(enumeration = "time_filter::TimeField", tag = "3")]
pub time_field: i32,
}
/// Nested message and enum types in `TimeFilter`.
pub mod time_filter {
/// Time fields can be used in TimeFilter.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum TimeField {
/// Default value.
Unspecified = 0,
/// Earliest profile create time.
CreateTime = 1,
/// Latest profile update time.
UpdateTime = 2,
}
}
/// Deprecated. Use AvailabilityFilter instead.
///
/// Filter on availability signals.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CandidateAvailabilityFilter {
/// It is false by default. If true, API excludes all the potential available
/// profiles.
#[prost(bool, tag = "1")]
pub negated: bool,
}
/// Filter on availability signals.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AvailabilityFilter {
/// Required. Type of signal to apply filter on.
#[prost(enumeration = "AvailabilitySignalType", tag = "1")]
pub signal_type: i32,
/// Required. Range of times to filter candidate signals by.
#[prost(message, optional, tag = "2")]
pub range: ::core::option::Option<TimestampRange>,
/// If multiple \[AvailabilityFilter][google.cloud.talent.v4beta1.AvailabilityFilter\] are provided, the default
/// behavior is to OR all filters, but if this field is set to true, this
/// particular \[AvailabilityFilter][google.cloud.talent.v4beta1.AvailabilityFilter\] will be AND'ed against other
/// \[AvailabilityFilter][google.cloud.talent.v4beta1.AvailabilityFilter\].
#[prost(bool, tag = "3")]
pub required: bool,
}
/// Filter on person name.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PersonNameFilter {
/// Required. The person name. For example, "John Smith".
///
/// Can be any combination of \[PersonName.structured_name.given_name][\],
/// \[PersonName.structured_name.middle_initial][\],
/// \[PersonName.structured_name.family_name][\], and
/// \[PersonName.formatted_name][google.cloud.talent.v4beta1.PersonName.formatted_name\].
#[prost(string, tag = "1")]
pub person_name: ::prost::alloc::string::String,
}
/// The histogram request.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HistogramQuery {
/// An expression specifies a histogram request against matching resources
/// (for example, jobs, profiles) for searches.
///
/// See \[SearchJobsRequest.histogram_queries][google.cloud.talent.v4beta1.SearchJobsRequest.histogram_queries\] and
/// \[SearchProfilesRequest.histogram_queries][google.cloud.talent.v4beta1.SearchProfilesRequest.histogram_queries\] for details about syntax.
#[prost(string, tag = "1")]
pub histogram_query: ::prost::alloc::string::String,
}
/// Histogram result that matches \[HistogramQuery][google.cloud.talent.v4beta1.HistogramQuery\] specified in searches.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HistogramQueryResult {
/// Requested histogram expression.
#[prost(string, tag = "1")]
pub histogram_query: ::prost::alloc::string::String,
/// A map from the values of the facet associated with distinct values to the
/// number of matching entries with corresponding value.
///
/// The key format is:
///
/// * (for string histogram) string values stored in the field.
/// * (for named numeric bucket) name specified in `bucket()` function, like
/// for `bucket(0, MAX, "non-negative")`, the key will be `non-negative`.
/// * (for anonymous numeric bucket) range formatted as `<low>-<high>`, for
/// example, `0-1000`, `MIN-0`, and `0-MAX`.
#[prost(map = "string, int64", tag = "2")]
pub histogram: ::std::collections::HashMap<::prost::alloc::string::String, i64>,
}
/// A Job resource represents a job posting (also referred to as a "job listing"
/// or "job requisition"). A job belongs to a \[Company][google.cloud.talent.v4beta1.Company\], which is the hiring
/// entity responsible for the job.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Job {
/// Required during job update.
///
/// The resource name for the job. This is generated by the service when a
/// job is created.
///
/// The format is
/// "projects/{project_id}/tenants/{tenant_id}/jobs/{job_id}". For
/// example, "projects/foo/tenants/bar/jobs/baz".
///
/// If tenant id is unspecified, the default tenant is used. For
/// example, "projects/foo/jobs/bar".
///
/// Use of this field in job queries and API calls is preferred over the use of
/// \[requisition_id][google.cloud.talent.v4beta1.Job.requisition_id\] since this value is unique.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
/// Required. The resource name of the company listing the job.
///
/// The format is
/// "projects/{project_id}/tenants/{tenant_id}/companies/{company_id}". For
/// example, "projects/foo/tenants/bar/companies/baz".
///
/// If tenant id is unspecified, the default tenant is used. For
/// example, "projects/foo/companies/bar".
#[prost(string, tag = "2")]
pub company: ::prost::alloc::string::String,
/// Required. The requisition ID, also referred to as the posting ID, is assigned by the
/// client to identify a job. This field is intended to be used by clients
/// for client identification and tracking of postings. A job isn't allowed
/// to be created if there is another job with the same \[company][google.cloud.talent.v4beta1.Job.name\],
/// \[language_code][google.cloud.talent.v4beta1.Job.language_code\] and \[requisition_id][google.cloud.talent.v4beta1.Job.requisition_id\].
///
/// The maximum number of allowed characters is 255.
#[prost(string, tag = "3")]
pub requisition_id: ::prost::alloc::string::String,
/// Required. The title of the job, such as "Software Engineer"
///
/// The maximum number of allowed characters is 500.
#[prost(string, tag = "4")]
pub title: ::prost::alloc::string::String,
/// Required. The description of the job, which typically includes a multi-paragraph
/// description of the company and related information. Separate fields are
/// provided on the job object for \[responsibilities][google.cloud.talent.v4beta1.Job.responsibilities\],
/// \[qualifications][google.cloud.talent.v4beta1.Job.qualifications\], and other job characteristics. Use of
/// these separate job fields is recommended.
///
/// This field accepts and sanitizes HTML input, and also accepts
/// bold, italic, ordered list, and unordered list markup tags.
///
/// The maximum number of allowed characters is 100,000.
#[prost(string, tag = "5")]
pub description: ::prost::alloc::string::String,
/// Strongly recommended for the best service experience.
///
/// Location(s) where the employer is looking to hire for this job posting.
///
/// Specifying the full street address(es) of the hiring location enables
/// better API results, especially job searches by commute time.
///
/// At most 50 locations are allowed for best search performance. If a job has
/// more locations, it is suggested to split it into multiple jobs with unique
/// \[requisition_id][google.cloud.talent.v4beta1.Job.requisition_id\]s (e.g. 'ReqA' becomes 'ReqA-1', 'ReqA-2', and so on.) as
/// multiple jobs with the same \[company][google.cloud.talent.v4beta1.Job.company\], \[language_code][google.cloud.talent.v4beta1.Job.language_code\] and
/// \[requisition_id][google.cloud.talent.v4beta1.Job.requisition_id\] are not allowed. If the original \[requisition_id][google.cloud.talent.v4beta1.Job.requisition_id\] must
/// be preserved, a custom field should be used for storage. It is also
/// suggested to group the locations that close to each other in the same job
/// for better search experience.
///
/// The maximum number of allowed characters is 500.
#[prost(string, repeated, tag = "6")]
pub addresses: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
/// Job application information.
#[prost(message, optional, tag = "7")]
pub application_info: ::core::option::Option<job::ApplicationInfo>,
/// The benefits included with the job.
#[prost(enumeration = "JobBenefit", repeated, tag = "8")]
pub job_benefits: ::prost::alloc::vec::Vec<i32>,
/// Job compensation information (a.k.a. "pay rate") i.e., the compensation
/// that will paid to the employee.
#[prost(message, optional, tag = "9")]
pub compensation_info: ::core::option::Option<CompensationInfo>,
/// A map of fields to hold both filterable and non-filterable custom job
/// attributes that are not covered by the provided structured fields.
///
/// The keys of the map are strings up to 64 bytes and must match the
/// pattern: `\[a-zA-Z][a-zA-Z0-9_\]*`. For example, key0LikeThis or
/// KEY_1_LIKE_THIS.
///
/// At most 100 filterable and at most 100 unfilterable keys are supported.
/// For filterable `string_values`, across all keys at most 200 values are
/// allowed, with each string no more than 255 characters. For unfilterable
/// `string_values`, the maximum total size of `string_values` across all keys
/// is 50KB.
#[prost(map = "string, message", tag = "10")]
pub custom_attributes:
::std::collections::HashMap<::prost::alloc::string::String, CustomAttribute>,
/// The desired education degrees for the job, such as Bachelors, Masters.
#[prost(enumeration = "DegreeType", repeated, tag = "11")]
pub degree_types: ::prost::alloc::vec::Vec<i32>,
/// The department or functional area within the company with the open
/// position.
///
/// The maximum number of allowed characters is 255.
#[prost(string, tag = "12")]
pub department: ::prost::alloc::string::String,
/// The employment type(s) of a job, for example,
/// [full time]\[google.cloud.talent.v4beta1.EmploymentType.FULL_TIME\] or
/// [part time]\[google.cloud.talent.v4beta1.EmploymentType.PART_TIME\].
#[prost(enumeration = "EmploymentType", repeated, tag = "13")]
pub employment_types: ::prost::alloc::vec::Vec<i32>,
/// A description of bonus, commission, and other compensation
/// incentives associated with the job not including salary or pay.
///
/// The maximum number of allowed characters is 10,000.
#[prost(string, tag = "14")]
pub incentives: ::prost::alloc::string::String,
/// The language of the posting. This field is distinct from
/// any requirements for fluency that are associated with the job.
///
/// Language codes must be in BCP-47 format, such as "en-US" or "sr-Latn".
/// For more information, see
/// [Tags for Identifying Languages](<https://tools.ietf.org/html/bcp47>){:
/// class="external" target="_blank" }.
///
/// If this field is unspecified and \[Job.description][google.cloud.talent.v4beta1.Job.description\] is present, detected
/// language code based on \[Job.description][google.cloud.talent.v4beta1.Job.description\] is assigned, otherwise
/// defaults to 'en_US'.
#[prost(string, tag = "15")]
pub language_code: ::prost::alloc::string::String,
/// The experience level associated with the job, such as "Entry Level".
#[prost(enumeration = "JobLevel", tag = "16")]
pub job_level: i32,
/// A promotion value of the job, as determined by the client.
/// The value determines the sort order of the jobs returned when searching for
/// jobs using the featured jobs search call, with higher promotional values
/// being returned first and ties being resolved by relevance sort. Only the
/// jobs with a promotionValue >0 are returned in a FEATURED_JOB_SEARCH.
///
/// Default value is 0, and negative values are treated as 0.
#[prost(int32, tag = "17")]
pub promotion_value: i32,
/// A description of the qualifications required to perform the
/// job. The use of this field is recommended
/// as an alternative to using the more general \[description][google.cloud.talent.v4beta1.Job.description\] field.
///
/// This field accepts and sanitizes HTML input, and also accepts
/// bold, italic, ordered list, and unordered list markup tags.
///
/// The maximum number of allowed characters is 10,000.
#[prost(string, tag = "18")]
pub qualifications: ::prost::alloc::string::String,
/// A description of job responsibilities. The use of this field is
/// recommended as an alternative to using the more general \[description][google.cloud.talent.v4beta1.Job.description\]
/// field.
///
/// This field accepts and sanitizes HTML input, and also accepts
/// bold, italic, ordered list, and unordered list markup tags.
///
/// The maximum number of allowed characters is 10,000.
#[prost(string, tag = "19")]
pub responsibilities: ::prost::alloc::string::String,
/// The job \[PostingRegion][google.cloud.talent.v4beta1.PostingRegion\] (for example, state, country) throughout
/// which the job is available. If this field is set, a \[LocationFilter][google.cloud.talent.v4beta1.LocationFilter\]
/// in a search query within the job region finds this job posting if an
/// exact location match isn't specified. If this field is set to
/// \[PostingRegion.NATION][google.cloud.talent.v4beta1.PostingRegion.NATION\] or \[PostingRegion.ADMINISTRATIVE_AREA][google.cloud.talent.v4beta1.PostingRegion.ADMINISTRATIVE_AREA\],
/// setting job \[Job.addresses][google.cloud.talent.v4beta1.Job.addresses\] to the same location level as this field
/// is strongly recommended.
#[prost(enumeration = "PostingRegion", tag = "20")]
pub posting_region: i32,
/// Deprecated. The job is only visible to the owner.
///
/// The visibility of the job.
///
/// Defaults to \[Visibility.ACCOUNT_ONLY][google.cloud.talent.v4beta1.Visibility.ACCOUNT_ONLY\] if not specified.
#[deprecated]
#[prost(enumeration = "Visibility", tag = "21")]
pub visibility: i32,
/// The start timestamp of the job in UTC time zone. Typically this field
/// is used for contracting engagements. Invalid timestamps are ignored.
#[prost(message, optional, tag = "22")]
pub job_start_time: ::core::option::Option<::prost_types::Timestamp>,
/// The end timestamp of the job. Typically this field is used for contracting
/// engagements. Invalid timestamps are ignored.
#[prost(message, optional, tag = "23")]
pub job_end_time: ::core::option::Option<::prost_types::Timestamp>,
/// The timestamp this job posting was most recently published. The default
/// value is the time the request arrives at the server. Invalid timestamps are
/// ignored.
#[prost(message, optional, tag = "24")]
pub posting_publish_time: ::core::option::Option<::prost_types::Timestamp>,
/// Strongly recommended for the best service experience.
///
/// The expiration timestamp of the job. After this timestamp, the
/// job is marked as expired, and it no longer appears in search results. The
/// expired job can't be listed by the \[ListJobs][google.cloud.talent.v4beta1.JobService.ListJobs\] API,
/// but it can be retrieved with the \[GetJob][google.cloud.talent.v4beta1.JobService.GetJob\] API or
/// updated with the \[UpdateJob][google.cloud.talent.v4beta1.JobService.UpdateJob\] API or deleted with
/// the \[DeleteJob][google.cloud.talent.v4beta1.JobService.DeleteJob\] API. An expired job can
/// be updated and opened again by using a future expiration timestamp.
/// Updating an expired job fails if there is another existing open job with
/// same \[company][google.cloud.talent.v4beta1.Job.company\], \[language_code][google.cloud.talent.v4beta1.Job.language_code\] and \[requisition_id][google.cloud.talent.v4beta1.Job.requisition_id\].
///
/// The expired jobs are retained in our system for 90 days. However, the
/// overall expired job count cannot exceed 3 times the maximum number of
/// open jobs over previous 7 days. If this threshold is exceeded,
/// expired jobs are cleaned out in order of earliest expire time.
/// Expired jobs are no longer accessible after they are cleaned
/// out.
///
/// Invalid timestamps are ignored, and treated as expire time not provided.
///
/// If the timestamp is before the instant request is made, the job
/// is treated as expired immediately on creation. This kind of job can
/// not be updated. And when creating a job with past timestamp, the
/// \[posting_publish_time][google.cloud.talent.v4beta1.Job.posting_publish_time\] must be set before
/// \[posting_expire_time][google.cloud.talent.v4beta1.Job.posting_expire_time\]. The purpose of this feature is
/// to allow other objects, such as \[Application][google.cloud.talent.v4beta1.Application\], to refer a job
/// that didn't exist in the system prior to becoming expired. If you
/// want to modify a job that was expired on creation,
/// delete it and create a new one.
///
/// If this value isn't provided at the time of job creation or is invalid,
/// the job posting expires after 30 days from the job's creation time. For
/// example, if the job was created on 2017/01/01 13:00AM UTC with an
/// unspecified expiration date, the job expires after 2017/01/31 13:00AM UTC.
///
/// If this value isn't provided on job update, it depends on the field masks
/// set by \[UpdateJobRequest.update_mask][google.cloud.talent.v4beta1.UpdateJobRequest.update_mask\]. If the field masks include
/// \[job_end_time][google.cloud.talent.v4beta1.Job.job_end_time\], or the masks are empty meaning that every field is
/// updated, the job posting expires after 30 days from the job's last
/// update time. Otherwise the expiration date isn't updated.
#[prost(message, optional, tag = "25")]
pub posting_expire_time: ::core::option::Option<::prost_types::Timestamp>,
/// Output only. The timestamp when this job posting was created.
#[prost(message, optional, tag = "26")]
pub posting_create_time: ::core::option::Option<::prost_types::Timestamp>,
/// Output only. The timestamp when this job posting was last updated.
#[prost(message, optional, tag = "27")]
pub posting_update_time: ::core::option::Option<::prost_types::Timestamp>,
/// Output only. Display name of the company listing the job.
#[prost(string, tag = "28")]
pub company_display_name: ::prost::alloc::string::String,
/// Output only. Derived details about the job posting.
#[prost(message, optional, tag = "29")]
pub derived_info: ::core::option::Option<job::DerivedInfo>,
/// Options for job processing.
#[prost(message, optional, tag = "30")]
pub processing_options: ::core::option::Option<job::ProcessingOptions>,
}
/// Nested message and enum types in `Job`.
pub mod job {
/// Application related details of a job posting.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ApplicationInfo {
/// Use this field to specify email address(es) to which resumes or
/// applications can be sent.
///
/// The maximum number of allowed characters for each entry is 255.
#[prost(string, repeated, tag = "1")]
pub emails: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
/// Use this field to provide instructions, such as "Mail your application
/// to ...", that a candidate can follow to apply for the job.
///
/// This field accepts and sanitizes HTML input, and also accepts
/// bold, italic, ordered list, and unordered list markup tags.
///
/// The maximum number of allowed characters is 3,000.
#[prost(string, tag = "2")]
pub instruction: ::prost::alloc::string::String,
/// Use this URI field to direct an applicant to a website, for example to
/// link to an online application form.
///
/// The maximum number of allowed characters for each entry is 2,000.
#[prost(string, repeated, tag = "3")]
pub uris: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Derived details about the job posting.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DerivedInfo {
/// Structured locations of the job, resolved from \[Job.addresses][google.cloud.talent.v4beta1.Job.addresses\].
///
/// \[locations][google.cloud.talent.v4beta1.Job.DerivedInfo.locations\] are exactly matched to \[Job.addresses][google.cloud.talent.v4beta1.Job.addresses\] in the same
/// order.
#[prost(message, repeated, tag = "1")]
pub locations: ::prost::alloc::vec::Vec<super::Location>,
/// Job categories derived from \[Job.title][google.cloud.talent.v4beta1.Job.title\] and \[Job.description][google.cloud.talent.v4beta1.Job.description\].
#[prost(enumeration = "super::JobCategory", repeated, tag = "3")]
pub job_categories: ::prost::alloc::vec::Vec<i32>,
}
/// Options for job processing.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ProcessingOptions {
/// If set to `true`, the service does not attempt to resolve a
/// more precise address for the job.
#[prost(bool, tag = "1")]
pub disable_street_address_resolution: bool,
/// Option for job HTML content sanitization. Applied fields are:
///
/// * description
/// * applicationInfo.instruction
/// * incentives
/// * qualifications
/// * responsibilities
///
/// HTML tags in these fields may be stripped if sanitiazation isn't
/// disabled.
///
/// Defaults to \[HtmlSanitization.SIMPLE_FORMATTING_ONLY][google.cloud.talent.v4beta1.HtmlSanitization.SIMPLE_FORMATTING_ONLY\].
#[prost(enumeration = "super::HtmlSanitization", tag = "2")]
pub html_sanitization: i32,
}
}
/// Create job request.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateJobRequest {
/// Required. The resource name of the tenant under which the job is created.
///
/// The format is "projects/{project_id}/tenants/{tenant_id}". For example,
/// "projects/foo/tenant/bar". If tenant id is unspecified a default tenant
/// is created. For example, "projects/foo".
#[prost(string, tag = "1")]
pub parent: ::prost::alloc::string::String,
/// Required. The Job to be created.
#[prost(message, optional, tag = "2")]
pub job: ::core::option::Option<Job>,
}
/// Get job request.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetJobRequest {
/// Required. The resource name of the job to retrieve.
///
/// The format is
/// "projects/{project_id}/tenants/{tenant_id}/jobs/{job_id}". For
/// example, "projects/foo/tenants/bar/jobs/baz".
///
/// If tenant id is unspecified, the default tenant is used. For
/// example, "projects/foo/jobs/bar".
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
}
/// Update job request.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateJobRequest {
/// Required. The Job to be updated.
#[prost(message, optional, tag = "1")]
pub job: ::core::option::Option<Job>,
/// Strongly recommended for the best service experience.
///
/// If \[update_mask][google.cloud.talent.v4beta1.UpdateJobRequest.update_mask\] is provided, only the specified fields in
/// \[job][google.cloud.talent.v4beta1.UpdateJobRequest.job\] are updated. Otherwise all the fields are updated.
///
/// A field mask to restrict the fields that are updated. Only
/// top level fields of \[Job][google.cloud.talent.v4beta1.Job\] are supported.
#[prost(message, optional, tag = "2")]
pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Delete job request.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteJobRequest {
/// Required. The resource name of the job to be deleted.
///
/// The format is
/// "projects/{project_id}/tenants/{tenant_id}/jobs/{job_id}". For
/// example, "projects/foo/tenants/bar/jobs/baz".
///
/// If tenant id is unspecified, the default tenant is used. For
/// example, "projects/foo/jobs/bar".
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
}
/// Batch delete jobs request.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchDeleteJobsRequest {
/// Required. The resource name of the tenant under which the job is created.
///
/// The format is "projects/{project_id}/tenants/{tenant_id}". For example,
/// "projects/foo/tenant/bar". If tenant id is unspecified, a default tenant
/// is created. For example, "projects/foo".
#[prost(string, tag = "1")]
pub parent: ::prost::alloc::string::String,
/// Required. The filter string specifies the jobs to be deleted.
///
/// Supported operator: =, AND
///
/// The fields eligible for filtering are:
///
/// * `companyName` (Required)
/// * `requisitionId` (Required)
///
/// Sample Query: companyName = "projects/foo/companies/bar" AND
/// requisitionId = "req-1"
#[prost(string, tag = "2")]
pub filter: ::prost::alloc::string::String,
}
/// List jobs request.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListJobsRequest {
/// Required. The resource name of the tenant under which the job is created.
///
/// The format is "projects/{project_id}/tenants/{tenant_id}". For example,
/// "projects/foo/tenant/bar". If tenant id is unspecified, a default tenant
/// is created. For example, "projects/foo".
#[prost(string, tag = "1")]
pub parent: ::prost::alloc::string::String,
/// Required. The filter string specifies the jobs to be enumerated.
///
/// Supported operator: =, AND
///
/// The fields eligible for filtering are:
///
/// * `companyName` (Required)
/// * `requisitionId`
/// * `status` Available values: OPEN, EXPIRED, ALL. Defaults to
/// OPEN if no value is specified.
///
/// Sample Query:
///
/// * companyName = "projects/foo/tenants/bar/companies/baz"
/// * companyName = "projects/foo/tenants/bar/companies/baz" AND
/// requisitionId = "req-1"
/// * companyName = "projects/foo/tenants/bar/companies/baz" AND
/// status = "EXPIRED"
#[prost(string, tag = "2")]
pub filter: ::prost::alloc::string::String,
/// The starting point of a query result.
#[prost(string, tag = "3")]
pub page_token: ::prost::alloc::string::String,
/// The maximum number of jobs to be returned per page of results.
///
/// If \[job_view][google.cloud.talent.v4beta1.ListJobsRequest.job_view\] is set to \[JobView.JOB_VIEW_ID_ONLY][google.cloud.talent.v4beta1.JobView.JOB_VIEW_ID_ONLY\], the maximum allowed
/// page size is 1000. Otherwise, the maximum allowed page size is 100.
///
/// Default is 100 if empty or a number < 1 is specified.
#[prost(int32, tag = "4")]
pub page_size: i32,
/// The desired job attributes returned for jobs in the
/// search response. Defaults to \[JobView.JOB_VIEW_FULL][google.cloud.talent.v4beta1.JobView.JOB_VIEW_FULL\] if no value is
/// specified.
#[prost(enumeration = "JobView", tag = "5")]
pub job_view: i32,
}
/// List jobs response.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListJobsResponse {
/// The Jobs for a given company.
///
/// The maximum number of items returned is based on the limit field
/// provided in the request.
#[prost(message, repeated, tag = "1")]
pub jobs: ::prost::alloc::vec::Vec<Job>,
/// A token to retrieve the next page of results.
#[prost(string, tag = "2")]
pub next_page_token: ::prost::alloc::string::String,
/// Additional information for the API invocation, such as the request
/// tracking id.
#[prost(message, optional, tag = "3")]
pub metadata: ::core::option::Option<ResponseMetadata>,
}
/// The Request body of the `SearchJobs` call.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SearchJobsRequest {
/// Required. The resource name of the tenant to search within.
///
/// The format is "projects/{project_id}/tenants/{tenant_id}". For example,
/// "projects/foo/tenant/bar". If tenant id is unspecified, a default tenant
/// is created. For example, "projects/foo".
#[prost(string, tag = "1")]
pub parent: ::prost::alloc::string::String,
/// Mode of a search.
///
/// Defaults to \[SearchMode.JOB_SEARCH][google.cloud.talent.v4beta1.SearchJobsRequest.SearchMode.JOB_SEARCH\].
#[prost(enumeration = "search_jobs_request::SearchMode", tag = "2")]
pub search_mode: i32,
/// Required. The meta information collected about the job searcher, used to improve the
/// search quality of the service. The identifiers (such as `user_id`) are
/// provided by users, and must be unique and consistent.
#[prost(message, optional, tag = "3")]
pub request_metadata: ::core::option::Option<RequestMetadata>,
/// Query used to search against jobs, such as keyword, location filters, etc.
#[prost(message, optional, tag = "4")]
pub job_query: ::core::option::Option<JobQuery>,
/// Controls whether to broaden the search when it produces sparse results.
/// Broadened queries append results to the end of the matching results
/// list.
///
/// Defaults to false.
#[prost(bool, tag = "5")]
pub enable_broadening: bool,
/// Controls if the search job request requires the return of a precise
/// count of the first 300 results. Setting this to `true` ensures
/// consistency in the number of results per page. Best practice is to set this
/// value to true if a client allows users to jump directly to a
/// non-sequential search results page.
///
/// Enabling this flag may adversely impact performance.
///
/// Defaults to false.
#[prost(bool, tag = "6")]
pub require_precise_result_size: bool,
/// An expression specifies a histogram request against matching jobs.
///
/// Expression syntax is an aggregation function call with histogram facets and
/// other options.
///
/// Available aggregation function calls are:
/// * `count(string_histogram_facet)`: Count the number of matching entities,
/// for each distinct attribute value.
/// * `count(numeric_histogram_facet, list of buckets)`: Count the number of
/// matching entities within each bucket.
///
/// Data types:
///
/// * Histogram facet: facet names with format `\[a-zA-Z][a-zA-Z0-9_\]+`.
/// * String: string like "any string with backslash escape for quote(\")."
/// * Number: whole number and floating point number like 10, -1 and -0.01.
/// * List: list of elements with comma(,) separator surrounded by square
/// brackets, for example, [1, 2, 3] and ["one", "two", "three"].
///
/// Built-in constants:
///
/// * MIN (minimum number similar to java Double.MIN_VALUE)
/// * MAX (maximum number similar to java Double.MAX_VALUE)
///
/// Built-in functions:
///
/// * bucket(start, end[, label]): bucket built-in function creates a bucket
/// with range of [start, end). Note that the end is exclusive, for example,
/// bucket(1, MAX, "positive number") or bucket(1, 10).
///
/// Job histogram facets:
///
/// * company_display_name: histogram by \[Job.company_display_name][google.cloud.talent.v4beta1.Job.company_display_name\].
/// * employment_type: histogram by \[Job.employment_types][google.cloud.talent.v4beta1.Job.employment_types\], for example,
/// "FULL_TIME", "PART_TIME".
/// * company_size: histogram by \[CompanySize][google.cloud.talent.v4beta1.CompanySize\], for example, "SMALL",
/// "MEDIUM", "BIG".
/// * publish_time_in_month: histogram by the \[Job.posting_publish_time][google.cloud.talent.v4beta1.Job.posting_publish_time\]
/// in months.
/// Must specify list of numeric buckets in spec.
/// * publish_time_in_year: histogram by the \[Job.posting_publish_time][google.cloud.talent.v4beta1.Job.posting_publish_time\]
/// in years.
/// Must specify list of numeric buckets in spec.
/// * degree_types: histogram by the \[Job.degree_types][google.cloud.talent.v4beta1.Job.degree_types\], for example,
/// "Bachelors", "Masters".
/// * job_level: histogram by the \[Job.job_level][google.cloud.talent.v4beta1.Job.job_level\], for example, "Entry
/// Level".
/// * country: histogram by the country code of jobs, for example, "US", "FR".
/// * admin1: histogram by the admin1 code of jobs, which is a global
/// placeholder referring to the state, province, or the particular term a
/// country uses to define the geographic structure below the country level,
/// for example, "CA", "IL".
/// * city: histogram by a combination of the "city name, admin1 code". For
/// example, "Mountain View, CA", "New York, NY".
/// * admin1_country: histogram by a combination of the "admin1 code, country",
/// for example, "CA, US", "IL, US".
/// * city_coordinate: histogram by the city center's GPS coordinates (latitude
/// and longitude), for example, 37.4038522,-122.0987765. Since the
/// coordinates of a city center can change, customers may need to refresh
/// them periodically.
/// * locale: histogram by the \[Job.language_code][google.cloud.talent.v4beta1.Job.language_code\], for example, "en-US",
/// "fr-FR".
/// * language: histogram by the language subtag of the \[Job.language_code][google.cloud.talent.v4beta1.Job.language_code\],
/// for example, "en", "fr".
/// * category: histogram by the \[JobCategory][google.cloud.talent.v4beta1.JobCategory\], for example,
/// "COMPUTER_AND_IT", "HEALTHCARE".
/// * base_compensation_unit: histogram by the
/// \[CompensationInfo.CompensationUnit][google.cloud.talent.v4beta1.CompensationInfo.CompensationUnit\] of base
/// salary, for example, "WEEKLY", "MONTHLY".
/// * base_compensation: histogram by the base salary. Must specify list of
/// numeric buckets to group results by.
/// * annualized_base_compensation: histogram by the base annualized salary.
/// Must specify list of numeric buckets to group results by.
/// * annualized_total_compensation: histogram by the total annualized salary.
/// Must specify list of numeric buckets to group results by.
/// * string_custom_attribute: histogram by string \[Job.custom_attributes][google.cloud.talent.v4beta1.Job.custom_attributes\].
/// Values can be accessed via square bracket notations like
/// string_custom_attribute\["key1"\].
/// * numeric_custom_attribute: histogram by numeric \[Job.custom_attributes][google.cloud.talent.v4beta1.Job.custom_attributes\].
/// Values can be accessed via square bracket notations like
/// numeric_custom_attribute\["key1"\]. Must specify list of numeric buckets to
/// group results by.
///
/// Example expressions:
///
/// * `count(admin1)`
/// * `count(base_compensation, [bucket(1000, 10000), bucket(10000, 100000),
/// bucket(100000, MAX)])`
/// * `count(string_custom_attribute\["some-string-custom-attribute"\])`
/// * `count(numeric_custom_attribute\["some-numeric-custom-attribute"\],
/// [bucket(MIN, 0, "negative"), bucket(0, MAX, "non-negative"])`
#[prost(message, repeated, tag = "7")]
pub histogram_queries: ::prost::alloc::vec::Vec<HistogramQuery>,
/// The desired job attributes returned for jobs in the search response.
/// Defaults to \[JobView.JOB_VIEW_SMALL][google.cloud.talent.v4beta1.JobView.JOB_VIEW_SMALL\] if no value is specified.
#[prost(enumeration = "JobView", tag = "8")]
pub job_view: i32,
/// An integer that specifies the current offset (that is, starting result
/// location, amongst the jobs deemed by the API as relevant) in search
/// results. This field is only considered if \[page_token][google.cloud.talent.v4beta1.SearchJobsRequest.page_token\] is unset.
///
/// The maximum allowed value is 5000. Otherwise an error is thrown.
///
/// For example, 0 means to return results starting from the first matching
/// job, and 10 means to return from the 11th job. This can be used for
/// pagination, (for example, pageSize = 10 and offset = 10 means to return
/// from the second page).
#[prost(int32, tag = "9")]
pub offset: i32,
/// A limit on the number of jobs returned in the search results.
/// Increasing this value above the default value of 10 can increase search
/// response time. The value can be between 1 and 100.
#[prost(int32, tag = "10")]
pub page_size: i32,
/// The token specifying the current offset within
/// search results. See \[SearchJobsResponse.next_page_token][google.cloud.talent.v4beta1.SearchJobsResponse.next_page_token\] for
/// an explanation of how to obtain the next set of query results.
#[prost(string, tag = "11")]
pub page_token: ::prost::alloc::string::String,
/// The criteria determining how search results are sorted. Default is
/// `"relevance desc"`.
///
/// Supported options are:
///
/// * `"relevance desc"`: By relevance descending, as determined by the API
/// algorithms. Relevance thresholding of query results is only available
/// with this ordering.
/// * `"posting_publish_time desc"`: By \[Job.posting_publish_time][google.cloud.talent.v4beta1.Job.posting_publish_time\]
/// descending.
/// * `"posting_update_time desc"`: By \[Job.posting_update_time][google.cloud.talent.v4beta1.Job.posting_update_time\]
/// descending.
/// * `"title"`: By \[Job.title][google.cloud.talent.v4beta1.Job.title\] ascending.
/// * `"title desc"`: By \[Job.title][google.cloud.talent.v4beta1.Job.title\] descending.
/// * `"annualized_base_compensation"`: By job's
/// \[CompensationInfo.annualized_base_compensation_range][google.cloud.talent.v4beta1.CompensationInfo.annualized_base_compensation_range\] ascending. Jobs
/// whose annualized base compensation is unspecified are put at the end of
/// search results.
/// * `"annualized_base_compensation desc"`: By job's
/// \[CompensationInfo.annualized_base_compensation_range][google.cloud.talent.v4beta1.CompensationInfo.annualized_base_compensation_range\] descending. Jobs
/// whose annualized base compensation is unspecified are put at the end of
/// search results.
/// * `"annualized_total_compensation"`: By job's
/// \[CompensationInfo.annualized_total_compensation_range][google.cloud.talent.v4beta1.CompensationInfo.annualized_total_compensation_range\] ascending. Jobs
/// whose annualized base compensation is unspecified are put at the end of
/// search results.
/// * `"annualized_total_compensation desc"`: By job's
/// \[CompensationInfo.annualized_total_compensation_range][google.cloud.talent.v4beta1.CompensationInfo.annualized_total_compensation_range\] descending. Jobs
/// whose annualized base compensation is unspecified are put at the end of
/// search results.
/// * `"custom_ranking desc"`: By the relevance score adjusted to the
/// \[SearchJobsRequest.CustomRankingInfo.ranking_expression][google.cloud.talent.v4beta1.SearchJobsRequest.CustomRankingInfo.ranking_expression\] with weight
/// factor assigned by
/// \[SearchJobsRequest.CustomRankingInfo.importance_level][google.cloud.talent.v4beta1.SearchJobsRequest.CustomRankingInfo.importance_level\] in descending
/// order.
/// * Location sorting: Use the special syntax to order jobs by distance:<br>
/// `"distance_from('Hawaii')"`: Order by distance from Hawaii.<br>
/// `"distance_from(19.89, 155.5)"`: Order by distance from a coordinate.<br>
/// `"distance_from('Hawaii'), distance_from('Puerto Rico')"`: Order by
/// multiple locations. See details below.<br>
/// `"distance_from('Hawaii'), distance_from(19.89, 155.5)"`: Order by
/// multiple locations. See details below.<br>
/// The string can have a maximum of 256 characters. When multiple distance
/// centers are provided, a job that is close to any of the distance centers
/// would have a high rank. When a job has multiple locations, the job
/// location closest to one of the distance centers will be used. Jobs that
/// don't have locations will be ranked at the bottom. Distance is calculated
/// with a precision of 11.3 meters (37.4 feet). Diversification strategy is
/// still applied unless explicitly disabled in
/// \[diversification_level][google.cloud.talent.v4beta1.SearchJobsRequest.diversification_level\].
#[prost(string, tag = "12")]
pub order_by: ::prost::alloc::string::String,
/// Controls whether highly similar jobs are returned next to each other in
/// the search results. Jobs are identified as highly similar based on
/// their titles, job categories, and locations. Highly similar results are
/// clustered so that only one representative job of the cluster is
/// displayed to the job seeker higher up in the results, with the other jobs
/// being displayed lower down in the results.
///
/// Defaults to \[DiversificationLevel.SIMPLE][google.cloud.talent.v4beta1.SearchJobsRequest.DiversificationLevel.SIMPLE\] if no value
/// is specified.
#[prost(enumeration = "search_jobs_request::DiversificationLevel", tag = "13")]
pub diversification_level: i32,
/// Controls over how job documents get ranked on top of existing relevance
/// score (determined by API algorithm).
#[prost(message, optional, tag = "14")]
pub custom_ranking_info: ::core::option::Option<search_jobs_request::CustomRankingInfo>,
/// Controls whether to disable exact keyword match on \[Job.title][google.cloud.talent.v4beta1.Job.title\],
/// \[Job.description][google.cloud.talent.v4beta1.Job.description\], \[Job.company_display_name][google.cloud.talent.v4beta1.Job.company_display_name\], \[Job.addresses][google.cloud.talent.v4beta1.Job.addresses\],
/// \[Job.qualifications][google.cloud.talent.v4beta1.Job.qualifications\]. When disable keyword match is turned off, a
/// keyword match returns jobs that do not match given category filters when
/// there are matching keywords. For example, for the query "program manager,"
/// a result is returned even if the job posting has the title "software
/// developer," which doesn't fall into "program manager" ontology, but does
/// have "program manager" appearing in its description.
///
/// For queries like "cloud" that don't contain title or
/// location specific ontology, jobs with "cloud" keyword matches are returned
/// regardless of this flag's value.
///
/// Use \[Company.keyword_searchable_job_custom_attributes][google.cloud.talent.v4beta1.Company.keyword_searchable_job_custom_attributes\] if
/// company-specific globally matched custom field/attribute string values are
/// needed. Enabling keyword match improves recall of subsequent search
/// requests.
///
/// Defaults to false.
#[prost(bool, tag = "16")]
pub disable_keyword_match: bool,
}
/// Nested message and enum types in `SearchJobsRequest`.
pub mod search_jobs_request {
/// Custom ranking information for \[SearchJobsRequest][google.cloud.talent.v4beta1.SearchJobsRequest\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CustomRankingInfo {
/// Required. Controls over how important the score of
/// \[CustomRankingInfo.ranking_expression][google.cloud.talent.v4beta1.SearchJobsRequest.CustomRankingInfo.ranking_expression\] gets applied to job's final
/// ranking position.
///
/// An error is thrown if not specified.
#[prost(enumeration = "custom_ranking_info::ImportanceLevel", tag = "1")]
pub importance_level: i32,
/// Required. Controls over how job documents get ranked on top of existing relevance
/// score (determined by API algorithm). A combination of the ranking
/// expression and relevance score is used to determine job's final ranking
/// position.
///
/// The syntax for this expression is a subset of Google SQL syntax.
///
/// Supported operators are: +, -, *, /, where the left and right side of
/// the operator is either a numeric \[Job.custom_attributes][google.cloud.talent.v4beta1.Job.custom_attributes\] key,
/// integer/double value or an expression that can be evaluated to a number.
///
/// Parenthesis are supported to adjust calculation precedence. The
/// expression must be < 100 characters in length.
///
/// The expression is considered invalid for a job if the expression
/// references custom attributes that are not populated on the job or if the
/// expression results in a divide by zero. If an expression is invalid for a
/// job, that job is demoted to the end of the results.
///
/// Sample ranking expression
/// (year + 25) * 0.25 - (freshness / 0.5)
#[prost(string, tag = "2")]
pub ranking_expression: ::prost::alloc::string::String,
}
/// Nested message and enum types in `CustomRankingInfo`.
pub mod custom_ranking_info {
/// The importance level for \[CustomRankingInfo.ranking_expression][google.cloud.talent.v4beta1.SearchJobsRequest.CustomRankingInfo.ranking_expression\].
#[derive(
Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
)]
#[repr(i32)]
pub enum ImportanceLevel {
/// Default value if the importance level isn't specified.
Unspecified = 0,
/// The given ranking expression is of None importance, existing relevance
/// score (determined by API algorithm) dominates job's final ranking
/// position.
None = 1,
/// The given ranking expression is of Low importance in terms of job's
/// final ranking position compared to existing relevance
/// score (determined by API algorithm).
Low = 2,
/// The given ranking expression is of Mild importance in terms of job's
/// final ranking position compared to existing relevance
/// score (determined by API algorithm).
Mild = 3,
/// The given ranking expression is of Medium importance in terms of job's
/// final ranking position compared to existing relevance
/// score (determined by API algorithm).
Medium = 4,
/// The given ranking expression is of High importance in terms of job's
/// final ranking position compared to existing relevance
/// score (determined by API algorithm).
High = 5,
/// The given ranking expression is of Extreme importance, and dominates
/// job's final ranking position with existing relevance
/// score (determined by API algorithm) ignored.
Extreme = 6,
}
}
/// A string-represented enumeration of the job search mode. The service
/// operate differently for different modes of service.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SearchMode {
/// The mode of the search method isn't specified. The default search
/// behavior is identical to JOB_SEARCH search behavior.
Unspecified = 0,
/// The job search matches against all jobs, and featured jobs
/// (jobs with promotionValue > 0) are not specially handled.
JobSearch = 1,
/// The job search matches only against featured jobs (jobs with a
/// promotionValue > 0). This method doesn't return any jobs having a
/// promotionValue <= 0. The search results order is determined by the
/// promotionValue (jobs with a higher promotionValue are returned higher up
/// in the search results), with relevance being used as a tiebreaker.
FeaturedJobSearch = 2,
}
/// Controls whether highly similar jobs are returned next to each other in
/// the search results. Jobs are identified as highly similar based on
/// their titles, job categories, and locations. Highly similar results are
/// clustered so that only one representative job of the cluster is
/// displayed to the job seeker higher up in the results, with the other jobs
/// being displayed lower down in the results.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum DiversificationLevel {
/// The diversification level isn't specified.
Unspecified = 0,
/// Disables diversification. Jobs that would normally be pushed to the last
/// page would not have their positions altered. This may result in highly
/// similar jobs appearing in sequence in the search results.
Disabled = 1,
/// Default diversifying behavior. The result list is ordered so that
/// highly similar results are pushed to the end of the last page of search
/// results. If you are using pageToken to page through the result set,
/// latency might be lower but we can't guarantee that all results are
/// returned. If you are using page offset, latency might be higher but all
/// results are returned.
Simple = 2,
}
}
/// Response for SearchJob method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SearchJobsResponse {
/// The Job entities that match the specified \[SearchJobsRequest][google.cloud.talent.v4beta1.SearchJobsRequest\].
#[prost(message, repeated, tag = "1")]
pub matching_jobs: ::prost::alloc::vec::Vec<search_jobs_response::MatchingJob>,
/// The histogram results that match with specified
/// \[SearchJobsRequest.histogram_queries][google.cloud.talent.v4beta1.SearchJobsRequest.histogram_queries\].
#[prost(message, repeated, tag = "2")]
pub histogram_query_results: ::prost::alloc::vec::Vec<HistogramQueryResult>,
/// The token that specifies the starting position of the next page of results.
/// This field is empty if there are no more results.
#[prost(string, tag = "3")]
pub next_page_token: ::prost::alloc::string::String,
/// The location filters that the service applied to the specified query. If
/// any filters are lat-lng based, the \[Location.location_type][google.cloud.talent.v4beta1.Location.location_type\] is
/// \[Location.LocationType.LOCATION_TYPE_UNSPECIFIED][google.cloud.talent.v4beta1.Location.LocationType.LOCATION_TYPE_UNSPECIFIED\].
#[prost(message, repeated, tag = "4")]
pub location_filters: ::prost::alloc::vec::Vec<Location>,
/// An estimation of the number of jobs that match the specified query.
///
/// This number isn't guaranteed to be accurate. For accurate results,
/// see \[SearchJobsRequest.require_precise_result_size][google.cloud.talent.v4beta1.SearchJobsRequest.require_precise_result_size\].
#[prost(int32, tag = "5")]
pub estimated_total_size: i32,
/// The precise result count, which is available only if the client set
/// \[SearchJobsRequest.require_precise_result_size][google.cloud.talent.v4beta1.SearchJobsRequest.require_precise_result_size\] to `true`, or if the
/// response is the last page of results. Otherwise, the value is `-1`.
#[prost(int32, tag = "6")]
pub total_size: i32,
/// Additional information for the API invocation, such as the request
/// tracking id.
#[prost(message, optional, tag = "7")]
pub metadata: ::core::option::Option<ResponseMetadata>,
/// If query broadening is enabled, we may append additional results from the
/// broadened query. This number indicates how many of the jobs returned in the
/// jobs field are from the broadened query. These results are always at the
/// end of the jobs list. In particular, a value of 0, or if the field isn't
/// set, all the jobs in the jobs list are from the original
/// (without broadening) query. If this field is non-zero, subsequent requests
/// with offset after this result set should contain all broadened results.
#[prost(int32, tag = "8")]
pub broadened_query_jobs_count: i32,
/// The spell checking result, and correction.
#[prost(message, optional, tag = "9")]
pub spell_correction: ::core::option::Option<SpellingCorrection>,
}
/// Nested message and enum types in `SearchJobsResponse`.
pub mod search_jobs_response {
/// Job entry with metadata inside \[SearchJobsResponse][google.cloud.talent.v4beta1.SearchJobsResponse\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MatchingJob {
/// Job resource that matches the specified \[SearchJobsRequest][google.cloud.talent.v4beta1.SearchJobsRequest\].
#[prost(message, optional, tag = "1")]
pub job: ::core::option::Option<super::Job>,
/// A summary of the job with core information that's displayed on the search
/// results listing page.
#[prost(string, tag = "2")]
pub job_summary: ::prost::alloc::string::String,
/// Contains snippets of text from the \[Job.title][google.cloud.talent.v4beta1.Job.title\] field most
/// closely matching a search query's keywords, if available. The matching
/// query keywords are enclosed in HTML bold tags.
#[prost(string, tag = "3")]
pub job_title_snippet: ::prost::alloc::string::String,
/// Contains snippets of text from the \[Job.description][google.cloud.talent.v4beta1.Job.description\] and similar
/// fields that most closely match a search query's keywords, if available.
/// All HTML tags in the original fields are stripped when returned in this
/// field, and matching query keywords are enclosed in HTML bold tags.
#[prost(string, tag = "4")]
pub search_text_snippet: ::prost::alloc::string::String,
/// Commute information which is generated based on specified
/// \[CommuteFilter][google.cloud.talent.v4beta1.CommuteFilter\].
#[prost(message, optional, tag = "5")]
pub commute_info: ::core::option::Option<CommuteInfo>,
}
/// Commute details related to this job.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CommuteInfo {
/// Location used as the destination in the commute calculation.
#[prost(message, optional, tag = "1")]
pub job_location: ::core::option::Option<super::Location>,
/// The number of seconds required to travel to the job location from the
/// query location. A duration of 0 seconds indicates that the job isn't
/// reachable within the requested duration, but was returned as part of an
/// expanded query.
#[prost(message, optional, tag = "2")]
pub travel_duration: ::core::option::Option<::prost_types::Duration>,
}
}
/// Request to create a batch of jobs.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchCreateJobsRequest {
/// Required. The resource name of the tenant under which the job is created.
///
/// The format is "projects/{project_id}/tenants/{tenant_id}". For example,
/// "projects/foo/tenant/bar". If tenant id is unspecified, a default tenant
/// is created. For example, "projects/foo".
#[prost(string, tag = "1")]
pub parent: ::prost::alloc::string::String,
/// Required. The jobs to be created.
#[prost(message, repeated, tag = "2")]
pub jobs: ::prost::alloc::vec::Vec<Job>,
}
/// Request to update a batch of jobs.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchUpdateJobsRequest {
/// Required. The resource name of the tenant under which the job is created.
///
/// The format is "projects/{project_id}/tenants/{tenant_id}". For example,
/// "projects/foo/tenant/bar". If tenant id is unspecified, a default tenant
/// is created. For example, "projects/foo".
#[prost(string, tag = "1")]
pub parent: ::prost::alloc::string::String,
/// Required. The jobs to be updated.
#[prost(message, repeated, tag = "2")]
pub jobs: ::prost::alloc::vec::Vec<Job>,
/// Strongly recommended for the best service experience. Be aware that it will
/// also increase latency when checking the status of a batch operation.
///
/// If \[update_mask][google.cloud.talent.v4beta1.BatchUpdateJobsRequest.update_mask\] is provided, only the specified fields in
/// \[Job][google.cloud.talent.v4beta1.Job\] are updated. Otherwise all the fields are updated.
///
/// A field mask to restrict the fields that are updated. Only
/// top level fields of \[Job][google.cloud.talent.v4beta1.Job\] are supported.
///
/// If \[update_mask][google.cloud.talent.v4beta1.BatchUpdateJobsRequest.update_mask\] is provided, The \[Job][google.cloud.talent.v4beta1.Job\] inside
/// \[JobResult][google.cloud.talent.v4beta1.JobOperationResult.JobResult\]
/// will only contains fields that is updated, plus the Id of the Job.
/// Otherwise, \[Job][google.cloud.talent.v4beta1.Job\] will include all fields, which can yield a very
/// large response.
#[prost(message, optional, tag = "3")]
pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// The result of \[JobService.BatchCreateJobs][google.cloud.talent.v4beta1.JobService.BatchCreateJobs\] or
/// \[JobService.BatchUpdateJobs][google.cloud.talent.v4beta1.JobService.BatchUpdateJobs\] APIs. It's used to
/// replace \[google.longrunning.Operation.response][google.longrunning.Operation.response\] in case of success.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct JobOperationResult {
/// List of job mutation results from a batch mutate operation. It can change
/// until operation status is FINISHED, FAILED or CANCELLED.
#[prost(message, repeated, tag = "1")]
pub job_results: ::prost::alloc::vec::Vec<job_operation_result::JobResult>,
}
/// Nested message and enum types in `JobOperationResult`.
pub mod job_operation_result {
/// Mutation result of a job.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct JobResult {
/// Here \[Job][google.cloud.talent.v4beta1.Job\] only contains basic information including \[name][google.cloud.talent.v4beta1.Job.name\],
/// \[company][google.cloud.talent.v4beta1.Job.company\], \[language_code][google.cloud.talent.v4beta1.Job.language_code\]
/// and \[requisition_id][google.cloud.talent.v4beta1.Job.requisition_id\], use getJob method to retrieve
/// detailed information of the created/updated job.
#[prost(message, optional, tag = "1")]
pub job: ::core::option::Option<super::Job>,
/// The status of the job processed. This field is populated if the
/// processing of the \[job][google.cloud.talent.v4beta1.JobOperationResult.JobResult.job\] fails.
#[prost(message, optional, tag = "2")]
pub status: ::core::option::Option<super::super::super::super::rpc::Status>,
}
}
/// An enum that specifies the job attributes that are returned in the
/// \[MatchingJob.job][google.cloud.talent.v4beta1.SearchJobsResponse.MatchingJob.job\] or
/// \[ListJobsResponse.jobs][google.cloud.talent.v4beta1.ListJobsResponse.jobs\] fields.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum JobView {
/// Default value.
Unspecified = 0,
/// A ID only view of job, with following attributes:
/// \[Job.name][google.cloud.talent.v4beta1.Job.name\], \[Job.requisition_id][google.cloud.talent.v4beta1.Job.requisition_id\], \[Job.language_code][google.cloud.talent.v4beta1.Job.language_code\].
IdOnly = 1,
/// A minimal view of the job, with the following attributes:
/// \[Job.name][google.cloud.talent.v4beta1.Job.name\], \[Job.requisition_id][google.cloud.talent.v4beta1.Job.requisition_id\], \[Job.title][google.cloud.talent.v4beta1.Job.title\],
/// \[Job.company][google.cloud.talent.v4beta1.Job.company\], \[Job.DerivedInfo.locations][google.cloud.talent.v4beta1.Job.DerivedInfo.locations\], \[Job.language_code][google.cloud.talent.v4beta1.Job.language_code\].
Minimal = 2,
/// A small view of the job, with the following attributes in the search
/// results: \[Job.name][google.cloud.talent.v4beta1.Job.name\], \[Job.requisition_id][google.cloud.talent.v4beta1.Job.requisition_id\], \[Job.title][google.cloud.talent.v4beta1.Job.title\],
/// \[Job.company][google.cloud.talent.v4beta1.Job.company\], \[Job.DerivedInfo.locations][google.cloud.talent.v4beta1.Job.DerivedInfo.locations\], \[Job.visibility][google.cloud.talent.v4beta1.Job.visibility\],
/// \[Job.language_code][google.cloud.talent.v4beta1.Job.language_code\], \[Job.description][google.cloud.talent.v4beta1.Job.description\].
Small = 3,
/// All available attributes are included in the search results.
Full = 4,
}
#[doc = r" Generated client implementations."]
pub mod job_service_client {
#![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
use tonic::codegen::*;
#[doc = " A service handles job management, including job CRUD, enumeration and search."]
#[derive(Debug, Clone)]
pub struct JobServiceClient<T> {
inner: tonic::client::Grpc<T>,
}
impl<T> JobServiceClient<T>
where
T: tonic::client::GrpcService<tonic::body::BoxBody>,
T::ResponseBody: Body + Send + 'static,
T::Error: Into<StdError>,
<T::ResponseBody as Body>::Error: Into<StdError> + Send,
{
pub fn new(inner: T) -> Self {
let inner = tonic::client::Grpc::new(inner);
Self { inner }
}
pub fn with_interceptor<F>(
inner: T,
interceptor: F,
) -> JobServiceClient<InterceptedService<T, F>>
where
F: tonic::service::Interceptor,
T: tonic::codegen::Service<
http::Request<tonic::body::BoxBody>,
Response = http::Response<
<T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
>,
>,
<T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
Into<StdError> + Send + Sync,
{
JobServiceClient::new(InterceptedService::new(inner, interceptor))
}
#[doc = r" Compress requests with `gzip`."]
#[doc = r""]
#[doc = r" This requires the server to support it otherwise it might respond with an"]
#[doc = r" error."]
pub fn send_gzip(mut self) -> Self {
self.inner = self.inner.send_gzip();
self
}
#[doc = r" Enable decompressing responses with `gzip`."]
pub fn accept_gzip(mut self) -> Self {
self.inner = self.inner.accept_gzip();
self
}
#[doc = " Creates a new job."]
#[doc = ""]
#[doc = " Typically, the job becomes searchable within 10 seconds, but it may take"]
#[doc = " up to 5 minutes."]
pub async fn create_job(
&mut self,
request: impl tonic::IntoRequest<super::CreateJobRequest>,
) -> Result<tonic::Response<super::Job>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.talent.v4beta1.JobService/CreateJob",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Begins executing a batch create jobs operation."]
pub async fn batch_create_jobs(
&mut self,
request: impl tonic::IntoRequest<super::BatchCreateJobsRequest>,
) -> Result<
tonic::Response<super::super::super::super::longrunning::Operation>,
tonic::Status,
> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.talent.v4beta1.JobService/BatchCreateJobs",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Retrieves the specified job, whose status is OPEN or recently EXPIRED"]
#[doc = " within the last 90 days."]
pub async fn get_job(
&mut self,
request: impl tonic::IntoRequest<super::GetJobRequest>,
) -> Result<tonic::Response<super::Job>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.talent.v4beta1.JobService/GetJob",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Updates specified job."]
#[doc = ""]
#[doc = " Typically, updated contents become visible in search results within 10"]
#[doc = " seconds, but it may take up to 5 minutes."]
pub async fn update_job(
&mut self,
request: impl tonic::IntoRequest<super::UpdateJobRequest>,
) -> Result<tonic::Response<super::Job>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.talent.v4beta1.JobService/UpdateJob",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Begins executing a batch update jobs operation."]
pub async fn batch_update_jobs(
&mut self,
request: impl tonic::IntoRequest<super::BatchUpdateJobsRequest>,
) -> Result<
tonic::Response<super::super::super::super::longrunning::Operation>,
tonic::Status,
> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.talent.v4beta1.JobService/BatchUpdateJobs",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Deletes the specified job."]
#[doc = ""]
#[doc = " Typically, the job becomes unsearchable within 10 seconds, but it may take"]
#[doc = " up to 5 minutes."]
pub async fn delete_job(
&mut self,
request: impl tonic::IntoRequest<super::DeleteJobRequest>,
) -> Result<tonic::Response<()>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.talent.v4beta1.JobService/DeleteJob",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Deletes a list of [Job][google.cloud.talent.v4beta1.Job]s by filter."]
pub async fn batch_delete_jobs(
&mut self,
request: impl tonic::IntoRequest<super::BatchDeleteJobsRequest>,
) -> Result<tonic::Response<()>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.talent.v4beta1.JobService/BatchDeleteJobs",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Lists jobs by filter."]
pub async fn list_jobs(
&mut self,
request: impl tonic::IntoRequest<super::ListJobsRequest>,
) -> Result<tonic::Response<super::ListJobsResponse>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.talent.v4beta1.JobService/ListJobs",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Searches for jobs using the provided [SearchJobsRequest][google.cloud.talent.v4beta1.SearchJobsRequest]."]
#[doc = ""]
#[doc = " This call constrains the [visibility][google.cloud.talent.v4beta1.Job.visibility] of jobs"]
#[doc = " present in the database, and only returns jobs that the caller has"]
#[doc = " permission to search against."]
pub async fn search_jobs(
&mut self,
request: impl tonic::IntoRequest<super::SearchJobsRequest>,
) -> Result<tonic::Response<super::SearchJobsResponse>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.talent.v4beta1.JobService/SearchJobs",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Searches for jobs using the provided [SearchJobsRequest][google.cloud.talent.v4beta1.SearchJobsRequest]."]
#[doc = ""]
#[doc = " This API call is intended for the use case of targeting passive job"]
#[doc = " seekers (for example, job seekers who have signed up to receive email"]
#[doc = " alerts about potential job opportunities), and has different algorithmic"]
#[doc = " adjustments that are targeted to passive job seekers."]
#[doc = ""]
#[doc = " This call constrains the [visibility][google.cloud.talent.v4beta1.Job.visibility] of jobs"]
#[doc = " present in the database, and only returns jobs the caller has"]
#[doc = " permission to search against."]
pub async fn search_jobs_for_alert(
&mut self,
request: impl tonic::IntoRequest<super::SearchJobsRequest>,
) -> Result<tonic::Response<super::SearchJobsResponse>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.talent.v4beta1.JobService/SearchJobsForAlert",
);
self.inner.unary(request.into_request(), path, codec).await
}
}
} // Cloud Profile Discovery API definition
/// A resource that represents the profile for a job candidate (also referred to
/// as a "single-source profile").
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Profile {
/// Required during profile update.
///
/// Resource name assigned to a profile by the API.
///
/// The format is
/// "projects/{project_id}/tenants/{tenant_id}/profiles/{profile_id}",
/// for example, "projects/foo/tenants/bar/profiles/baz".
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
/// Profile's id in client system, if available. This value is unique for each
/// profile inside a tenant. An error is thrown if another profile with the
/// same external_id is created.
///
/// The maximum number of bytes allowed is 100.
#[prost(string, tag = "2")]
pub external_id: ::prost::alloc::string::String,
/// The source description indicating where the profile is acquired.
///
/// For example, if a candidate profile is acquired from a resume, the user can
/// input "resume" here to indicate the source.
///
/// The maximum number of bytes allowed is 100.
#[prost(string, tag = "3")]
pub source: ::prost::alloc::string::String,
/// The URI set by clients that links to this profile's client-side copy.
///
/// The maximum number of bytes allowed is 4000.
#[prost(string, tag = "4")]
pub uri: ::prost::alloc::string::String,
/// The cluster id of the profile to associate with other profile(s) for the
/// same candidate.
///
/// This field should be generated by the customer. If a value is not provided,
/// a random UUID is assigned to this field of the profile.
///
/// This is used to link multiple profiles to the same candidate. For example,
/// a client has a candidate with two profiles, where one was created recently
/// and the other one was created 5 years ago. These two profiles may be very
/// different. The clients can create the first profile and get a generated
/// \[group_id][google.cloud.talent.v4beta1.Profile.group_id\], and assign it when the second profile is created,
/// indicating these two profiles are referring to the same candidate.
#[prost(string, tag = "5")]
pub group_id: ::prost::alloc::string::String,
/// Indicates the hirable status of the candidate.
#[prost(message, optional, tag = "6")]
pub is_hirable: ::core::option::Option<bool>,
/// The timestamp when the profile was first created at this source.
#[prost(message, optional, tag = "7")]
pub create_time: ::core::option::Option<::prost_types::Timestamp>,
/// The timestamp when the profile was last updated at this source.
#[prost(message, optional, tag = "8")]
pub update_time: ::core::option::Option<::prost_types::Timestamp>,
/// The timestamp when the profile was last updated as a result of a direct or
/// indirect action by a candidate.
///
/// These actions include:
///
/// * Direct actions such as the candidate submitting a new resume as part of a
/// job application to the agency, using a self-service tool such as a website
/// to update their profile, and so on.
/// * Indirect actions by the candidate such as uploading a resume to a job
/// board that is collected by the agency through a feed, providing a resume to
/// a recruiter who then uploads it into the ATS, and so on.
/// * Updates made to the candidate's profile by the recruiter as a result of
/// interacting with the candidate (for example adding a skill or work
/// preference, and so on). Changes to \[recruiting_notes][google.cloud.talent.v4beta1.Profile.recruiting_notes\] are specifically
/// excluded from this action type.
///
/// Note: \[candidate_update_time][google.cloud.talent.v4beta1.Profile.candidate_update_time\] must be greater than or equal to
/// \[resume_update_time][google.cloud.talent.v4beta1.Profile.resume_update_time\] or an error is thrown.
#[prost(message, optional, tag = "67")]
pub candidate_update_time: ::core::option::Option<::prost_types::Timestamp>,
/// The timestamp when the candidate's resume was added or updated on the
/// candidate's profile. Whether that resume was directly uploaded by a
/// candidate, pulled from a 3rd party job board feed, added by a recruiter,
/// and so on.
///
/// If this field is updated, it's expected that \[resume][google.cloud.talent.v4beta1.Profile.resume\] is provided in
/// the create or update calls.
#[prost(message, optional, tag = "68")]
pub resume_update_time: ::core::option::Option<::prost_types::Timestamp>,
/// The resume representing this profile.
#[prost(message, optional, tag = "53")]
pub resume: ::core::option::Option<Resume>,
/// The names of the candidate this profile references.
///
/// Currently only one person name is supported.
#[prost(message, repeated, tag = "11")]
pub person_names: ::prost::alloc::vec::Vec<PersonName>,
/// The candidate's postal addresses. It's highly recommended to
/// input this information as accurately as possible to help improve search
/// quality. Here are some recommendations:
///
/// * Provide \[Address.usage][google.cloud.talent.v4beta1.Address.usage\] if possible, especially if the address is
/// PERSONAL. During a search only personal addresses are considered. If there
/// is no such address, all addresses with unspecified usage are assumed to be
/// personal.
/// * Provide \[Address.current][google.cloud.talent.v4beta1.Address.current\] for the current address if possible. During
/// a search, only current addresses are considered. If there is no such
/// address, all addresses are assumed to be current.
///
/// When displaying a candidate's addresses, it is sometimes desirable to limit
/// the number of addresses shown. In these cases we recommend that you display
/// the addresses in the following order of priority:
/// 1. \[Address.usage][google.cloud.talent.v4beta1.Address.usage\] is PERSONAL and \[Address.current][google.cloud.talent.v4beta1.Address.current\] is true.
/// 2. \[Address.usage][google.cloud.talent.v4beta1.Address.usage\] is PERSONAL and \[Address.current][google.cloud.talent.v4beta1.Address.current\] is false or not
/// set.
/// 3. \[Address.usage][google.cloud.talent.v4beta1.Address.usage\] is CONTACT_INFO_USAGE_UNSPECIFIED and
/// \[Address.current][google.cloud.talent.v4beta1.Address.current\] is true.
/// 4. \[Address.usage][google.cloud.talent.v4beta1.Address.usage\] is CONTACT_INFO_USAGE_UNSPECIFIED and
/// \[Address.current][google.cloud.talent.v4beta1.Address.current\] is false or not set.
#[prost(message, repeated, tag = "12")]
pub addresses: ::prost::alloc::vec::Vec<Address>,
/// The candidate's email addresses.
#[prost(message, repeated, tag = "13")]
pub email_addresses: ::prost::alloc::vec::Vec<Email>,
/// The candidate's phone number(s).
#[prost(message, repeated, tag = "14")]
pub phone_numbers: ::prost::alloc::vec::Vec<Phone>,
/// The candidate's personal URIs.
#[prost(message, repeated, tag = "15")]
pub personal_uris: ::prost::alloc::vec::Vec<PersonalUri>,
/// Available contact information besides \[addresses][google.cloud.talent.v4beta1.Profile.addresses\], \[email_addresses][google.cloud.talent.v4beta1.Profile.email_addresses\],
/// \[phone_numbers][google.cloud.talent.v4beta1.Profile.phone_numbers\] and \[personal_uris][google.cloud.talent.v4beta1.Profile.personal_uris\]. For example, Hang-out, Skype.
#[prost(message, repeated, tag = "16")]
pub additional_contact_info: ::prost::alloc::vec::Vec<AdditionalContactInfo>,
/// The employment history records of the candidate. It's highly recommended
/// to input this information as accurately as possible to help improve search
/// quality. Here are some recommendations:
///
/// * Specify the start and end dates of the employment records.
/// * List different employment types separately, no matter how minor the
/// change is.
/// For example, only job title is changed from "software engineer" to "senior
/// software engineer".
/// * Provide \[EmploymentRecord.is_current][google.cloud.talent.v4beta1.EmploymentRecord.is_current\] for the current employment if
/// possible. If not, it's inferred from user inputs.
///
/// The limitation for max number of employment records is 100.
#[prost(message, repeated, tag = "17")]
pub employment_records: ::prost::alloc::vec::Vec<EmploymentRecord>,
/// The education history record of the candidate. It's highly recommended to
/// input this information as accurately as possible to help improve search
/// quality. Here are some recommendations:
///
/// * Specify the start and end dates of the education records.
/// * List each education type separately, no matter how minor the change is.
/// For example, the profile contains the education experience from the same
/// school but different degrees.
/// * Provide \[EducationRecord.is_current][google.cloud.talent.v4beta1.EducationRecord.is_current\] for the current education if
/// possible. If not, it's inferred from user inputs.
///
/// The limitation for max number of education records is 100.
#[prost(message, repeated, tag = "18")]
pub education_records: ::prost::alloc::vec::Vec<EducationRecord>,
/// The skill set of the candidate. It's highly recommended to provide as
/// much information as possible to help improve the search quality.
///
/// The limitation for max number of skills is 500.
#[prost(message, repeated, tag = "19")]
pub skills: ::prost::alloc::vec::Vec<Skill>,
/// The individual or collaborative activities which the candidate has
/// participated in, for example, open-source projects, class assignments that
/// aren't listed in \[employment_records][google.cloud.talent.v4beta1.Profile.employment_records\].
///
/// The limitation for max number of activities is 50.
#[prost(message, repeated, tag = "20")]
pub activities: ::prost::alloc::vec::Vec<Activity>,
/// The publications published by the candidate.
///
/// The limitation for max number of publications is 50.
#[prost(message, repeated, tag = "21")]
pub publications: ::prost::alloc::vec::Vec<Publication>,
/// The patents acquired by the candidate.
#[prost(message, repeated, tag = "22")]
pub patents: ::prost::alloc::vec::Vec<Patent>,
/// The certifications acquired by the candidate.
#[prost(message, repeated, tag = "23")]
pub certifications: ::prost::alloc::vec::Vec<Certification>,
/// Output only. The resource names of the candidate's applications.
#[prost(string, repeated, tag = "47")]
pub applications: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
/// Output only. The resource names of the candidate's assignments.
#[prost(string, repeated, tag = "48")]
pub assignments: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
/// A map of fields to hold both filterable and non-filterable custom profile
/// attributes that aren't covered by the provided structured fields. See
/// \[CustomAttribute][google.cloud.talent.v4beta1.CustomAttribute\] for more details.
///
/// At most 100 filterable and at most 100 unfilterable keys are supported. If
/// limit is exceeded, an error is thrown. Custom attributes are `unfilterable`
/// by default. These are filterable when the `filterable` flag is set to
/// `true`.
///
/// Numeric custom attributes: each key can only map to one numeric value,
/// otherwise an error is thrown. Client can also filter on numeric custom
/// attributes using '>', '<' or '=' operators.
///
/// String custom attributes: each key can map up to 50 string values. For
/// filterable string value, each value has a byte size of no more than 256B.
/// For unfilterable string values, the maximum byte size of a single key is
/// 64B. An error is thrown for any request exceeding the limit.
/// The maximum total byte size is 10KB.
#[prost(map = "string, message", tag = "26")]
pub custom_attributes:
::std::collections::HashMap<::prost::alloc::string::String, CustomAttribute>,
/// Output only. Indicates if a summarized profile was created as part of the
/// profile creation API call. This flag does not indicate whether a profile is
/// searchable or not.
#[prost(bool, tag = "27")]
pub processed: bool,
/// Output only. Keyword snippet shows how the search result is related to a
/// search query. This is only returned in \[SearchProfilesResponse][google.cloud.talent.v4beta1.SearchProfilesResponse\].
#[prost(string, tag = "28")]
pub keyword_snippet: ::prost::alloc::string::String,
/// Output only. Candidate's availability signals.
#[prost(message, repeated, tag = "70")]
pub availability_signals: ::prost::alloc::vec::Vec<AvailabilitySignal>,
/// Output only. Derived locations of the profile, resolved from \[Profile.addresses][google.cloud.talent.v4beta1.Profile.addresses\].
///
/// \[derived_addresses][google.cloud.talent.v4beta1.Profile.derived_addresses\] are exactly matched to \[Profile.addresses][google.cloud.talent.v4beta1.Profile.addresses\] in the
/// same order.
#[prost(message, repeated, tag = "64")]
pub derived_addresses: ::prost::alloc::vec::Vec<Location>,
}
/// Candidate availability signal.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AvailabilitySignal {
/// Type of signal.
#[prost(enumeration = "AvailabilitySignalType", tag = "1")]
pub r#type: i32,
/// Timestamp of when the given availability activity last happened.
#[prost(message, optional, tag = "2")]
pub last_update_time: ::core::option::Option<::prost_types::Timestamp>,
/// Indicates if the \[last_update_time][google.cloud.talent.v4beta1.AvailabilitySignal.last_update_time\] is within
/// \[AvailabilityFilter.range][google.cloud.talent.v4beta1.AvailabilityFilter.range\].
///
/// Returned only in a search response when there is an \[AvailabilityFilter][google.cloud.talent.v4beta1.AvailabilityFilter\]
/// in \[ProfileQuery.availability_filters][google.cloud.talent.v4beta1.ProfileQuery.availability_filters\] where
/// \[signal_type][google.cloud.talent.v4beta1.AvailabilityFilter.signal_type\] matches \[type][google.cloud.talent.v4beta1.AvailabilitySignal.type\].
#[prost(message, optional, tag = "3")]
pub filter_satisfied: ::core::option::Option<bool>,
}
/// Resource that represents a resume.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Resume {
/// Users can create a profile with only this field field, if \[resume_type][google.cloud.talent.v4beta1.Resume.resume_type\]
/// is \[HRXML][google.cloud.talent.v4beta1.Resume.ResumeType.HRXML\]. For example, the API parses this field and
/// creates a profile
/// with all structured fields populated. \[EmploymentRecord][google.cloud.talent.v4beta1.EmploymentRecord\],
/// \[EducationRecord][google.cloud.talent.v4beta1.EducationRecord\], and so on. An error is thrown if this field cannot be
/// parsed.
///
/// Note that the use of the functionality offered by this field to extract
/// data from resumes is an Alpha feature and as such is not covered by any
/// SLA.
#[prost(string, tag = "1")]
pub structured_resume: ::prost::alloc::string::String,
/// The format of \[structured_resume][google.cloud.talent.v4beta1.Resume.structured_resume\].
#[prost(enumeration = "resume::ResumeType", tag = "2")]
pub resume_type: i32,
}
/// Nested message and enum types in `Resume`.
pub mod resume {
/// The format of a structured resume.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ResumeType {
/// Default value.
Unspecified = 0,
/// The profile contents in HR-XML format.
/// See <https://schemas.liquid-technologies.com/hr-xml/2007-04-15/> for more
/// information about Human Resources XML.
Hrxml = 1,
/// Resume type not specified.
OtherResumeType = 2,
}
}
/// Resource that represents the name of a person.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PersonName {
/// Preferred name for the person. This field is ignored if \[structured_name][google.cloud.talent.v4beta1.PersonName.structured_name\]
/// is provided.
///
/// Number of characters allowed is 100.
#[prost(string, tag = "3")]
pub preferred_name: ::prost::alloc::string::String,
/// The name of a person. It can be one of
/// \[formatted_name][google.cloud.talent.v4beta1.PersonName.formatted_name\] or
/// \[structured_name][google.cloud.talent.v4beta1.PersonName.structured_name\].
#[prost(oneof = "person_name::PersonName", tags = "1, 2")]
pub person_name: ::core::option::Option<person_name::PersonName>,
}
/// Nested message and enum types in `PersonName`.
pub mod person_name {
/// Resource that represents a person's structured name.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PersonStructuredName {
/// Given/first name.
///
/// It's derived from \[formatted_name][google.cloud.talent.v4beta1.PersonName.formatted_name\] if not provided.
///
/// Number of characters allowed is 100.
#[prost(string, tag = "1")]
pub given_name: ::prost::alloc::string::String,
/// Preferred given/first name or nickname.
///
/// Number of characters allowed is 100.
#[prost(string, tag = "6")]
pub preferred_name: ::prost::alloc::string::String,
/// Middle initial.
///
/// It's derived from \[formatted_name][google.cloud.talent.v4beta1.PersonName.formatted_name\] if not provided.
///
/// Number of characters allowed is 20.
#[prost(string, tag = "2")]
pub middle_initial: ::prost::alloc::string::String,
/// Family/last name.
///
/// It's derived from \[formatted_name][google.cloud.talent.v4beta1.PersonName.formatted_name\] if not provided.
///
/// Number of characters allowed is 100.
#[prost(string, tag = "3")]
pub family_name: ::prost::alloc::string::String,
/// Suffixes.
///
/// Number of characters allowed is 20.
#[prost(string, repeated, tag = "4")]
pub suffixes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
/// Prefixes.
///
/// Number of characters allowed is 20.
#[prost(string, repeated, tag = "5")]
pub prefixes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// The name of a person. It can be one of
/// \[formatted_name][google.cloud.talent.v4beta1.PersonName.formatted_name\] or
/// \[structured_name][google.cloud.talent.v4beta1.PersonName.structured_name\].
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum PersonName {
/// A string represents a person's full name. For example, "Dr. John Smith".
///
/// Number of characters allowed is 100.
#[prost(string, tag = "1")]
FormattedName(::prost::alloc::string::String),
/// A person's name in a structured way (last name, first name, suffix, and
/// so on.)
#[prost(message, tag = "2")]
StructuredName(PersonStructuredName),
}
}
/// Resource that represents a address.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Address {
/// The usage of the address. For example, SCHOOL, WORK, PERSONAL.
#[prost(enumeration = "ContactInfoUsage", tag = "1")]
pub usage: i32,
/// Indicates if it's the person's current address.
#[prost(message, optional, tag = "4")]
pub current: ::core::option::Option<bool>,
/// The address of a person. It can be one of
/// \[unstructured_address][google.cloud.talent.v4beta1.Address.unstructured_address\] or
/// \[structured_address][google.cloud.talent.v4beta1.Address.structured_address\].
#[prost(oneof = "address::Address", tags = "2, 3")]
pub address: ::core::option::Option<address::Address>,
}
/// Nested message and enum types in `Address`.
pub mod address {
/// The address of a person. It can be one of
/// \[unstructured_address][google.cloud.talent.v4beta1.Address.unstructured_address\] or
/// \[structured_address][google.cloud.talent.v4beta1.Address.structured_address\].
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum Address {
/// Unstructured address.
///
/// For example, "1600 Amphitheatre Pkwy, Mountain View, CA 94043",
/// "Sunnyvale, California".
///
/// Number of characters allowed is 100.
#[prost(string, tag = "2")]
UnstructuredAddress(::prost::alloc::string::String),
/// Structured address that contains street address, city, state, country,
/// and so on.
#[prost(message, tag = "3")]
StructuredAddress(super::super::super::super::r#type::PostalAddress),
}
}
/// Resource that represents a person's email address.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Email {
/// The usage of the email address. For example, SCHOOL, WORK, PERSONAL.
#[prost(enumeration = "ContactInfoUsage", tag = "1")]
pub usage: i32,
/// Email address.
///
/// Number of characters allowed is 4,000.
#[prost(string, tag = "2")]
pub email_address: ::prost::alloc::string::String,
}
/// Resource that represents a person's telephone number.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Phone {
/// The usage of the phone. For example, SCHOOL, WORK, PERSONAL.
#[prost(enumeration = "ContactInfoUsage", tag = "1")]
pub usage: i32,
/// The phone type. For example, LANDLINE, MOBILE, FAX.
#[prost(enumeration = "phone::PhoneType", tag = "2")]
pub r#type: i32,
/// Phone number.
///
/// Any phone formats are supported and only exact matches are performed on
/// searches. For example, if a phone number in profile is provided in the
/// format of "(xxx)xxx-xxxx", in profile searches the same phone format
/// has to be provided.
///
/// Number of characters allowed is 20.
#[prost(string, tag = "3")]
pub number: ::prost::alloc::string::String,
/// When this number is available. Any descriptive string is expected.
///
/// Number of characters allowed is 100.
#[prost(string, tag = "4")]
pub when_available: ::prost::alloc::string::String,
}
/// Nested message and enum types in `Phone`.
pub mod phone {
/// Enum that represents the type of the telephone.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum PhoneType {
/// Default value.
Unspecified = 0,
/// A landline.
Landline = 1,
/// A mobile.
Mobile = 2,
/// A fax.
Fax = 3,
/// A pager.
Pager = 4,
/// A TTY (test telephone) or TDD (telecommunication device for the deaf).
TtyOrTdd = 5,
/// A voicemail.
Voicemail = 6,
/// A virtual telephone number is a number that can be routed to another
/// number and managed by the user via Web, SMS, IVR, and so on. It is
/// associated with a particular person, and may be routed to either a MOBILE
/// or LANDLINE number. The [phone usage]\[google.cloud.talent.v4beta1.ContactInfoUsage\] should
/// be set to PERSONAL for these phone types. Some more information can be
/// found here: <https://en.wikipedia.org/wiki/Personal_Numbers>
Virtual = 7,
/// Voice over IP numbers. This includes TSoIP (Telephony Service over IP).
Voip = 8,
/// In some regions (e.g. the USA), it is impossible to distinguish between
/// fixed-line and mobile numbers by looking at the phone number itself.
MobileOrLandline = 9,
}
}
/// Resource that represents a valid URI for a personal use.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PersonalUri {
/// The personal URI.
///
/// Number of characters allowed is 4,000.
#[prost(string, tag = "1")]
pub uri: ::prost::alloc::string::String,
}
/// Resource that represents contact information other than phone, email,
/// URI and addresses.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AdditionalContactInfo {
/// The usage of this contact method. For example, SCHOOL, WORK, PERSONAL.
#[prost(enumeration = "ContactInfoUsage", tag = "1")]
pub usage: i32,
/// The name of the contact method.
///
/// For example, "hangout", "skype".
///
/// Number of characters allowed is 100.
#[prost(string, tag = "2")]
pub name: ::prost::alloc::string::String,
/// The contact id.
///
/// Number of characters allowed is 100.
#[prost(string, tag = "3")]
pub contact_id: ::prost::alloc::string::String,
}
/// Resource that represents an employment record of a candidate.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EmploymentRecord {
/// Start date of the employment.
#[prost(message, optional, tag = "1")]
pub start_date: ::core::option::Option<super::super::super::r#type::Date>,
/// End date of the employment.
#[prost(message, optional, tag = "2")]
pub end_date: ::core::option::Option<super::super::super::r#type::Date>,
/// The name of the employer company/organization.
///
/// For example, "Google", "Alphabet", and so on.
///
/// Number of characters allowed is 250.
#[prost(string, tag = "3")]
pub employer_name: ::prost::alloc::string::String,
/// The division name of the employment.
///
/// For example, division, department, client, and so on.
///
/// Number of characters allowed is 100.
#[prost(string, tag = "4")]
pub division_name: ::prost::alloc::string::String,
/// The physical address of the employer.
#[prost(message, optional, tag = "5")]
pub address: ::core::option::Option<Address>,
/// The job title of the employment.
///
/// For example, "Software Engineer", "Data Scientist", and so on.
///
/// Number of characters allowed is 250.
#[prost(string, tag = "6")]
pub job_title: ::prost::alloc::string::String,
/// The description of job content.
///
/// Number of characters allowed is 100,000.
#[prost(string, tag = "7")]
pub job_description: ::prost::alloc::string::String,
/// If the jobs is a supervisor position.
#[prost(message, optional, tag = "8")]
pub is_supervisor: ::core::option::Option<bool>,
/// If this employment is self-employed.
#[prost(message, optional, tag = "9")]
pub is_self_employed: ::core::option::Option<bool>,
/// If this employment is current.
#[prost(message, optional, tag = "10")]
pub is_current: ::core::option::Option<bool>,
/// Output only. The job title snippet shows how the \[job_title][google.cloud.talent.v4beta1.EmploymentRecord.job_title\] is related
/// to a search query. It's empty if the \[job_title][google.cloud.talent.v4beta1.EmploymentRecord.job_title\] isn't related to the
/// search query.
#[prost(string, tag = "11")]
pub job_title_snippet: ::prost::alloc::string::String,
/// Output only. The job description snippet shows how the \[job_description][google.cloud.talent.v4beta1.EmploymentRecord.job_description\]
/// is related to a search query. It's empty if the \[job_description][google.cloud.talent.v4beta1.EmploymentRecord.job_description\] isn't
/// related to the search query.
#[prost(string, tag = "12")]
pub job_description_snippet: ::prost::alloc::string::String,
/// Output only. The employer name snippet shows how the \[employer_name][google.cloud.talent.v4beta1.EmploymentRecord.employer_name\] is
/// related to a search query. It's empty if the \[employer_name][google.cloud.talent.v4beta1.EmploymentRecord.employer_name\] isn't
/// related to the search query.
#[prost(string, tag = "13")]
pub employer_name_snippet: ::prost::alloc::string::String,
}
/// Resource that represents an education record of a candidate.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EducationRecord {
/// The start date of the education.
#[prost(message, optional, tag = "1")]
pub start_date: ::core::option::Option<super::super::super::r#type::Date>,
/// The end date of the education.
#[prost(message, optional, tag = "2")]
pub end_date: ::core::option::Option<super::super::super::r#type::Date>,
/// The expected graduation date if currently pursuing a degree.
#[prost(message, optional, tag = "3")]
pub expected_graduation_date: ::core::option::Option<super::super::super::r#type::Date>,
/// The name of the school or institution.
///
/// For example, "Stanford University", "UC Berkeley", and so on.
///
/// Number of characters allowed is 250.
#[prost(string, tag = "4")]
pub school_name: ::prost::alloc::string::String,
/// The physical address of the education institution.
#[prost(message, optional, tag = "5")]
pub address: ::core::option::Option<Address>,
/// The description of the education.
///
/// Number of characters allowed is 100,000.
#[prost(string, tag = "8")]
pub description: ::prost::alloc::string::String,
/// If this education is current.
#[prost(message, optional, tag = "9")]
pub is_current: ::core::option::Option<bool>,
/// Output only. The school name snippet shows how the \[school_name][google.cloud.talent.v4beta1.EducationRecord.school_name\] is related to a
/// search query in search result. It's empty if the \[school_name][google.cloud.talent.v4beta1.EducationRecord.school_name\] isn't
/// related to the search query.
#[prost(string, tag = "10")]
pub school_name_snippet: ::prost::alloc::string::String,
/// Output only. The job description snippet shows how the \[Degree][google.cloud.talent.v4beta1.Degree\] is related to a search
/// query in search result. It's empty if the \[Degree][google.cloud.talent.v4beta1.Degree\] isn't related to the
/// search query.
#[prost(string, tag = "11")]
pub degree_snippet: ::prost::alloc::string::String,
/// The degree information. It can be one of
/// \[degree_description][google.cloud.talent.v4beta1.EducationRecord.degree_description\] or
/// \[structured_degree][google.cloud.talent.v4beta1.EducationRecord.structured_degree\].
#[prost(oneof = "education_record::Degree", tags = "6, 7")]
pub degree: ::core::option::Option<education_record::Degree>,
}
/// Nested message and enum types in `EducationRecord`.
pub mod education_record {
/// The degree information. It can be one of
/// \[degree_description][google.cloud.talent.v4beta1.EducationRecord.degree_description\] or
/// \[structured_degree][google.cloud.talent.v4beta1.EducationRecord.structured_degree\].
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum Degree {
/// The full description of the degree.
///
/// For example, "Master of Science in Computer Science", "B.S in Math".
///
/// Number of characters allowed is 100.
#[prost(string, tag = "6")]
DegreeDescription(::prost::alloc::string::String),
/// The structured notation of the degree.
#[prost(message, tag = "7")]
StructuredDegree(super::Degree),
}
}
/// Resource that represents a degree pursuing or acquired by a candidate.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Degree {
/// ISCED degree type.
#[prost(enumeration = "DegreeType", tag = "1")]
pub degree_type: i32,
/// Full Degree name.
///
/// For example, "B.S.", "Master of Arts", and so on.
///
/// Number of characters allowed is 100.
#[prost(string, tag = "2")]
pub degree_name: ::prost::alloc::string::String,
/// Fields of study for the degree.
///
/// For example, "Computer science", "engineering".
///
/// Number of characters allowed is 100.
#[prost(string, repeated, tag = "3")]
pub fields_of_study: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Resource that represents an individual or collaborative activity participated
/// in by a candidate, for example, an open-source project, a class assignment,
/// and so on.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Activity {
/// Activity display name.
///
/// Number of characters allowed is 100.
#[prost(string, tag = "1")]
pub display_name: ::prost::alloc::string::String,
/// Activity description.
///
/// Number of characters allowed is 100,000.
#[prost(string, tag = "2")]
pub description: ::prost::alloc::string::String,
/// Activity URI.
///
/// Number of characters allowed is 4,000.
#[prost(string, tag = "3")]
pub uri: ::prost::alloc::string::String,
/// The first creation date of the activity.
#[prost(message, optional, tag = "4")]
pub create_date: ::core::option::Option<super::super::super::r#type::Date>,
/// The last update date of the activity.
#[prost(message, optional, tag = "5")]
pub update_date: ::core::option::Option<super::super::super::r#type::Date>,
/// A list of team members involved in this activity.
///
/// Number of characters allowed is 100.
///
/// The limitation for max number of team members is 50.
#[prost(string, repeated, tag = "6")]
pub team_members: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
/// A list of skills used in this activity.
///
/// The limitation for max number of skills used is 50.
#[prost(message, repeated, tag = "7")]
pub skills_used: ::prost::alloc::vec::Vec<Skill>,
/// Output only. Activity name snippet shows how the \[display_name][google.cloud.talent.v4beta1.Activity.display_name\] is related to a search
/// query. It's empty if the \[display_name][google.cloud.talent.v4beta1.Activity.display_name\] isn't related to the search
/// query.
#[prost(string, tag = "8")]
pub activity_name_snippet: ::prost::alloc::string::String,
/// Output only. Activity description snippet shows how the
/// \[description][google.cloud.talent.v4beta1.Activity.description\] is related to a search query. It's empty if the
/// \[description][google.cloud.talent.v4beta1.Activity.description\] isn't related to the search query.
#[prost(string, tag = "9")]
pub activity_description_snippet: ::prost::alloc::string::String,
/// Output only. Skill used snippet shows how the corresponding
/// \[skills_used][google.cloud.talent.v4beta1.Activity.skills_used\] are related to a search query. It's empty if the
/// corresponding \[skills_used][google.cloud.talent.v4beta1.Activity.skills_used\] are not related to the search query.
#[prost(string, repeated, tag = "10")]
pub skills_used_snippet: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Resource that represents a publication resource of a candidate.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Publication {
/// A list of author names.
///
/// Number of characters allowed is 100.
#[prost(string, repeated, tag = "1")]
pub authors: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
/// The title of the publication.
///
/// Number of characters allowed is 100.
#[prost(string, tag = "2")]
pub title: ::prost::alloc::string::String,
/// The description of the publication.
///
/// Number of characters allowed is 100,000.
#[prost(string, tag = "3")]
pub description: ::prost::alloc::string::String,
/// The journal name of the publication.
///
/// Number of characters allowed is 100.
#[prost(string, tag = "4")]
pub journal: ::prost::alloc::string::String,
/// Volume number.
///
/// Number of characters allowed is 100.
#[prost(string, tag = "5")]
pub volume: ::prost::alloc::string::String,
/// The publisher of the journal.
///
/// Number of characters allowed is 100.
#[prost(string, tag = "6")]
pub publisher: ::prost::alloc::string::String,
/// The publication date.
#[prost(message, optional, tag = "7")]
pub publication_date: ::core::option::Option<super::super::super::r#type::Date>,
/// The publication type.
///
/// Number of characters allowed is 100.
#[prost(string, tag = "8")]
pub publication_type: ::prost::alloc::string::String,
/// ISBN number.
///
/// Number of characters allowed is 100.
#[prost(string, tag = "9")]
pub isbn: ::prost::alloc::string::String,
}
/// Resource that represents the patent acquired by a candidate.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Patent {
/// Name of the patent.
///
/// Number of characters allowed is 100.
#[prost(string, tag = "1")]
pub display_name: ::prost::alloc::string::String,
/// A list of inventors' names.
///
/// Number of characters allowed for each is 100.
#[prost(string, repeated, tag = "2")]
pub inventors: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
/// The status of the patent.
///
/// Number of characters allowed is 100.
#[prost(string, tag = "3")]
pub patent_status: ::prost::alloc::string::String,
/// The date the last time the status of the patent was checked.
#[prost(message, optional, tag = "4")]
pub patent_status_date: ::core::option::Option<super::super::super::r#type::Date>,
/// The date that the patent was filed.
#[prost(message, optional, tag = "5")]
pub patent_filing_date: ::core::option::Option<super::super::super::r#type::Date>,
/// The name of the patent office.
///
/// Number of characters allowed is 100.
#[prost(string, tag = "6")]
pub patent_office: ::prost::alloc::string::String,
/// The number of the patent.
///
/// Number of characters allowed is 100.
#[prost(string, tag = "7")]
pub patent_number: ::prost::alloc::string::String,
/// The description of the patent.
///
/// Number of characters allowed is 100,000.
#[prost(string, tag = "8")]
pub patent_description: ::prost::alloc::string::String,
/// The skills used in this patent.
#[prost(message, repeated, tag = "9")]
pub skills_used: ::prost::alloc::vec::Vec<Skill>,
}
/// List profiles request.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListProfilesRequest {
/// Required. The resource name of the tenant under which the profile is created.
///
/// The format is "projects/{project_id}/tenants/{tenant_id}". For example,
/// "projects/foo/tenants/bar".
#[prost(string, tag = "1")]
pub parent: ::prost::alloc::string::String,
/// The filter string specifies the profiles to be enumerated.
///
/// Supported operator: =, AND
///
/// The field(s) eligible for filtering are:
///
/// * `externalId`
/// * `groupId`
///
/// externalId and groupId cannot be specified at the same time. If both
/// externalId and groupId are provided, the API will return a bad request
/// error.
///
/// Sample Query:
///
/// * externalId = "externalId-1"
/// * groupId = "groupId-1"
#[prost(string, tag = "5")]
pub filter: ::prost::alloc::string::String,
/// The token that specifies the current offset (that is, starting result).
///
/// Please set the value to \[ListProfilesResponse.next_page_token][google.cloud.talent.v4beta1.ListProfilesResponse.next_page_token\] to
/// continue the list.
#[prost(string, tag = "2")]
pub page_token: ::prost::alloc::string::String,
/// The maximum number of profiles to be returned, at most 100.
///
/// Default is 100 unless a positive number smaller than 100 is specified.
#[prost(int32, tag = "3")]
pub page_size: i32,
/// A field mask to specify the profile fields to be listed in response.
/// All fields are listed if it is unset.
///
/// Valid values are:
///
/// * name
#[prost(message, optional, tag = "4")]
pub read_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// The List profiles response object.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListProfilesResponse {
/// Profiles for the specific tenant.
#[prost(message, repeated, tag = "1")]
pub profiles: ::prost::alloc::vec::Vec<Profile>,
/// A token to retrieve the next page of results. This is empty if there are no
/// more results.
#[prost(string, tag = "2")]
pub next_page_token: ::prost::alloc::string::String,
}
/// Create profile request.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateProfileRequest {
/// Required. The name of the tenant this profile belongs to.
///
/// The format is "projects/{project_id}/tenants/{tenant_id}". For example,
/// "projects/foo/tenants/bar".
#[prost(string, tag = "1")]
pub parent: ::prost::alloc::string::String,
/// Required. The profile to be created.
#[prost(message, optional, tag = "2")]
pub profile: ::core::option::Option<Profile>,
}
/// Get profile request.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetProfileRequest {
/// Required. Resource name of the profile to get.
///
/// The format is
/// "projects/{project_id}/tenants/{tenant_id}/profiles/{profile_id}". For
/// example, "projects/foo/tenants/bar/profiles/baz".
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
}
/// Update profile request
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateProfileRequest {
/// Required. Profile to be updated.
#[prost(message, optional, tag = "1")]
pub profile: ::core::option::Option<Profile>,
/// A field mask to specify the profile fields to update.
///
/// A full update is performed if it is unset.
#[prost(message, optional, tag = "2")]
pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Delete profile request.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteProfileRequest {
/// Required. Resource name of the profile to be deleted.
///
/// The format is
/// "projects/{project_id}/tenants/{tenant_id}/profiles/{profile_id}". For
/// example, "projects/foo/tenants/bar/profiles/baz".
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
}
/// The request body of the `SearchProfiles` call.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SearchProfilesRequest {
/// Required. The resource name of the tenant to search within.
///
/// The format is "projects/{project_id}/tenants/{tenant_id}". For example,
/// "projects/foo/tenants/bar".
#[prost(string, tag = "1")]
pub parent: ::prost::alloc::string::String,
/// Required. The meta information collected about the profile search user. This is used
/// to improve the search quality of the service. These values are provided by
/// users, and must be precise and consistent.
#[prost(message, optional, tag = "2")]
pub request_metadata: ::core::option::Option<RequestMetadata>,
/// Search query to execute. See \[ProfileQuery][google.cloud.talent.v4beta1.ProfileQuery\] for more details.
#[prost(message, optional, tag = "3")]
pub profile_query: ::core::option::Option<ProfileQuery>,
/// A limit on the number of profiles returned in the search results.
/// A value above the default value 10 can increase search response time.
///
/// The maximum value allowed is 100. Otherwise an error is thrown.
#[prost(int32, tag = "4")]
pub page_size: i32,
/// The pageToken, similar to offset enables users of the API to paginate
/// through the search results. To retrieve the first page of results, set the
/// pageToken to empty. The search response includes a
/// \[nextPageToken][google.cloud.talent.v4beta1.SearchProfilesResponse.next_page_token\] field that can be
/// used to populate the pageToken field for the next page of results. Using
/// pageToken instead of offset increases the performance of the API,
/// especially compared to larger offset values.
#[prost(string, tag = "5")]
pub page_token: ::prost::alloc::string::String,
/// An integer that specifies the current offset (that is, starting result) in
/// search results. This field is only considered if \[page_token][google.cloud.talent.v4beta1.SearchProfilesRequest.page_token\] is unset.
///
/// The maximum allowed value is 5000. Otherwise an error is thrown.
///
/// For example, 0 means to search from the first profile, and 10 means to
/// search from the 11th profile. This can be used for pagination, for example
/// pageSize = 10 and offset = 10 means to search from the second page.
#[prost(int32, tag = "6")]
pub offset: i32,
/// This flag controls the spell-check feature. If `false`, the
/// service attempts to correct a misspelled query.
///
/// For example, "enginee" is corrected to "engineer".
#[prost(bool, tag = "7")]
pub disable_spell_check: bool,
/// The criteria that determines how search results are sorted.
/// Defaults is "relevance desc" if no value is specified.
///
/// Supported options are:
///
/// * "relevance desc": By descending relevance, as determined by the API
/// algorithms.
/// * "update_date desc": Sort by \[Profile.update_time][google.cloud.talent.v4beta1.Profile.update_time\] in descending order
/// (recently updated profiles first).
/// * "create_date desc": Sort by \[Profile.create_time][google.cloud.talent.v4beta1.Profile.create_time\] in descending order
/// (recently created profiles first).
/// * "first_name": Sort by \[PersonName.PersonStructuredName.given_name][google.cloud.talent.v4beta1.PersonName.PersonStructuredName.given_name\] in
/// ascending order.
/// * "first_name desc": Sort by \[PersonName.PersonStructuredName.given_name][google.cloud.talent.v4beta1.PersonName.PersonStructuredName.given_name\]
/// in descending order.
/// * "last_name": Sort by \[PersonName.PersonStructuredName.family_name][google.cloud.talent.v4beta1.PersonName.PersonStructuredName.family_name\] in
/// ascending order.
/// * "last_name desc": Sort by \[PersonName.PersonStructuredName.family_name][google.cloud.talent.v4beta1.PersonName.PersonStructuredName.family_name\]
/// in ascending order.
#[prost(string, tag = "8")]
pub order_by: ::prost::alloc::string::String,
/// When sort by field is based on alphabetical order, sort values case
/// sensitively (based on ASCII) when the value is set to true. Default value
/// is case in-sensitive sort (false).
#[prost(bool, tag = "9")]
pub case_sensitive_sort: bool,
/// A list of expressions specifies histogram requests against matching
/// profiles for \[SearchProfilesRequest][google.cloud.talent.v4beta1.SearchProfilesRequest\].
///
/// The expression syntax looks like a function definition with parameters.
///
/// Function syntax: function_name(histogram_facet[, list of buckets])
///
/// Data types:
///
/// * Histogram facet: facet names with format `\[a-zA-Z][a-zA-Z0-9_\]+`.
/// * String: string like "any string with backslash escape for quote(\")."
/// * Number: whole number and floating point number like 10, -1 and -0.01.
/// * List: list of elements with comma(,) separator surrounded by square
/// brackets. For example, [1, 2, 3] and ["one", "two", "three"].
///
/// Built-in constants:
///
/// * MIN (minimum number similar to java Double.MIN_VALUE)
/// * MAX (maximum number similar to java Double.MAX_VALUE)
///
/// Built-in functions:
///
/// * bucket(start, end[, label])
/// Bucket build-in function creates a bucket with range of [start, end). Note
/// that the end is exclusive.
/// For example, bucket(1, MAX, "positive number") or bucket(1, 10).
///
/// Histogram Facets:
///
/// * admin1: Admin1 is a global placeholder for referring to state, province,
/// or the particular term a country uses to define the geographic structure
/// below the country level. Examples include states codes such as "CA", "IL",
/// "NY", and provinces, such as "BC".
/// * locality: Locality is a global placeholder for referring to city, town,
/// or the particular term a country uses to define the geographic structure
/// below the admin1 level. Examples include city names such as
/// "Mountain View" and "New York".
/// * extended_locality: Extended locality is concatenated version of admin1
/// and locality with comma separator. For example, "Mountain View, CA" and
/// "New York, NY".
/// * postal_code: Postal code of profile which follows locale code.
/// * country: Country code (ISO-3166-1 alpha-2 code) of profile, such as US,
/// JP, GB.
/// * job_title: Normalized job titles specified in EmploymentHistory.
/// * company_name: Normalized company name of profiles to match on.
/// * institution: The school name. For example, "MIT",
/// "University of California, Berkeley"
/// * degree: Highest education degree in ISCED code. Each value in degree
/// covers a specific level of education, without any expansion to upper nor
/// lower levels of education degree.
/// * experience_in_months: experience in months. 0 means 0 month to 1 month
/// (exclusive).
/// * application_date: The application date specifies application start dates.
/// See \[ApplicationDateFilter][google.cloud.talent.v4beta1.ApplicationDateFilter\] for more details.
/// * application_outcome_notes: The application outcome reason specifies the
/// reasons behind the outcome of the job application.
/// See \[ApplicationOutcomeNotesFilter][google.cloud.talent.v4beta1.ApplicationOutcomeNotesFilter\] for more details.
/// * application_job_title: The application job title specifies the job
/// applied for in the application.
/// See \[ApplicationJobFilter][google.cloud.talent.v4beta1.ApplicationJobFilter\] for more details.
/// * hirable_status: Hirable status specifies the profile's hirable status.
/// * string_custom_attribute: String custom attributes. Values can be accessed
/// via square bracket notation like string_custom_attribute\["key1"\].
/// * numeric_custom_attribute: Numeric custom attributes. Values can be
/// accessed via square bracket notation like numeric_custom_attribute\["key1"\].
///
/// Example expressions:
///
/// * count(admin1)
/// * count(experience_in_months, [bucket(0, 12, "1 year"),
/// bucket(12, 36, "1-3 years"), bucket(36, MAX, "3+ years")])
/// * count(string_custom_attribute\["assigned_recruiter"\])
/// * count(numeric_custom_attribute\["favorite_number"\],
/// [bucket(MIN, 0, "negative"), bucket(0, MAX, "non-negative")])
#[prost(message, repeated, tag = "10")]
pub histogram_queries: ::prost::alloc::vec::Vec<HistogramQuery>,
/// An id that uniquely identifies the result set of a
/// \[SearchProfiles][google.cloud.talent.v4beta1.ProfileService.SearchProfiles\] call. The id should be
/// retrieved from the
/// \[SearchProfilesResponse][google.cloud.talent.v4beta1.SearchProfilesResponse\] message returned from a previous
/// invocation of \[SearchProfiles][google.cloud.talent.v4beta1.ProfileService.SearchProfiles\].
///
/// A result set is an ordered list of search results.
///
/// If this field is not set, a new result set is computed based on the
/// \[profile_query][google.cloud.talent.v4beta1.SearchProfilesRequest.profile_query\]. A new \[result_set_id][google.cloud.talent.v4beta1.SearchProfilesRequest.result_set_id\] is returned as a handle to
/// access this result set.
///
/// If this field is set, the service will ignore the resource and
/// \[profile_query][google.cloud.talent.v4beta1.SearchProfilesRequest.profile_query\] values, and simply retrieve a page of results from the
/// corresponding result set. In this case, one and only one of \[page_token][google.cloud.talent.v4beta1.SearchProfilesRequest.page_token\]
/// or \[offset][google.cloud.talent.v4beta1.SearchProfilesRequest.offset\] must be set.
///
/// A typical use case is to invoke \[SearchProfilesRequest][google.cloud.talent.v4beta1.SearchProfilesRequest\] without this
/// field, then use the resulting \[result_set_id][google.cloud.talent.v4beta1.SearchProfilesRequest.result_set_id\] in
/// \[SearchProfilesResponse][google.cloud.talent.v4beta1.SearchProfilesResponse\] to page through the results.
#[prost(string, tag = "12")]
pub result_set_id: ::prost::alloc::string::String,
/// This flag is used to indicate whether the service will attempt to
/// understand synonyms and terms related to the search query or treat the
/// query "as is" when it generates a set of results. By default this flag is
/// set to false, thus allowing expanded results to also be returned. For
/// example a search for "software engineer" might also return candidates who
/// have experience in jobs similar to software engineer positions. By setting
/// this flag to true, the service will only attempt to deliver candidates has
/// software engineer in his/her global fields by treating "software engineer"
/// as a keyword.
///
/// It is recommended to provide a feature in the UI (such as a checkbox) to
/// allow recruiters to set this flag to true if they intend to search for
/// longer boolean strings.
#[prost(bool, tag = "13")]
pub strict_keywords_search: bool,
}
/// Response of SearchProfiles method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SearchProfilesResponse {
/// An estimation of the number of profiles that match the specified query.
///
/// This number isn't guaranteed to be accurate.
#[prost(int64, tag = "1")]
pub estimated_total_size: i64,
/// The spell checking result, and correction.
#[prost(message, optional, tag = "2")]
pub spell_correction: ::core::option::Option<SpellingCorrection>,
/// Additional information for the API invocation, such as the request
/// tracking id.
#[prost(message, optional, tag = "3")]
pub metadata: ::core::option::Option<ResponseMetadata>,
/// A token to retrieve the next page of results. This is empty if there are no
/// more results.
#[prost(string, tag = "4")]
pub next_page_token: ::prost::alloc::string::String,
/// The histogram results that match with specified
/// \[SearchProfilesRequest.histogram_queries][google.cloud.talent.v4beta1.SearchProfilesRequest.histogram_queries\].
#[prost(message, repeated, tag = "5")]
pub histogram_query_results: ::prost::alloc::vec::Vec<HistogramQueryResult>,
/// The profile entities that match the specified \[SearchProfilesRequest][google.cloud.talent.v4beta1.SearchProfilesRequest\].
#[prost(message, repeated, tag = "6")]
pub summarized_profiles: ::prost::alloc::vec::Vec<SummarizedProfile>,
/// An id that uniquely identifies the result set of a
/// \[SearchProfiles][google.cloud.talent.v4beta1.ProfileService.SearchProfiles\] call for consistent
/// results.
#[prost(string, tag = "7")]
pub result_set_id: ::prost::alloc::string::String,
}
/// Profile entry with metadata inside \[SearchProfilesResponse][google.cloud.talent.v4beta1.SearchProfilesResponse\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SummarizedProfile {
/// A list of profiles that are linked by \[Profile.group_id][google.cloud.talent.v4beta1.Profile.group_id\].
#[prost(message, repeated, tag = "1")]
pub profiles: ::prost::alloc::vec::Vec<Profile>,
/// A profile summary shows the profile summary and how the profile matches the
/// search query.
///
/// In profile summary, the profiles with the same \[Profile.group_id][google.cloud.talent.v4beta1.Profile.group_id\] are
/// merged together. Among profiles, same education/employment records may be
/// slightly different but they are merged into one with best efforts.
///
/// For example, in one profile the school name is "UC Berkeley" and the field
/// study is "Computer Science" and in another one the school name is
/// "University of California at Berkeley" and the field study is "CS". The API
/// merges these two inputs into one and selects one value for each field. For
/// example, the school name in summary is set to "University of California at
/// Berkeley" and the field of study is set to "Computer Science".
#[prost(message, optional, tag = "2")]
pub summary: ::core::option::Option<Profile>,
}
#[doc = r" Generated client implementations."]
pub mod profile_service_client {
#![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
use tonic::codegen::*;
#[doc = " A service that handles profile management, including profile CRUD,"]
#[doc = " enumeration and search."]
#[derive(Debug, Clone)]
pub struct ProfileServiceClient<T> {
inner: tonic::client::Grpc<T>,
}
impl<T> ProfileServiceClient<T>
where
T: tonic::client::GrpcService<tonic::body::BoxBody>,
T::ResponseBody: Body + Send + 'static,
T::Error: Into<StdError>,
<T::ResponseBody as Body>::Error: Into<StdError> + Send,
{
pub fn new(inner: T) -> Self {
let inner = tonic::client::Grpc::new(inner);
Self { inner }
}
pub fn with_interceptor<F>(
inner: T,
interceptor: F,
) -> ProfileServiceClient<InterceptedService<T, F>>
where
F: tonic::service::Interceptor,
T: tonic::codegen::Service<
http::Request<tonic::body::BoxBody>,
Response = http::Response<
<T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
>,
>,
<T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
Into<StdError> + Send + Sync,
{
ProfileServiceClient::new(InterceptedService::new(inner, interceptor))
}
#[doc = r" Compress requests with `gzip`."]
#[doc = r""]
#[doc = r" This requires the server to support it otherwise it might respond with an"]
#[doc = r" error."]
pub fn send_gzip(mut self) -> Self {
self.inner = self.inner.send_gzip();
self
}
#[doc = r" Enable decompressing responses with `gzip`."]
pub fn accept_gzip(mut self) -> Self {
self.inner = self.inner.accept_gzip();
self
}
#[doc = " Lists profiles by filter. The order is unspecified."]
pub async fn list_profiles(
&mut self,
request: impl tonic::IntoRequest<super::ListProfilesRequest>,
) -> Result<tonic::Response<super::ListProfilesResponse>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.talent.v4beta1.ProfileService/ListProfiles",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Creates and returns a new profile."]
pub async fn create_profile(
&mut self,
request: impl tonic::IntoRequest<super::CreateProfileRequest>,
) -> Result<tonic::Response<super::Profile>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.talent.v4beta1.ProfileService/CreateProfile",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Gets the specified profile."]
pub async fn get_profile(
&mut self,
request: impl tonic::IntoRequest<super::GetProfileRequest>,
) -> Result<tonic::Response<super::Profile>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.talent.v4beta1.ProfileService/GetProfile",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Updates the specified profile and returns the updated result."]
pub async fn update_profile(
&mut self,
request: impl tonic::IntoRequest<super::UpdateProfileRequest>,
) -> Result<tonic::Response<super::Profile>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.talent.v4beta1.ProfileService/UpdateProfile",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Deletes the specified profile."]
#[doc = " Prerequisite: The profile has no associated applications or assignments"]
#[doc = " associated."]
pub async fn delete_profile(
&mut self,
request: impl tonic::IntoRequest<super::DeleteProfileRequest>,
) -> Result<tonic::Response<()>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.talent.v4beta1.ProfileService/DeleteProfile",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Searches for profiles within a tenant."]
#[doc = ""]
#[doc = " For example, search by raw queries \"software engineer in Mountain View\" or"]
#[doc = " search by structured filters (location filter, education filter, etc.)."]
#[doc = ""]
#[doc = " See [SearchProfilesRequest][google.cloud.talent.v4beta1.SearchProfilesRequest] for more information."]
pub async fn search_profiles(
&mut self,
request: impl tonic::IntoRequest<super::SearchProfilesRequest>,
) -> Result<tonic::Response<super::SearchProfilesResponse>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.talent.v4beta1.ProfileService/SearchProfiles",
);
self.inner.unary(request.into_request(), path, codec).await
}
}
}
/// A Tenant resource represents a tenant in the service. A tenant is a group or
/// entity that shares common access with specific privileges for resources like
/// profiles. Customer may create multiple tenants to provide data isolation for
/// different groups.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Tenant {
/// Required during tenant update.
///
/// The resource name for a tenant. This is generated by the service when a
/// tenant is created.
///
/// The format is "projects/{project_id}/tenants/{tenant_id}", for example,
/// "projects/foo/tenants/bar".
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
/// Required. Client side tenant identifier, used to uniquely identify the tenant.
///
/// The maximum number of allowed characters is 255.
#[prost(string, tag = "2")]
pub external_id: ::prost::alloc::string::String,
/// Indicates whether data owned by this tenant may be used to provide product
/// improvements across other tenants.
///
/// Defaults behavior is \[DataUsageType.ISOLATED][google.cloud.talent.v4beta1.Tenant.DataUsageType.ISOLATED\] if it's unset.
#[prost(enumeration = "tenant::DataUsageType", tag = "3")]
pub usage_type: i32,
/// A list of keys of filterable \[Profile.custom_attributes][google.cloud.talent.v4beta1.Profile.custom_attributes\], whose
/// corresponding `string_values` are used in keyword searches. Profiles with
/// `string_values` under these specified field keys are returned if any
/// of the values match the search keyword. Custom field values with
/// parenthesis, brackets and special symbols are not searchable as-is,
/// and must be surrounded by quotes.
#[prost(string, repeated, tag = "4")]
pub keyword_searchable_profile_custom_attributes:
::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Nested message and enum types in `Tenant`.
pub mod tenant {
/// Enum that represents how user data owned by the tenant is used.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum DataUsageType {
/// Default value.
Unspecified = 0,
/// Data owned by this tenant is used to improve search/recommendation
/// quality across tenants.
Aggregated = 1,
/// Data owned by this tenant is used to improve search/recommendation
/// quality for this tenant only.
Isolated = 2,
}
}
/// The Request of the CreateTenant method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateTenantRequest {
/// Required. Resource name of the project under which the tenant is created.
///
/// The format is "projects/{project_id}", for example,
/// "projects/foo".
#[prost(string, tag = "1")]
pub parent: ::prost::alloc::string::String,
/// Required. The tenant to be created.
#[prost(message, optional, tag = "2")]
pub tenant: ::core::option::Option<Tenant>,
}
/// Request for getting a tenant by name.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetTenantRequest {
/// Required. The resource name of the tenant to be retrieved.
///
/// The format is "projects/{project_id}/tenants/{tenant_id}", for example,
/// "projects/foo/tenants/bar".
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
}
/// Request for updating a specified tenant.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateTenantRequest {
/// Required. The tenant resource to replace the current resource in the system.
#[prost(message, optional, tag = "1")]
pub tenant: ::core::option::Option<Tenant>,
/// Strongly recommended for the best service experience.
///
/// If \[update_mask][google.cloud.talent.v4beta1.UpdateTenantRequest.update_mask\] is provided, only the specified fields in
/// \[tenant][google.cloud.talent.v4beta1.UpdateTenantRequest.tenant\] are updated. Otherwise all the fields are updated.
///
/// A field mask to specify the tenant fields to be updated. Only
/// top level fields of \[Tenant][google.cloud.talent.v4beta1.Tenant\] are supported.
#[prost(message, optional, tag = "2")]
pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request to delete a tenant.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteTenantRequest {
/// Required. The resource name of the tenant to be deleted.
///
/// The format is "projects/{project_id}/tenants/{tenant_id}", for example,
/// "projects/foo/tenants/bar".
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
}
/// List tenants for which the client has ACL visibility.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListTenantsRequest {
/// Required. Resource name of the project under which the tenant is created.
///
/// The format is "projects/{project_id}", for example,
/// "projects/foo".
#[prost(string, tag = "1")]
pub parent: ::prost::alloc::string::String,
/// The starting indicator from which to return results.
#[prost(string, tag = "2")]
pub page_token: ::prost::alloc::string::String,
/// The maximum number of tenants to be returned, at most 100.
/// Default is 100 if a non-positive number is provided.
#[prost(int32, tag = "3")]
pub page_size: i32,
}
/// The List tenants response object.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListTenantsResponse {
/// Tenants for the current client.
#[prost(message, repeated, tag = "1")]
pub tenants: ::prost::alloc::vec::Vec<Tenant>,
/// A token to retrieve the next page of results.
#[prost(string, tag = "2")]
pub next_page_token: ::prost::alloc::string::String,
/// Additional information for the API invocation, such as the request
/// tracking id.
#[prost(message, optional, tag = "3")]
pub metadata: ::core::option::Option<ResponseMetadata>,
}
#[doc = r" Generated client implementations."]
pub mod tenant_service_client {
#![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
use tonic::codegen::*;
#[doc = " A service that handles tenant management, including CRUD and enumeration."]
#[derive(Debug, Clone)]
pub struct TenantServiceClient<T> {
inner: tonic::client::Grpc<T>,
}
impl<T> TenantServiceClient<T>
where
T: tonic::client::GrpcService<tonic::body::BoxBody>,
T::ResponseBody: Body + Send + 'static,
T::Error: Into<StdError>,
<T::ResponseBody as Body>::Error: Into<StdError> + Send,
{
pub fn new(inner: T) -> Self {
let inner = tonic::client::Grpc::new(inner);
Self { inner }
}
pub fn with_interceptor<F>(
inner: T,
interceptor: F,
) -> TenantServiceClient<InterceptedService<T, F>>
where
F: tonic::service::Interceptor,
T: tonic::codegen::Service<
http::Request<tonic::body::BoxBody>,
Response = http::Response<
<T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
>,
>,
<T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
Into<StdError> + Send + Sync,
{
TenantServiceClient::new(InterceptedService::new(inner, interceptor))
}
#[doc = r" Compress requests with `gzip`."]
#[doc = r""]
#[doc = r" This requires the server to support it otherwise it might respond with an"]
#[doc = r" error."]
pub fn send_gzip(mut self) -> Self {
self.inner = self.inner.send_gzip();
self
}
#[doc = r" Enable decompressing responses with `gzip`."]
pub fn accept_gzip(mut self) -> Self {
self.inner = self.inner.accept_gzip();
self
}
#[doc = " Creates a new tenant entity."]
pub async fn create_tenant(
&mut self,
request: impl tonic::IntoRequest<super::CreateTenantRequest>,
) -> Result<tonic::Response<super::Tenant>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.talent.v4beta1.TenantService/CreateTenant",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Retrieves specified tenant."]
pub async fn get_tenant(
&mut self,
request: impl tonic::IntoRequest<super::GetTenantRequest>,
) -> Result<tonic::Response<super::Tenant>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.talent.v4beta1.TenantService/GetTenant",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Updates specified tenant."]
pub async fn update_tenant(
&mut self,
request: impl tonic::IntoRequest<super::UpdateTenantRequest>,
) -> Result<tonic::Response<super::Tenant>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.talent.v4beta1.TenantService/UpdateTenant",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Deletes specified tenant."]
pub async fn delete_tenant(
&mut self,
request: impl tonic::IntoRequest<super::DeleteTenantRequest>,
) -> Result<tonic::Response<()>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.talent.v4beta1.TenantService/DeleteTenant",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Lists all tenants associated with the project."]
pub async fn list_tenants(
&mut self,
request: impl tonic::IntoRequest<super::ListTenantsRequest>,
) -> Result<tonic::Response<super::ListTenantsResponse>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.talent.v4beta1.TenantService/ListTenants",
);
self.inner.unary(request.into_request(), path, codec).await
}
}
}