/// 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.v4.Location.LocationType.NEIGHBORHOOD\], and "Kansas City, KS, USA"
/// has a type of \[LocationType.LOCALITY][google.cloud.talent.v4.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.v4.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.v4.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.v4.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.v4.RequestMetadata.domain\], \[session_id][google.cloud.talent.v4.RequestMetadata.session_id\] and \[user_id][google.cloud.talent.v4.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.v4.RequestMetadata.domain\], \[session_id][google.cloud.talent.v4.RequestMetadata.session_id\] and \[user_id][google.cloud.talent.v4.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.v4.CustomAttribute.string_values\] or \[long_values][google.cloud.talent.v4.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.v4.CustomAttribute.string_values\] or \[long_values][google.cloud.talent.v4.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.v4.CustomAttribute.long_values\] is supported.
#[prost(int64, repeated, tag = "2")]
pub long_values: ::prost::alloc::vec::Vec<i64>,
/// If the `filterable` flag is true, the custom field values may be used for
/// custom attribute filters \[JobQuery.custom_attribute_filter][google.cloud.talent.v4.JobQuery.custom_attribute_filter\].
/// If false, these values may not be used for custom attribute filters.
///
/// Default is false.
#[prost(bool, tag = "3")]
pub filterable: bool,
/// If the `keyword_searchable` flag is true, the keywords in custom fields are
/// searchable by keyword match.
/// If false, the values are not searchable by keyword match.
///
/// Default is false.
#[prost(bool, tag = "4")]
pub keyword_searchable: 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.v4.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.v4.CompensationInfo.CompensationEntry.amount\] times
/// \[CompensationEntry.expected_units_per_year][google.cloud.talent.v4.CompensationInfo.CompensationEntry.expected_units_per_year\].
///
/// See \[CompensationEntry][google.cloud.talent.v4.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.v4.CompensationInfo.CompensationEntry.amount\] times
/// \[CompensationEntry.expected_units_per_year][google.cloud.talent.v4.CompensationInfo.CompensationEntry.expected_units_per_year\].
///
/// See \[CompensationEntry][google.cloud.talent.v4.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.v4.CompensationInfo.CompensationEntry.amount\] or \[range][google.cloud.talent.v4.CompensationInfo.CompensationEntry.range\].
/// - and its \[expected_units_per_year][google.cloud.talent.v4.CompensationInfo.CompensationEntry.expected_units_per_year\] is set or can be derived.
/// Its annualized range is determined as (\[amount][google.cloud.talent.v4.CompensationInfo.CompensationEntry.amount\] or \[range][google.cloud.talent.v4.CompensationInfo.CompensationEntry.range\]) times
/// \[expected_units_per_year][google.cloud.talent.v4.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.v4.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.v4.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.v4.Job.employment_types\] is FULLTIME, a default value is inferred
/// based on \[unit][google.cloud.talent.v4.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.v4.CompensationInfo.CompensationEntry.description\].
///
/// For example, tipping format is described in
/// \[CompensationEntry.description][google.cloud.talent.v4.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.v4.CompensationInfo.CompensationEntry.amount\] or \[CompensationEntry.range][google.cloud.talent.v4.CompensationInfo.CompensationEntry.range\] ($10 per hour).
///
/// For example, equity is described in \[CompensationEntry.description][google.cloud.talent.v4.CompensationInfo.CompensationEntry.description\]
/// (for example, "1% - 2% equity vesting over 4 years, 1 year cliff") and
/// value estimated in \[CompensationEntry.amount][google.cloud.talent.v4.CompensationInfo.CompensationEntry.amount\] or
/// \[CompensationEntry.range][google.cloud.talent.v4.CompensationInfo.CompensationEntry.range\]. If no value estimate is possible, units are
/// \[CompensationUnit.COMPENSATION_UNIT_UNSPECIFIED][google.cloud.talent.v4.CompensationInfo.CompensationUnit.COMPENSATION_UNIT_UNSPECIFIED\] and then further
/// clarified in \[CompensationEntry.description][google.cloud.talent.v4.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,
}
}
/// 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.v4.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.v4.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.v4.LocationFilter\].
Unspecified = 0,
/// In addition to exact location matching, job posting is returned when the
/// \[LocationFilter][google.cloud.talent.v4.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.v4.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.v4.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.v4.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,
}
/// 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. Walking, biking and wheelchair accessible transit is
/// still in the Preview stage.
#[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,
/// Commute time is calculated based on public transit that is wheelchair
/// accessible.
TransitAccessible = 5,
}
/// 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".
#[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.v4.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.v4.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.v4.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/tenants/bar".
#[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".
#[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.v4.UpdateCompanyRequest.update_mask\] is provided, only the specified fields in
/// \[company][google.cloud.talent.v4.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.v4.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".
#[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/tenants/bar".
#[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.v4.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.v4.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.v4.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.v4.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.v4.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.v4.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/tenants/bar".
#[prost(string, tag = "1")]
pub tenant: ::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".
#[prost(string, tag = "5")]
pub company: ::prost::alloc::string::String,
/// The scope of the completion. The defaults is \[CompletionScope.PUBLIC][google.cloud.talent.v4.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.v4.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.v4.CompleteQueryRequest.CompletionType.JOB_TITLE\] type, only open jobs with the same
/// \[language_codes][google.cloud.talent.v4.CompleteQueryRequest.language_codes\] are returned.
JobTitle = 1,
/// Suggest company names for jobs autocomplete.
///
/// For \[CompletionType.COMPANY_NAME][google.cloud.talent.v4.CompleteQueryRequest.CompletionType.COMPANY_NAME\] type,
/// only companies having open jobs with the same \[language_codes][google.cloud.talent.v4.CompleteQueryRequest.language_codes\] are
/// returned.
CompanyName = 2,
/// Suggest both job titles and company names for jobs autocomplete.
///
/// For \[CompletionType.COMBINED][google.cloud.talent.v4.CompleteQueryRequest.CompletionType.COMBINED\] type, only open jobs with the same
/// \[language_codes][google.cloud.talent.v4.CompleteQueryRequest.language_codes\] or companies having open jobs with the same
/// \[language_codes][google.cloud.talent.v4.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.v4.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.v4.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.v4.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 job 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")]
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 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.v4.JobEvent.JobEventType\]).
#[prost(enumeration = "job_event::JobEventType", tag = "1")]
pub r#type: i32,
/// Required. The [job name(s)]\[google.cloud.talent.v4.Job.name\] associated with this event.
/// For example, if this is an \[impression][google.cloud.talent.v4.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.v4.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>,
}
/// 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.v4.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.v4.JobEvent.JobEventType.APPLICATION_START\] or \[JobEventType.APPLICATION_FINISH][google.cloud.talent.v4.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.v4.JobEvent.JobEventType.APPLICATION_START\],
/// \[JobEventType.APPLICATION_FINISH][google.cloud.talent.v4.JobEvent.JobEventType.APPLICATION_FINISH\] or \[JobEventType.VIEW][google.cloud.talent.v4.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,
}
}
/// 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/tenants/bar".
#[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.v4.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.v4.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".
///
/// 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.v4.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.v4.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.v4.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.v4.CommuteMethod\]. In this case,
/// \[location_filters][google.cloud.talent.v4.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.v4.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.v4.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.v4.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 < 10000 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.v4.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>,
}
/// 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. This field may be used in two ways:
///
/// 1) If telecommute preference is not set, this field is used address
/// ambiguity of the user-input address. For example, "Liverpool" may refer to
/// "Liverpool, NY, US" or "Liverpool, UK". This region code biases the
/// address resolution toward a specific country or territory. If this field is
/// not set, address resolution is biased toward the United States by default.
///
/// 2) If telecommute preference is set to TELECOMMUTE_ALLOWED, the
/// telecommute location filter will be limited to the region specified in this
/// field. If this field is not set, the telecommute job locations will not be
///
/// See
/// <https://unicode-org.github.io/cldr-staging/charts/latest/supplemental/territory_information.html>
/// for details. Example: "CH" for Switzerland.
#[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.v4.Job.posting_region\] indicates if a job permits telecommuting.
/// If this field is set to \[TelecommutePreference.TELECOMMUTE_ALLOWED][google.cloud.talent.v4.LocationFilter.TelecommutePreference.TELECOMMUTE_ALLOWED\],
/// telecommuting jobs are searched, and \[address][google.cloud.talent.v4.LocationFilter.address\] and \[lat_lng][google.cloud.talent.v4.LocationFilter.lat_lng\] are
/// ignored. If not set or set to
/// \[TelecommutePreference.TELECOMMUTE_EXCLUDED][google.cloud.talent.v4.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,
}
/// 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.v4.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.v4.CompensationFilter.units\].
/// Populate one or more \[units][google.cloud.talent.v4.CompensationFilter.units\].
///
/// See \[CompensationInfo.CompensationEntry][google.cloud.talent.v4.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.v4.CompensationInfo.CompensationUnit\] and
/// amount or range overlaps with provided
/// \[CompensationRange][google.cloud.talent.v4.CompensationInfo.CompensationRange\].
///
/// See \[CompensationInfo.CompensationEntry][google.cloud.talent.v4.CompensationInfo.CompensationEntry\] for definition of
/// base compensation entry.
///
/// Set exactly one \[units][google.cloud.talent.v4.CompensationFilter.units\] and populate \[range][google.cloud.talent.v4.CompensationFilter.range\].
UnitAndAmount = 2,
/// Filter by annualized base compensation amount and `base compensation
/// entry's` unit. Populate \[range][google.cloud.talent.v4.CompensationFilter.range\] and zero or more \[units][google.cloud.talent.v4.CompensationFilter.units\].
AnnualizedBaseAmount = 3,
/// Filter by annualized total compensation amount and `base compensation
/// entry's` unit . Populate \[range][google.cloud.talent.v4.CompensationFilter.range\] and zero or more \[units][google.cloud.talent.v4.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),
}
}
/// The histogram request.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HistogramQuery {
/// An expression specifies a histogram request against matching jobs for
/// searches.
///
/// See \[SearchJobsRequest.histogram_queries][google.cloud.talent.v4.SearchJobsRequest.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.v4.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.v4.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".
///
/// Use of this field in job queries and API calls is preferred over the use of
/// \[requisition_id][google.cloud.talent.v4.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".
#[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.v4.Job.name\],
/// \[language_code][google.cloud.talent.v4.Job.language_code\] and \[requisition_id][google.cloud.talent.v4.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.v4.Job.responsibilities\],
/// \[qualifications][google.cloud.talent.v4.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.v4.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.v4.Job.company\], \[language_code][google.cloud.talent.v4.Job.language_code\] and
/// \[requisition_id][google.cloud.talent.v4.Job.requisition_id\] are not allowed. If the original \[requisition_id][google.cloud.talent.v4.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.
///
/// Jobs with multiple addresses must have their addresses with the same
/// \[LocationType][\] to allow location filtering to work properly. (For
/// example, a Job with addresses "1600 Amphitheatre Parkway, Mountain View,
/// CA, USA" and "London, UK" may not have location filters applied correctly
/// at search time since the first is a \[LocationType.STREET_ADDRESS][\] and the
/// second is a \[LocationType.LOCALITY][\].) If a job needs to have multiple
/// addresses, it is suggested to split it into multiple jobs with same
/// LocationTypes.
///
/// 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.v4.EmploymentType.FULL_TIME\] or
/// [part time]\[google.cloud.talent.v4.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.v4.Job.description\] is present, detected
/// language code based on \[Job.description][google.cloud.talent.v4.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.v4.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.v4.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.v4.PostingRegion\] (for example, state, country) throughout
/// which the job is available. If this field is set, a \[LocationFilter][google.cloud.talent.v4.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.v4.PostingRegion.NATION\] or \[PostingRegion.ADMINISTRATIVE_AREA][google.cloud.talent.v4.PostingRegion.ADMINISTRATIVE_AREA\],
/// setting job \[Job.addresses][google.cloud.talent.v4.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.v4.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.v4.JobService.ListJobs\] API,
/// but it can be retrieved with the \[GetJob][google.cloud.talent.v4.JobService.GetJob\] API or
/// updated with the \[UpdateJob][google.cloud.talent.v4.JobService.UpdateJob\] API or deleted with
/// the \[DeleteJob][google.cloud.talent.v4.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.v4.Job.company\], \[language_code][google.cloud.talent.v4.Job.language_code\] and \[requisition_id][google.cloud.talent.v4.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.v4.Job.posting_publish_time\] must be set before
/// \[posting_expire_time][google.cloud.talent.v4.Job.posting_expire_time\]. The purpose of this feature is
/// to allow other objects, such as \[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.v4.UpdateJobRequest.update_mask\]. If the field masks include
/// \[job_end_time][google.cloud.talent.v4.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.v4.Job.addresses\].
///
/// \[locations][google.cloud.talent.v4.Job.DerivedInfo.locations\] are exactly matched to \[Job.addresses][google.cloud.talent.v4.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.v4.Job.title\] and \[Job.description][google.cloud.talent.v4.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.v4.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/tenants/bar".
#[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".
#[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.v4.UpdateJobRequest.update_mask\] is provided, only the specified fields in
/// \[job][google.cloud.talent.v4.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.v4.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".
#[prost(string, tag = "1")]
pub name: ::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/tenants/bar".
#[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`
/// * `requisitionId`
/// * `status` Available values: OPEN, EXPIRED, ALL. Defaults to
/// OPEN if no value is specified.
///
/// At least one of `companyName` and `requisitionId` must present or an
/// INVALID_ARGUMENT error is thrown.
///
/// 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"
/// * requisitionId = "req-1"
/// * requisitionId = "req-1" 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.v4.ListJobsRequest.job_view\] is set to \[JobView.JOB_VIEW_ID_ONLY][google.cloud.talent.v4.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.v4.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/tenants/bar".
#[prost(string, tag = "1")]
pub parent: ::prost::alloc::string::String,
/// Mode of a search.
///
/// Defaults to \[SearchMode.JOB_SEARCH][google.cloud.talent.v4.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,
/// 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.v4.Job.company_display_name\].
/// * employment_type: histogram by \[Job.employment_types][google.cloud.talent.v4.Job.employment_types\], for example,
/// "FULL_TIME", "PART_TIME".
/// * company_size: histogram by \[CompanySize][google.cloud.talent.v4.CompanySize\], for example, "SMALL",
/// "MEDIUM", "BIG".
/// * publish_time_in_day: histogram by the \[Job.posting_publish_time][google.cloud.talent.v4.Job.posting_publish_time\]
/// in days.
/// Must specify list of numeric buckets in spec.
/// * publish_time_in_month: histogram by the \[Job.posting_publish_time][google.cloud.talent.v4.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.v4.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.v4.Job.degree_types\], for example,
/// "Bachelors", "Masters".
/// * job_level: histogram by the \[Job.job_level][google.cloud.talent.v4.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.v4.Job.language_code\], for example, "en-US",
/// "fr-FR".
/// * language: histogram by the language subtag of the \[Job.language_code][google.cloud.talent.v4.Job.language_code\],
/// for example, "en", "fr".
/// * category: histogram by the \[JobCategory][google.cloud.talent.v4.JobCategory\], for example,
/// "COMPUTER_AND_IT", "HEALTHCARE".
/// * base_compensation_unit: histogram by the
/// \[CompensationInfo.CompensationUnit][google.cloud.talent.v4.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.v4.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.v4.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.v4.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.v4.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 max_page_size: i32,
/// The token specifying the current offset within
/// search results. See \[SearchJobsResponse.next_page_token][google.cloud.talent.v4.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.v4.Job.posting_publish_time\]
/// descending.
/// * `"posting_update_time desc"`: By \[Job.posting_update_time][google.cloud.talent.v4.Job.posting_update_time\]
/// descending.
/// * `"title"`: By \[Job.title][google.cloud.talent.v4.Job.title\] ascending.
/// * `"title desc"`: By \[Job.title][google.cloud.talent.v4.Job.title\] descending.
/// * `"annualized_base_compensation"`: By job's
/// \[CompensationInfo.annualized_base_compensation_range][google.cloud.talent.v4.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.v4.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.v4.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.v4.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.v4.SearchJobsRequest.CustomRankingInfo.ranking_expression\] with weight
/// factor assigned by
/// \[SearchJobsRequest.CustomRankingInfo.importance_level][google.cloud.talent.v4.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.v4.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.v4.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>,
/// This field is deprecated. Please use
/// \[SearchJobsRequest.keyword_match_mode][google.cloud.talent.v4.SearchJobsRequest.keyword_match_mode\] going forward.
///
/// To migrate, disable_keyword_match set to false maps to
/// \[KeywordMatchMode.KEYWORD_MATCH_ALL][google.cloud.talent.v4.SearchJobsRequest.KeywordMatchMode.KEYWORD_MATCH_ALL\], and disable_keyword_match set to
/// true maps to \[KeywordMatchMode.KEYWORD_MATCH_DISABLED][google.cloud.talent.v4.SearchJobsRequest.KeywordMatchMode.KEYWORD_MATCH_DISABLED\]. If
/// \[SearchJobsRequest.keyword_match_mode][google.cloud.talent.v4.SearchJobsRequest.keyword_match_mode\] is set, this field is ignored.
///
/// Controls whether to disable exact keyword match on \[Job.title][google.cloud.talent.v4.Job.title\],
/// \[Job.description][google.cloud.talent.v4.Job.description\], \[Job.company_display_name][google.cloud.talent.v4.Job.company_display_name\], \[Job.addresses][google.cloud.talent.v4.Job.addresses\],
/// \[Job.qualifications][google.cloud.talent.v4.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.v4.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.
#[deprecated]
#[prost(bool, tag = "16")]
pub disable_keyword_match: bool,
/// Controls what keyword match options to use. If both keyword_match_mode and
/// disable_keyword_match are set, keyword_match_mode will take precedence.
///
/// Defaults to \[KeywordMatchMode.KEYWORD_MATCH_ALL][google.cloud.talent.v4.SearchJobsRequest.KeywordMatchMode.KEYWORD_MATCH_ALL\] if no value
/// is specified.
#[prost(enumeration = "search_jobs_request::KeywordMatchMode", tag = "18")]
pub keyword_match_mode: i32,
}
/// Nested message and enum types in `SearchJobsRequest`.
pub mod search_jobs_request {
/// Custom ranking information for \[SearchJobsRequest][google.cloud.talent.v4.SearchJobsRequest\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CustomRankingInfo {
/// Required. Controls over how important the score of
/// \[CustomRankingInfo.ranking_expression][google.cloud.talent.v4.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.v4.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 < 200 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.v4.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.
///
/// 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.
#[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.
Simple = 2,
/// Only one job from the same company will be shown at once, other jobs
/// under same company are pushed to the end of the last page of search
/// result.
OnePerCompany = 3,
/// Similar to ONE_PER_COMPANY, but it allows at most two jobs in the
/// same company to be shown at once, the other jobs under same company are
/// pushed to the end of the last page of search result.
TwoPerCompany = 4,
/// The result list is ordered such that somewhat similar results are pushed
/// to the end of the last page of the search results. This option is
/// recommended if SIMPLE diversification does not diversify enough.
DiversifyByLooserSimilarity = 5,
}
/// Controls what keyword matching behavior the search has. When keyword
/// matching is enabled, a keyword match returns jobs that may not match given
/// category filters when there are matching keywords. For example, for the
/// query "program manager" with KeywordMatchMode set to KEYWORD_MATCH_ALL, a
/// job posting with the title "software developer," which doesn't fall into
/// "program manager" ontology, and "program manager" appearing in its
/// description will be surfaced.
///
/// For queries like "cloud" that don't contain title or
/// location specific ontology, jobs with "cloud" keyword matches are returned
/// regardless of this enum's value.
///
/// Use \[Company.keyword_searchable_job_custom_attributes][google.cloud.talent.v4.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.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum KeywordMatchMode {
/// The keyword match option isn't specified. Defaults to
/// \[KeywordMatchMode.KEYWORD_MATCH_ALL][google.cloud.talent.v4.SearchJobsRequest.KeywordMatchMode.KEYWORD_MATCH_ALL\] behavior.
Unspecified = 0,
/// Disables keyword matching.
KeywordMatchDisabled = 1,
/// Enable keyword matching over \[Job.title][google.cloud.talent.v4.Job.title\],
/// \[Job.description][google.cloud.talent.v4.Job.description\], \[Job.company_display_name][google.cloud.talent.v4.Job.company_display_name\], \[Job.addresses][google.cloud.talent.v4.Job.addresses\],
/// \[Job.qualifications][google.cloud.talent.v4.Job.qualifications\], and keyword searchable \[Job.custom_attributes][google.cloud.talent.v4.Job.custom_attributes\]
/// fields.
KeywordMatchAll = 2,
/// Only enable keyword matching over \[Job.title][google.cloud.talent.v4.Job.title\].
KeywordMatchTitleOnly = 3,
}
}
/// Response for SearchJob method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SearchJobsResponse {
/// The Job entities that match the specified \[SearchJobsRequest][google.cloud.talent.v4.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.v4.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.v4.Location.location_type\] is
/// \[Location.LocationType.LOCATION_TYPE_UNSPECIFIED][google.cloud.talent.v4.Location.LocationType.LOCATION_TYPE_UNSPECIFIED\].
#[prost(message, repeated, tag = "4")]
pub location_filters: ::prost::alloc::vec::Vec<Location>,
/// Number of jobs that match the specified query.
///
/// Note: This size is precise only if the total is less than 100,000.
#[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.v4.SearchJobsResponse\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MatchingJob {
/// Job resource that matches the specified \[SearchJobsRequest][google.cloud.talent.v4.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.v4.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.v4.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.v4.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/tenants/bar".
#[prost(string, tag = "1")]
pub parent: ::prost::alloc::string::String,
/// Required. The jobs to be created.
/// A maximum of 200 jobs can be created in a batch.
#[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/tenants/bar".
#[prost(string, tag = "1")]
pub parent: ::prost::alloc::string::String,
/// Required. The jobs to be updated.
/// A maximum of 200 jobs can be updated in a batch.
#[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.v4.BatchUpdateJobsRequest.update_mask\] is provided, only the specified fields in
/// \[Job][google.cloud.talent.v4.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.v4.Job\] are supported.
///
/// If \[update_mask][google.cloud.talent.v4.BatchUpdateJobsRequest.update_mask\] is provided, The \[Job][google.cloud.talent.v4.Job\] inside
/// \[JobResult][JobOperationResult.JobResult\]
/// will only contains fields that is updated, plus the Id of the Job.
/// Otherwise, \[Job][google.cloud.talent.v4.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>,
}
/// Request to delete a batch of jobs.
#[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/tenants/bar".
///
/// The parent of all of the jobs specified in `names` must match this field.
#[prost(string, tag = "1")]
pub parent: ::prost::alloc::string::String,
/// The names of the jobs to delete.
///
/// The format is "projects/{project_id}/tenants/{tenant_id}/jobs/{job_id}".
/// For example, "projects/foo/tenants/bar/jobs/baz".
///
/// A maximum of 200 jobs can be deleted in a batch.
#[prost(string, repeated, tag = "2")]
pub names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Mutation result of a job from a batch operation.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct JobResult {
/// Here \[Job][google.cloud.talent.v4.Job\] only contains basic information including \[name][google.cloud.talent.v4.Job.name\],
/// \[company][google.cloud.talent.v4.Job.company\], \[language_code][google.cloud.talent.v4.Job.language_code\]
/// and \[requisition_id][google.cloud.talent.v4.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<Job>,
/// The status of the job processed. This field is populated if the
/// processing of the \[job][google.cloud.talent.v4.JobResult.job\] fails.
#[prost(message, optional, tag = "2")]
pub status: ::core::option::Option<super::super::super::rpc::Status>,
}
/// The result of \[JobService.BatchCreateJobs][google.cloud.talent.v4.JobService.BatchCreateJobs\]. It's used to
/// replace \[google.longrunning.Operation.response][google.longrunning.Operation.response\] in case of success.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchCreateJobsResponse {
/// List of job mutation results from a batch create operation. It can change
/// until operation status is FINISHED, FAILED or CANCELLED.
#[prost(message, repeated, tag = "1")]
pub job_results: ::prost::alloc::vec::Vec<JobResult>,
}
/// The result of \[JobService.BatchUpdateJobs][google.cloud.talent.v4.JobService.BatchUpdateJobs\]. It's used to
/// replace \[google.longrunning.Operation.response][google.longrunning.Operation.response\] in case of success.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchUpdateJobsResponse {
/// List of job mutation results from a batch update operation. It can change
/// until operation status is FINISHED, FAILED or CANCELLED.
#[prost(message, repeated, tag = "1")]
pub job_results: ::prost::alloc::vec::Vec<JobResult>,
}
/// The result of \[JobService.BatchDeleteJobs][google.cloud.talent.v4.JobService.BatchDeleteJobs\]. It's used to
/// replace \[google.longrunning.Operation.response][google.longrunning.Operation.response\] in case of success.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchDeleteJobsResponse {
/// List of job mutation results from a batch delete operation. It can change
/// until operation status is FINISHED, FAILED or CANCELLED.
#[prost(message, repeated, tag = "1")]
pub job_results: ::prost::alloc::vec::Vec<JobResult>,
}
/// An enum that specifies the job attributes that are returned in the
/// \[MatchingJob.job][google.cloud.talent.v4.SearchJobsResponse.MatchingJob.job\] or
/// \[ListJobsResponse.jobs][google.cloud.talent.v4.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.v4.Job.name\], \[Job.requisition_id][google.cloud.talent.v4.Job.requisition_id\], \[Job.language_code][google.cloud.talent.v4.Job.language_code\].
IdOnly = 1,
/// A minimal view of the job, with the following attributes:
/// \[Job.name][google.cloud.talent.v4.Job.name\], \[Job.requisition_id][google.cloud.talent.v4.Job.requisition_id\], \[Job.title][google.cloud.talent.v4.Job.title\],
/// \[Job.company][google.cloud.talent.v4.Job.company\], \[Job.DerivedInfo.locations][google.cloud.talent.v4.Job.DerivedInfo.locations\], \[Job.language_code][google.cloud.talent.v4.Job.language_code\].
Minimal = 2,
/// A small view of the job, with the following attributes in the search
/// results: \[Job.name][google.cloud.talent.v4.Job.name\], \[Job.requisition_id][google.cloud.talent.v4.Job.requisition_id\], \[Job.title][google.cloud.talent.v4.Job.title\],
/// \[Job.company][google.cloud.talent.v4.Job.company\], \[Job.DerivedInfo.locations][google.cloud.talent.v4.Job.DerivedInfo.locations\], \[Job.visibility][google.cloud.talent.v4.Job.visibility\],
/// \[Job.language_code][google.cloud.talent.v4.Job.language_code\], \[Job.description][google.cloud.talent.v4.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.v4.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.v4.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.v4.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.v4.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.v4.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.v4.JobService/DeleteJob",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Begins executing a batch delete jobs operation."]
pub async fn batch_delete_jobs(
&mut self,
request: impl tonic::IntoRequest<super::BatchDeleteJobsRequest>,
) -> 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.v4.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.v4.JobService/ListJobs");
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Searches for jobs using the provided [SearchJobsRequest][google.cloud.talent.v4.SearchJobsRequest]."]
#[doc = ""]
#[doc = " This call constrains the [visibility][google.cloud.talent.v4.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.v4.JobService/SearchJobs",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Searches for jobs using the provided [SearchJobsRequest][google.cloud.talent.v4.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), it has different algorithmic"]
#[doc = " adjustments that are designed to specifically target passive job seekers."]
#[doc = ""]
#[doc = " This call constrains the [visibility][google.cloud.talent.v4.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.v4.JobService/SearchJobsForAlert",
);
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
/// jobs. 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,
}
/// 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.v4.UpdateTenantRequest.update_mask\] is provided, only the specified fields in
/// \[tenant][google.cloud.talent.v4.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.v4.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.v4.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.v4.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.v4.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.v4.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.v4.TenantService/ListTenants",
);
self.inner.unary(request.into_request(), path, codec).await
}
}
}