diff --git a/zitadel_client/api/beta_instance_service_api.py b/zitadel_client/api/beta_instance_service_api.py index 6cbaeb3..386bd2c 100644 --- a/zitadel_client/api/beta_instance_service_api.py +++ b/zitadel_client/api/beta_instance_service_api.py @@ -443,7 +443,7 @@ def _delete_instance_serialize( def get_instance( self, beta_instance_service_get_instance_request: BetaInstanceServiceGetInstanceRequest, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> BetaInstanceServiceGetInstanceResponse: """GetInstance - Get Instance Returns the instance in the current context. The instace_id in the input message will be used in the future. Required permissions: - `iam.read` + Get Instance Returns the instance in the current context. The instance_id in the input message will be used in the future. Required permissions: - `iam.read` :param beta_instance_service_get_instance_request: (required) :type beta_instance_service_get_instance_request: BetaInstanceServiceGetInstanceRequest diff --git a/zitadel_client/api/user_service_api.py b/zitadel_client/api/user_service_api.py index fce6670..867dd01 100644 --- a/zitadel_client/api/user_service_api.py +++ b/zitadel_client/api/user_service_api.py @@ -155,7 +155,7 @@ def __init__(self, api_client=None) -> None: def add_human_user( self, user_service_add_human_user_request: UserServiceAddHumanUserRequest, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> UserServiceAddHumanUserResponse: """AddHumanUser - Create a new human user Create/import a new user with the type human. The newly created user will get a verification email if either the email address is not marked as verified and you did not request the verification to be returned. + Create a new human user Deprecated: Use [CreateUser](apis/resources/user_service_v2/user-service-create-user.api.mdx) to create a new user of type human instead. Create/import a new user with the type human. The newly created user will get a verification email if either the email address is not marked as verified and you did not request the verification to be returned. :param user_service_add_human_user_request: (required) :type user_service_add_human_user_request: UserServiceAddHumanUserRequest @@ -1051,7 +1051,7 @@ def _add_secret_serialize( def create_invite_code( self, user_service_create_invite_code_request: UserServiceCreateInviteCodeRequest, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> UserServiceCreateInviteCodeResponse: """CreateInviteCode - Create an invite code for a user Create an invite code for a user to initialize their first authentication method (password, passkeys, IdP) depending on the organization's available methods. If an invite code has been created previously, it's url template and application name will be used as defaults for the new code. The new code will overwrite the previous one and make it invalid. + Create an invite code for a user Create an invite code for a user to initialize their first authentication method (password, passkeys, IdP) depending on the organization's available methods. If an invite code has been created previously, it's url template and application name will be used as defaults for the new code. The new code will overwrite the previous one and make it invalid. Note: It is possible to reissue a new code only when the previous code has expired, or when the user provides a wrong code three or more times during verification. :param user_service_create_invite_code_request: (required) :type user_service_create_invite_code_request: UserServiceCreateInviteCodeRequest @@ -4634,7 +4634,7 @@ def _remove_personal_access_token_serialize( def remove_phone( self, user_service_remove_phone_request: UserServiceRemovePhoneRequest, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> UserServiceRemovePhoneResponse: """RemovePhone - Delete the user phone Delete the phone number of a user. + Delete the user phone Deprecated: [Update the users phone field](apis/resources/user_service_v2/user-service-update-user.api.mdx) to remove the phone number. Delete the phone number of a user. :param user_service_remove_phone_request: (required) :type user_service_remove_phone_request: UserServiceRemovePhoneRequest @@ -5402,7 +5402,7 @@ def _resend_invite_code_serialize( def resend_phone_code( self, user_service_resend_phone_code_request: UserServiceResendPhoneCodeRequest, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> UserServiceResendPhoneCodeResponse: """ResendPhoneCode - Resend code to verify user phone + Resend code to verify user phone number Resend code to verify user phone number. :param user_service_resend_phone_code_request: (required) :type user_service_resend_phone_code_request: UserServiceResendPhoneCodeRequest @@ -5786,7 +5786,7 @@ def _send_email_code_serialize( def set_email( self, user_service_set_email_request: UserServiceSetEmailRequest, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> UserServiceSetEmailResponse: """SetEmail - Change the user email Change the email address of a user. If the state is set to not verified, a verification code will be generated, which can be either returned or sent to the user by email.. + Change the user email Deprecated: [Update the users email field](apis/resources/user_service_v2/user-service-update-user.api.mdx). Change the email address of a user. If the state is set to not verified, a verification code will be generated, which can be either returned or sent to the user by email.. :param user_service_set_email_request: (required) :type user_service_set_email_request: UserServiceSetEmailRequest @@ -5914,7 +5914,7 @@ def _set_email_serialize( def set_password( self, user_service_set_password_request: UserServiceSetPasswordRequest, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> UserServiceSetPasswordResponse: """SetPassword - Change password Change the password of a user with either a verification code or the current password.. + Change password Deprecated: [Update the users password](apis/resources/user_service_v2/user-service-update-user.api.mdx) instead. Change the password of a user with either a verification code or the current password.. :param user_service_set_password_request: (required) :type user_service_set_password_request: UserServiceSetPasswordRequest @@ -6042,7 +6042,7 @@ def _set_password_serialize( def set_phone( self, user_service_set_phone_request: UserServiceSetPhoneRequest, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> UserServiceSetPhoneResponse: """SetPhone - Set the user phone Set the phone number of a user. If the state is set to not verified, a verification code will be generated, which can be either returned or sent to the user by sms.. + Set the user phone Deprecated: [Update the users phone field](apis/resources/user_service_v2/user-service-update-user.api.mdx). Set the phone number of a user. If the state is set to not verified, a verification code will be generated, which can be either returned or sent to the user by sms.. :param user_service_set_phone_request: (required) :type user_service_set_phone_request: UserServiceSetPhoneRequest @@ -6554,7 +6554,7 @@ def _unlock_user_serialize( def update_human_user( self, user_service_update_human_user_request: UserServiceUpdateHumanUserRequest, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> UserServiceUpdateHumanUserResponse: """UpdateHumanUser - Update Human User Update all information from a user.. + Update Human User Deprecated: Use [UpdateUser](apis/resources/user_service_v2/user-service-update-user.api.mdx) to update a user of type human instead. Update all information from a user. :param user_service_update_human_user_request: (required) :type user_service_update_human_user_request: UserServiceUpdateHumanUserRequest @@ -7194,7 +7194,7 @@ def _verify_passkey_registration_serialize( def verify_phone( self, user_service_verify_phone_request: UserServiceVerifyPhoneRequest, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> UserServiceVerifyPhoneResponse: """VerifyPhone - Verify the phone Verify the phone with the generated code.. + Verify the phone number Verify the phone number with the generated code. :param user_service_verify_phone_request: (required) :type user_service_verify_phone_request: UserServiceVerifyPhoneRequest diff --git a/zitadel_client/models/__init__.py b/zitadel_client/models/__init__.py index a1faff0..f1be3ef 100644 --- a/zitadel_client/models/__init__.py +++ b/zitadel_client/models/__init__.py @@ -709,6 +709,7 @@ from zitadel_client.models.identity_provider_service_saml_binding import IdentityProviderServiceSAMLBinding from zitadel_client.models.identity_provider_service_saml_config import IdentityProviderServiceSAMLConfig from zitadel_client.models.identity_provider_service_saml_name_id_format import IdentityProviderServiceSAMLNameIDFormat +from zitadel_client.models.identity_provider_service_saml_signature_algorithm import IdentityProviderServiceSAMLSignatureAlgorithm from zitadel_client.models.oidc_service_any import OIDCServiceAny from zitadel_client.models.oidc_service_auth_request import OIDCServiceAuthRequest from zitadel_client.models.oidc_service_authorization_error import OIDCServiceAuthorizationError @@ -784,6 +785,7 @@ from zitadel_client.models.session_service_delete_session_request import SessionServiceDeleteSessionRequest from zitadel_client.models.session_service_delete_session_response import SessionServiceDeleteSessionResponse from zitadel_client.models.session_service_details import SessionServiceDetails +from zitadel_client.models.session_service_expiration_date_query import SessionServiceExpirationDateQuery from zitadel_client.models.session_service_factors import SessionServiceFactors from zitadel_client.models.session_service_get_session_request import SessionServiceGetSessionRequest from zitadel_client.models.session_service_get_session_response import SessionServiceGetSessionResponse @@ -884,6 +886,7 @@ from zitadel_client.models.user_service_auth_factor_u2_f import UserServiceAuthFactorU2F from zitadel_client.models.user_service_auth_factors import UserServiceAuthFactors from zitadel_client.models.user_service_authentication_method_type import UserServiceAuthenticationMethodType +from zitadel_client.models.user_service_byte_filter_method import UserServiceByteFilterMethod from zitadel_client.models.user_service_connect_error import UserServiceConnectError from zitadel_client.models.user_service_create_invite_code_request import UserServiceCreateInviteCodeRequest from zitadel_client.models.user_service_create_invite_code_response import UserServiceCreateInviteCodeResponse @@ -954,6 +957,7 @@ from zitadel_client.models.user_service_metadata import UserServiceMetadata from zitadel_client.models.user_service_metadata_key_filter import UserServiceMetadataKeyFilter from zitadel_client.models.user_service_metadata_search_filter import UserServiceMetadataSearchFilter +from zitadel_client.models.user_service_metadata_value_filter import UserServiceMetadataValueFilter from zitadel_client.models.user_service_nick_name_query import UserServiceNickNameQuery from zitadel_client.models.user_service_not_query import UserServiceNotQuery from zitadel_client.models.user_service_notification_type import UserServiceNotificationType diff --git a/zitadel_client/models/beta_feature_service_improved_performance.py b/zitadel_client/models/beta_feature_service_improved_performance.py index c81c477..775b8cb 100644 --- a/zitadel_client/models/beta_feature_service_improved_performance.py +++ b/zitadel_client/models/beta_feature_service_improved_performance.py @@ -27,7 +27,6 @@ class BetaFeatureServiceImprovedPerformance(str, Enum): allowed enum values """ IMPROVED_PERFORMANCE_UNSPECIFIED = 'IMPROVED_PERFORMANCE_UNSPECIFIED' - IMPROVED_PERFORMANCE_ORG_BY_ID = 'IMPROVED_PERFORMANCE_ORG_BY_ID' IMPROVED_PERFORMANCE_PROJECT_GRANT = 'IMPROVED_PERFORMANCE_PROJECT_GRANT' IMPROVED_PERFORMANCE_PROJECT = 'IMPROVED_PERFORMANCE_PROJECT' IMPROVED_PERFORMANCE_USER_GRANT = 'IMPROVED_PERFORMANCE_USER_GRANT' diff --git a/zitadel_client/models/feature_service_get_instance_features_response.py b/zitadel_client/models/feature_service_get_instance_features_response.py index eaea36b..3c2abf5 100644 --- a/zitadel_client/models/feature_service_get_instance_features_response.py +++ b/zitadel_client/models/feature_service_get_instance_features_response.py @@ -37,12 +37,11 @@ class FeatureServiceGetInstanceFeaturesResponse(BaseModel): improved_performance: Optional[FeatureServiceImprovedPerformanceFeatureFlag] = Field(default=None, alias="improvedPerformance") debug_oidc_parent_error: Optional[FeatureServiceFeatureFlag] = Field(default=None, alias="debugOidcParentError") oidc_single_v1_session_termination: Optional[FeatureServiceFeatureFlag] = Field(default=None, alias="oidcSingleV1SessionTermination") - disable_user_token_event: Optional[FeatureServiceFeatureFlag] = Field(default=None, alias="disableUserTokenEvent") enable_back_channel_logout: Optional[FeatureServiceFeatureFlag] = Field(default=None, alias="enableBackChannelLogout") login_v2: Optional[FeatureServiceLoginV2FeatureFlag] = Field(default=None, alias="loginV2") permission_check_v2: Optional[FeatureServiceFeatureFlag] = Field(default=None, alias="permissionCheckV2") console_use_v2_user_api: Optional[FeatureServiceFeatureFlag] = Field(default=None, alias="consoleUseV2UserApi") - __properties: ClassVar[List[str]] = ["details", "loginDefaultOrg", "userSchema", "oidcTokenExchange", "improvedPerformance", "debugOidcParentError", "oidcSingleV1SessionTermination", "disableUserTokenEvent", "enableBackChannelLogout", "loginV2", "permissionCheckV2", "consoleUseV2UserApi"] + __properties: ClassVar[List[str]] = ["details", "loginDefaultOrg", "userSchema", "oidcTokenExchange", "improvedPerformance", "debugOidcParentError", "oidcSingleV1SessionTermination", "enableBackChannelLogout", "loginV2", "permissionCheckV2", "consoleUseV2UserApi"] model_config = ConfigDict( populate_by_name=True, @@ -104,9 +103,6 @@ def to_dict(self) -> Dict[str, Any]: # override the default output from pydantic by calling `to_dict()` of oidc_single_v1_session_termination if self.oidc_single_v1_session_termination: _dict['oidcSingleV1SessionTermination'] = self.oidc_single_v1_session_termination.to_dict() - # override the default output from pydantic by calling `to_dict()` of disable_user_token_event - if self.disable_user_token_event: - _dict['disableUserTokenEvent'] = self.disable_user_token_event.to_dict() # override the default output from pydantic by calling `to_dict()` of enable_back_channel_logout if self.enable_back_channel_logout: _dict['enableBackChannelLogout'] = self.enable_back_channel_logout.to_dict() @@ -138,7 +134,6 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: "improvedPerformance": FeatureServiceImprovedPerformanceFeatureFlag.from_dict(obj["improvedPerformance"]) if obj.get("improvedPerformance") is not None else None, "debugOidcParentError": FeatureServiceFeatureFlag.from_dict(obj["debugOidcParentError"]) if obj.get("debugOidcParentError") is not None else None, "oidcSingleV1SessionTermination": FeatureServiceFeatureFlag.from_dict(obj["oidcSingleV1SessionTermination"]) if obj.get("oidcSingleV1SessionTermination") is not None else None, - "disableUserTokenEvent": FeatureServiceFeatureFlag.from_dict(obj["disableUserTokenEvent"]) if obj.get("disableUserTokenEvent") is not None else None, "enableBackChannelLogout": FeatureServiceFeatureFlag.from_dict(obj["enableBackChannelLogout"]) if obj.get("enableBackChannelLogout") is not None else None, "loginV2": FeatureServiceLoginV2FeatureFlag.from_dict(obj["loginV2"]) if obj.get("loginV2") is not None else None, "permissionCheckV2": FeatureServiceFeatureFlag.from_dict(obj["permissionCheckV2"]) if obj.get("permissionCheckV2") is not None else None, diff --git a/zitadel_client/models/feature_service_get_system_features_response.py b/zitadel_client/models/feature_service_get_system_features_response.py index 09516b1..457037b 100644 --- a/zitadel_client/models/feature_service_get_system_features_response.py +++ b/zitadel_client/models/feature_service_get_system_features_response.py @@ -36,11 +36,10 @@ class FeatureServiceGetSystemFeaturesResponse(BaseModel): oidc_token_exchange: Optional[FeatureServiceFeatureFlag] = Field(default=None, alias="oidcTokenExchange") improved_performance: Optional[FeatureServiceImprovedPerformanceFeatureFlag] = Field(default=None, alias="improvedPerformance") oidc_single_v1_session_termination: Optional[FeatureServiceFeatureFlag] = Field(default=None, alias="oidcSingleV1SessionTermination") - disable_user_token_event: Optional[FeatureServiceFeatureFlag] = Field(default=None, alias="disableUserTokenEvent") enable_back_channel_logout: Optional[FeatureServiceFeatureFlag] = Field(default=None, alias="enableBackChannelLogout") login_v2: Optional[FeatureServiceLoginV2FeatureFlag] = Field(default=None, alias="loginV2") permission_check_v2: Optional[FeatureServiceFeatureFlag] = Field(default=None, alias="permissionCheckV2") - __properties: ClassVar[List[str]] = ["details", "loginDefaultOrg", "userSchema", "oidcTokenExchange", "improvedPerformance", "oidcSingleV1SessionTermination", "disableUserTokenEvent", "enableBackChannelLogout", "loginV2", "permissionCheckV2"] + __properties: ClassVar[List[str]] = ["details", "loginDefaultOrg", "userSchema", "oidcTokenExchange", "improvedPerformance", "oidcSingleV1SessionTermination", "enableBackChannelLogout", "loginV2", "permissionCheckV2"] model_config = ConfigDict( populate_by_name=True, @@ -99,9 +98,6 @@ def to_dict(self) -> Dict[str, Any]: # override the default output from pydantic by calling `to_dict()` of oidc_single_v1_session_termination if self.oidc_single_v1_session_termination: _dict['oidcSingleV1SessionTermination'] = self.oidc_single_v1_session_termination.to_dict() - # override the default output from pydantic by calling `to_dict()` of disable_user_token_event - if self.disable_user_token_event: - _dict['disableUserTokenEvent'] = self.disable_user_token_event.to_dict() # override the default output from pydantic by calling `to_dict()` of enable_back_channel_logout if self.enable_back_channel_logout: _dict['enableBackChannelLogout'] = self.enable_back_channel_logout.to_dict() @@ -129,7 +125,6 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: "oidcTokenExchange": FeatureServiceFeatureFlag.from_dict(obj["oidcTokenExchange"]) if obj.get("oidcTokenExchange") is not None else None, "improvedPerformance": FeatureServiceImprovedPerformanceFeatureFlag.from_dict(obj["improvedPerformance"]) if obj.get("improvedPerformance") is not None else None, "oidcSingleV1SessionTermination": FeatureServiceFeatureFlag.from_dict(obj["oidcSingleV1SessionTermination"]) if obj.get("oidcSingleV1SessionTermination") is not None else None, - "disableUserTokenEvent": FeatureServiceFeatureFlag.from_dict(obj["disableUserTokenEvent"]) if obj.get("disableUserTokenEvent") is not None else None, "enableBackChannelLogout": FeatureServiceFeatureFlag.from_dict(obj["enableBackChannelLogout"]) if obj.get("enableBackChannelLogout") is not None else None, "loginV2": FeatureServiceLoginV2FeatureFlag.from_dict(obj["loginV2"]) if obj.get("loginV2") is not None else None, "permissionCheckV2": FeatureServiceFeatureFlag.from_dict(obj["permissionCheckV2"]) if obj.get("permissionCheckV2") is not None else None diff --git a/zitadel_client/models/feature_service_improved_performance.py b/zitadel_client/models/feature_service_improved_performance.py index ea98a8c..9c75611 100644 --- a/zitadel_client/models/feature_service_improved_performance.py +++ b/zitadel_client/models/feature_service_improved_performance.py @@ -27,7 +27,6 @@ class FeatureServiceImprovedPerformance(str, Enum): allowed enum values """ IMPROVED_PERFORMANCE_UNSPECIFIED = 'IMPROVED_PERFORMANCE_UNSPECIFIED' - IMPROVED_PERFORMANCE_ORG_BY_ID = 'IMPROVED_PERFORMANCE_ORG_BY_ID' IMPROVED_PERFORMANCE_PROJECT_GRANT = 'IMPROVED_PERFORMANCE_PROJECT_GRANT' IMPROVED_PERFORMANCE_PROJECT = 'IMPROVED_PERFORMANCE_PROJECT' IMPROVED_PERFORMANCE_USER_GRANT = 'IMPROVED_PERFORMANCE_USER_GRANT' diff --git a/zitadel_client/models/feature_service_set_instance_features_request.py b/zitadel_client/models/feature_service_set_instance_features_request.py index e5d5e6e..b340e54 100644 --- a/zitadel_client/models/feature_service_set_instance_features_request.py +++ b/zitadel_client/models/feature_service_set_instance_features_request.py @@ -34,12 +34,11 @@ class FeatureServiceSetInstanceFeaturesRequest(BaseModel): improved_performance: Optional[List[FeatureServiceImprovedPerformance]] = Field(default=None, alias="improvedPerformance") debug_oidc_parent_error: Optional[StrictBool] = Field(default=None, alias="debugOidcParentError") oidc_single_v1_session_termination: Optional[StrictBool] = Field(default=None, alias="oidcSingleV1SessionTermination") - disable_user_token_event: Optional[StrictBool] = Field(default=None, alias="disableUserTokenEvent") enable_back_channel_logout: Optional[StrictBool] = Field(default=None, alias="enableBackChannelLogout") login_v2: Optional[FeatureServiceLoginV2] = Field(default=None, alias="loginV2") permission_check_v2: Optional[StrictBool] = Field(default=None, alias="permissionCheckV2") console_use_v2_user_api: Optional[StrictBool] = Field(default=None, alias="consoleUseV2UserApi") - __properties: ClassVar[List[str]] = ["loginDefaultOrg", "userSchema", "oidcTokenExchange", "improvedPerformance", "debugOidcParentError", "oidcSingleV1SessionTermination", "disableUserTokenEvent", "enableBackChannelLogout", "loginV2", "permissionCheckV2", "consoleUseV2UserApi"] + __properties: ClassVar[List[str]] = ["loginDefaultOrg", "userSchema", "oidcTokenExchange", "improvedPerformance", "debugOidcParentError", "oidcSingleV1SessionTermination", "enableBackChannelLogout", "loginV2", "permissionCheckV2", "consoleUseV2UserApi"] model_config = ConfigDict( populate_by_name=True, @@ -108,11 +107,6 @@ def to_dict(self) -> Dict[str, Any]: if self.oidc_single_v1_session_termination is None and "oidc_single_v1_session_termination" in self.model_fields_set: _dict['oidcSingleV1SessionTermination'] = None - # set to None if disable_user_token_event (nullable) is None - # and model_fields_set contains the field - if self.disable_user_token_event is None and "disable_user_token_event" in self.model_fields_set: - _dict['disableUserTokenEvent'] = None - # set to None if enable_back_channel_logout (nullable) is None # and model_fields_set contains the field if self.enable_back_channel_logout is None and "enable_back_channel_logout" in self.model_fields_set: @@ -146,7 +140,6 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: "improvedPerformance": obj.get("improvedPerformance"), "debugOidcParentError": obj.get("debugOidcParentError"), "oidcSingleV1SessionTermination": obj.get("oidcSingleV1SessionTermination"), - "disableUserTokenEvent": obj.get("disableUserTokenEvent"), "enableBackChannelLogout": obj.get("enableBackChannelLogout"), "loginV2": FeatureServiceLoginV2.from_dict(obj["loginV2"]) if obj.get("loginV2") is not None else None, "permissionCheckV2": obj.get("permissionCheckV2"), diff --git a/zitadel_client/models/feature_service_set_system_features_request.py b/zitadel_client/models/feature_service_set_system_features_request.py index 22b3746..84eae0e 100644 --- a/zitadel_client/models/feature_service_set_system_features_request.py +++ b/zitadel_client/models/feature_service_set_system_features_request.py @@ -33,11 +33,10 @@ class FeatureServiceSetSystemFeaturesRequest(BaseModel): oidc_token_exchange: Optional[StrictBool] = Field(default=None, alias="oidcTokenExchange") improved_performance: Optional[List[FeatureServiceImprovedPerformance]] = Field(default=None, alias="improvedPerformance") oidc_single_v1_session_termination: Optional[StrictBool] = Field(default=None, alias="oidcSingleV1SessionTermination") - disable_user_token_event: Optional[StrictBool] = Field(default=None, alias="disableUserTokenEvent") enable_back_channel_logout: Optional[StrictBool] = Field(default=None, alias="enableBackChannelLogout") login_v2: Optional[FeatureServiceLoginV2] = Field(default=None, alias="loginV2") permission_check_v2: Optional[StrictBool] = Field(default=None, alias="permissionCheckV2") - __properties: ClassVar[List[str]] = ["loginDefaultOrg", "userSchema", "oidcTokenExchange", "improvedPerformance", "oidcSingleV1SessionTermination", "disableUserTokenEvent", "enableBackChannelLogout", "loginV2", "permissionCheckV2"] + __properties: ClassVar[List[str]] = ["loginDefaultOrg", "userSchema", "oidcTokenExchange", "improvedPerformance", "oidcSingleV1SessionTermination", "enableBackChannelLogout", "loginV2", "permissionCheckV2"] model_config = ConfigDict( populate_by_name=True, @@ -101,11 +100,6 @@ def to_dict(self) -> Dict[str, Any]: if self.oidc_single_v1_session_termination is None and "oidc_single_v1_session_termination" in self.model_fields_set: _dict['oidcSingleV1SessionTermination'] = None - # set to None if disable_user_token_event (nullable) is None - # and model_fields_set contains the field - if self.disable_user_token_event is None and "disable_user_token_event" in self.model_fields_set: - _dict['disableUserTokenEvent'] = None - # set to None if enable_back_channel_logout (nullable) is None # and model_fields_set contains the field if self.enable_back_channel_logout is None and "enable_back_channel_logout" in self.model_fields_set: @@ -133,7 +127,6 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: "oidcTokenExchange": obj.get("oidcTokenExchange"), "improvedPerformance": obj.get("improvedPerformance"), "oidcSingleV1SessionTermination": obj.get("oidcSingleV1SessionTermination"), - "disableUserTokenEvent": obj.get("disableUserTokenEvent"), "enableBackChannelLogout": obj.get("enableBackChannelLogout"), "loginV2": FeatureServiceLoginV2.from_dict(obj["loginV2"]) if obj.get("loginV2") is not None else None, "permissionCheckV2": obj.get("permissionCheckV2") diff --git a/zitadel_client/models/identity_provider_service_saml_config.py b/zitadel_client/models/identity_provider_service_saml_config.py index aac2ab9..242a799 100644 --- a/zitadel_client/models/identity_provider_service_saml_config.py +++ b/zitadel_client/models/identity_provider_service_saml_config.py @@ -21,6 +21,7 @@ from typing import Any, ClassVar, Dict, Optional, Union from zitadel_client.models.identity_provider_service_saml_binding import IdentityProviderServiceSAMLBinding from zitadel_client.models.identity_provider_service_saml_name_id_format import IdentityProviderServiceSAMLNameIDFormat +from zitadel_client.models.identity_provider_service_saml_signature_algorithm import IdentityProviderServiceSAMLSignatureAlgorithm from typing import Optional, Set from typing_extensions import Self @@ -34,7 +35,8 @@ class IdentityProviderServiceSAMLConfig(BaseModel): name_id_format: Optional[IdentityProviderServiceSAMLNameIDFormat] = Field(default=None, alias="nameIdFormat") transient_mapping_attribute_name: Optional[StrictStr] = Field(default=None, description="Optional name of the attribute, which will be used to map the user in case the nameid-format returned is `urn:oasis:names:tc:SAML:2.0:nameid-format:transient`.", alias="transientMappingAttributeName") federated_logout_enabled: Optional[StrictBool] = Field(default=None, description="Boolean weather federated logout is enabled. If enabled, ZITADEL will send a logout request to the identity provider, if the user terminates the session in ZITADEL. Be sure to provide a SLO endpoint as part of the metadata.", alias="federatedLogoutEnabled") - __properties: ClassVar[List[str]] = ["metadataXml", "binding", "withSignedRequest", "nameIdFormat", "transientMappingAttributeName", "federatedLogoutEnabled"] + signature_algorithm: Optional[IdentityProviderServiceSAMLSignatureAlgorithm] = Field(default=None, alias="signatureAlgorithm") + __properties: ClassVar[List[str]] = ["metadataXml", "binding", "withSignedRequest", "nameIdFormat", "transientMappingAttributeName", "federatedLogoutEnabled", "signatureAlgorithm"] model_config = ConfigDict( populate_by_name=True, @@ -102,7 +104,8 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: "withSignedRequest": obj.get("withSignedRequest"), "nameIdFormat": obj.get("nameIdFormat"), "transientMappingAttributeName": obj.get("transientMappingAttributeName"), - "federatedLogoutEnabled": obj.get("federatedLogoutEnabled") + "federatedLogoutEnabled": obj.get("federatedLogoutEnabled"), + "signatureAlgorithm": obj.get("signatureAlgorithm") }) return _obj diff --git a/zitadel_client/models/identity_provider_service_saml_signature_algorithm.py b/zitadel_client/models/identity_provider_service_saml_signature_algorithm.py new file mode 100644 index 0000000..2cbb715 --- /dev/null +++ b/zitadel_client/models/identity_provider_service_saml_signature_algorithm.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + Zitadel SDK + + The Zitadel SDK is a convenience wrapper around the Zitadel APIs to assist you in integrating with your Zitadel environment. This SDK enables you to handle resources, settings, and configurations within the Zitadel platform. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import json +from enum import Enum +from typing_extensions import Self + + +class IdentityProviderServiceSAMLSignatureAlgorithm(str, Enum): + """ + IdentityProviderServiceSAMLSignatureAlgorithm + """ + + """ + allowed enum values + """ + SAML_SIGNATURE_UNSPECIFIED = 'SAML_SIGNATURE_UNSPECIFIED' + SAML_SIGNATURE_RSA_SHA1 = 'SAML_SIGNATURE_RSA_SHA1' + SAML_SIGNATURE_RSA_SHA256 = 'SAML_SIGNATURE_RSA_SHA256' + SAML_SIGNATURE_RSA_SHA512 = 'SAML_SIGNATURE_RSA_SHA512' + + @classmethod + def from_json(cls, json_str: str) -> Self: + """Create an instance of IdentityProviderServiceSAMLSignatureAlgorithm from a JSON string""" + return cls(json.loads(json_str)) + + diff --git a/zitadel_client/models/session_service_expiration_date_query.py b/zitadel_client/models/session_service_expiration_date_query.py new file mode 100644 index 0000000..2c9accc --- /dev/null +++ b/zitadel_client/models/session_service_expiration_date_query.py @@ -0,0 +1,91 @@ +# coding: utf-8 + +""" + Zitadel SDK + + The Zitadel SDK is a convenience wrapper around the Zitadel APIs to assist you in integrating with your Zitadel environment. This SDK enables you to handle resources, settings, and configurations within the Zitadel platform. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import pprint +import re # noqa: F401 +import json + +from datetime import datetime +from pydantic import BaseModel, ConfigDict, Field +from typing import Any, ClassVar, Dict, Optional +from zitadel_client.models.session_service_timestamp_query_method import SessionServiceTimestampQueryMethod +from typing import Optional, Set +from typing_extensions import Self + +class SessionServiceExpirationDateQuery(BaseModel): + """ + SessionServiceExpirationDateQuery + """ # noqa: E501 + expiration_date: Optional[datetime] = Field(default=None, description="A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. All minutes are 60 seconds long. Leap seconds are \"smeared\" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. # Examples Example 1: Compute Timestamp from POSIX `time()`. Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); Example 2: Compute Timestamp from POSIX `gettimeofday()`. struct timeval tv; gettimeofday(&tv, NULL); Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. Timestamp timestamp; timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); timestamp.set_nanos((INT32) ((ticks % 10000000) * 100)); Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. long millis = System.currentTimeMillis(); Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); Example 5: Compute Timestamp from Java `Instant.now()`. Instant now = Instant.now(); Timestamp timestamp = Timestamp.newBuilder().setSeconds(now.getEpochSecond()) .setNanos(now.getNano()).build(); Example 6: Compute Timestamp from current time in Python. timestamp = Timestamp() timestamp.GetCurrentTime() # JSON Mapping In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is \"{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z\" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The \"Z\" suffix indicates the timezone (\"UTC\"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by \"Z\") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset). For example, \"2017-01-15T01:30:15.01Z\" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime() ) to obtain a formatter capable of generating timestamps in this format.", alias="expirationDate") + method: Optional[SessionServiceTimestampQueryMethod] = None + __properties: ClassVar[List[str]] = ["expirationDate", "method"] + + model_config = ConfigDict( + populate_by_name=True, + validate_assignment=True, + protected_namespaces=(), + ) + + + def to_str(self) -> str: + """Returns the string representation of the model using alias""" + return pprint.pformat(self.model_dump(by_alias=True)) + + def to_json(self) -> str: + """Returns the JSON representation of the model using alias""" + # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead + return json.dumps(self.to_dict()) + + @classmethod + def from_json(cls, json_str: str) -> Optional[Self]: + """Create an instance of SessionServiceExpirationDateQuery from a JSON string""" + return cls.from_dict(json.loads(json_str)) + + def to_dict(self) -> Dict[str, Any]: + """Return the dictionary representation of the model using alias. + + This has the following differences from calling pydantic's + `self.model_dump(by_alias=True)`: + + * `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + """ + excluded_fields: Set[str] = set([ + ]) + + _dict = self.model_dump( + by_alias=True, + exclude=excluded_fields, + exclude_none=True, + ) + return _dict + + @classmethod + def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: + """Create an instance of SessionServiceExpirationDateQuery from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _obj = cls.model_validate({ + "expirationDate": obj.get("expirationDate"), + "method": obj.get("method") + }) + return _obj + + diff --git a/zitadel_client/models/session_service_search_query.py b/zitadel_client/models/session_service_search_query.py index 73c6c7d..aec30e3 100644 --- a/zitadel_client/models/session_service_search_query.py +++ b/zitadel_client/models/session_service_search_query.py @@ -21,6 +21,7 @@ from typing import Any, ClassVar, Dict, Optional from zitadel_client.models.session_service_creation_date_query import SessionServiceCreationDateQuery from zitadel_client.models.session_service_creator_query import SessionServiceCreatorQuery +from zitadel_client.models.session_service_expiration_date_query import SessionServiceExpirationDateQuery from zitadel_client.models.session_service_ids_query import SessionServiceIDsQuery from zitadel_client.models.session_service_user_agent_query import SessionServiceUserAgentQuery from zitadel_client.models.session_service_user_id_query import SessionServiceUserIDQuery @@ -33,10 +34,11 @@ class SessionServiceSearchQuery(BaseModel): """ # noqa: E501 creation_date_query: Optional[SessionServiceCreationDateQuery] = Field(default=None, alias="creationDateQuery") creator_query: Optional[SessionServiceCreatorQuery] = Field(default=None, alias="creatorQuery") + expiration_date_query: Optional[SessionServiceExpirationDateQuery] = Field(default=None, alias="expirationDateQuery") ids_query: Optional[SessionServiceIDsQuery] = Field(default=None, alias="idsQuery") user_agent_query: Optional[SessionServiceUserAgentQuery] = Field(default=None, alias="userAgentQuery") user_id_query: Optional[SessionServiceUserIDQuery] = Field(default=None, alias="userIdQuery") - __properties: ClassVar[List[str]] = ["creationDateQuery", "creatorQuery", "idsQuery", "userAgentQuery", "userIdQuery"] + __properties: ClassVar[List[str]] = ["creationDateQuery", "creatorQuery", "expirationDateQuery", "idsQuery", "userAgentQuery", "userIdQuery"] model_config = ConfigDict( populate_by_name=True, @@ -83,6 +85,9 @@ def to_dict(self) -> Dict[str, Any]: # override the default output from pydantic by calling `to_dict()` of creator_query if self.creator_query: _dict['creatorQuery'] = self.creator_query.to_dict() + # override the default output from pydantic by calling `to_dict()` of expiration_date_query + if self.expiration_date_query: + _dict['expirationDateQuery'] = self.expiration_date_query.to_dict() # override the default output from pydantic by calling `to_dict()` of ids_query if self.ids_query: _dict['idsQuery'] = self.ids_query.to_dict() @@ -106,6 +111,7 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: _obj = cls.model_validate({ "creationDateQuery": SessionServiceCreationDateQuery.from_dict(obj["creationDateQuery"]) if obj.get("creationDateQuery") is not None else None, "creatorQuery": SessionServiceCreatorQuery.from_dict(obj["creatorQuery"]) if obj.get("creatorQuery") is not None else None, + "expirationDateQuery": SessionServiceExpirationDateQuery.from_dict(obj["expirationDateQuery"]) if obj.get("expirationDateQuery") is not None else None, "idsQuery": SessionServiceIDsQuery.from_dict(obj["idsQuery"]) if obj.get("idsQuery") is not None else None, "userAgentQuery": SessionServiceUserAgentQuery.from_dict(obj["userAgentQuery"]) if obj.get("userAgentQuery") is not None else None, "userIdQuery": SessionServiceUserIDQuery.from_dict(obj["userIdQuery"]) if obj.get("userIdQuery") is not None else None diff --git a/zitadel_client/models/user_service_byte_filter_method.py b/zitadel_client/models/user_service_byte_filter_method.py new file mode 100644 index 0000000..e7a6c27 --- /dev/null +++ b/zitadel_client/models/user_service_byte_filter_method.py @@ -0,0 +1,37 @@ +# coding: utf-8 + +""" + Zitadel SDK + + The Zitadel SDK is a convenience wrapper around the Zitadel APIs to assist you in integrating with your Zitadel environment. This SDK enables you to handle resources, settings, and configurations within the Zitadel platform. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import json +from enum import Enum +from typing_extensions import Self + + +class UserServiceByteFilterMethod(str, Enum): + """ + UserServiceByteFilterMethod + """ + + """ + allowed enum values + """ + BYTE_FILTER_METHOD_EQUALS = 'BYTE_FILTER_METHOD_EQUALS' + BYTE_FILTER_METHOD_NOT_EQUALS = 'BYTE_FILTER_METHOD_NOT_EQUALS' + + @classmethod + def from_json(cls, json_str: str) -> Self: + """Create an instance of UserServiceByteFilterMethod from a JSON string""" + return cls(json.loads(json_str)) + + diff --git a/zitadel_client/models/user_service_metadata_value_filter.py b/zitadel_client/models/user_service_metadata_value_filter.py new file mode 100644 index 0000000..4896ae8 --- /dev/null +++ b/zitadel_client/models/user_service_metadata_value_filter.py @@ -0,0 +1,90 @@ +# coding: utf-8 + +""" + Zitadel SDK + + The Zitadel SDK is a convenience wrapper around the Zitadel APIs to assist you in integrating with your Zitadel environment. This SDK enables you to handle resources, settings, and configurations within the Zitadel platform. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import pprint +import re # noqa: F401 +import json + +from pydantic import BaseModel, ConfigDict, StrictBytes, StrictStr +from typing import Any, ClassVar, Dict, Optional, Union +from zitadel_client.models.user_service_byte_filter_method import UserServiceByteFilterMethod +from typing import Optional, Set +from typing_extensions import Self + +class UserServiceMetadataValueFilter(BaseModel): + """ + UserServiceMetadataValueFilter + """ # noqa: E501 + value: Optional[Union[StrictBytes, StrictStr]] = None + method: Optional[UserServiceByteFilterMethod] = None + __properties: ClassVar[List[str]] = ["value", "method"] + + model_config = ConfigDict( + populate_by_name=True, + validate_assignment=True, + protected_namespaces=(), + ) + + + def to_str(self) -> str: + """Returns the string representation of the model using alias""" + return pprint.pformat(self.model_dump(by_alias=True)) + + def to_json(self) -> str: + """Returns the JSON representation of the model using alias""" + # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead + return json.dumps(self.to_dict()) + + @classmethod + def from_json(cls, json_str: str) -> Optional[Self]: + """Create an instance of UserServiceMetadataValueFilter from a JSON string""" + return cls.from_dict(json.loads(json_str)) + + def to_dict(self) -> Dict[str, Any]: + """Return the dictionary representation of the model using alias. + + This has the following differences from calling pydantic's + `self.model_dump(by_alias=True)`: + + * `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + """ + excluded_fields: Set[str] = set([ + ]) + + _dict = self.model_dump( + by_alias=True, + exclude=excluded_fields, + exclude_none=True, + ) + return _dict + + @classmethod + def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: + """Create an instance of UserServiceMetadataValueFilter from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _obj = cls.model_validate({ + "value": obj.get("value"), + "method": obj.get("method") + }) + return _obj + + diff --git a/zitadel_client/models/user_service_search_query.py b/zitadel_client/models/user_service_search_query.py index da7a9fc..84797d7 100644 --- a/zitadel_client/models/user_service_search_query.py +++ b/zitadel_client/models/user_service_search_query.py @@ -26,6 +26,8 @@ from zitadel_client.models.user_service_in_user_id_query import UserServiceInUserIDQuery from zitadel_client.models.user_service_last_name_query import UserServiceLastNameQuery from zitadel_client.models.user_service_login_name_query import UserServiceLoginNameQuery +from zitadel_client.models.user_service_metadata_key_filter import UserServiceMetadataKeyFilter +from zitadel_client.models.user_service_metadata_value_filter import UserServiceMetadataValueFilter from zitadel_client.models.user_service_nick_name_query import UserServiceNickNameQuery from zitadel_client.models.user_service_organization_id_query import UserServiceOrganizationIdQuery from zitadel_client.models.user_service_phone_query import UserServicePhoneQuery @@ -47,6 +49,8 @@ class UserServiceSearchQuery(BaseModel): in_user_ids_query: Optional[UserServiceInUserIDQuery] = Field(default=None, alias="inUserIdsQuery") last_name_query: Optional[UserServiceLastNameQuery] = Field(default=None, alias="lastNameQuery") login_name_query: Optional[UserServiceLoginNameQuery] = Field(default=None, alias="loginNameQuery") + metadata_key_filter: Optional[UserServiceMetadataKeyFilter] = Field(default=None, alias="metadataKeyFilter") + metadata_value_filter: Optional[UserServiceMetadataValueFilter] = Field(default=None, alias="metadataValueFilter") nick_name_query: Optional[UserServiceNickNameQuery] = Field(default=None, alias="nickNameQuery") not_query: Optional[UserServiceNotQuery] = Field(default=None, alias="notQuery") or_query: Optional[UserServiceOrQuery] = Field(default=None, alias="orQuery") @@ -55,7 +59,7 @@ class UserServiceSearchQuery(BaseModel): state_query: Optional[UserServiceStateQuery] = Field(default=None, alias="stateQuery") type_query: Optional[UserServiceTypeQuery] = Field(default=None, alias="typeQuery") user_name_query: Optional[UserServiceUserNameQuery] = Field(default=None, alias="userNameQuery") - __properties: ClassVar[List[str]] = ["andQuery", "displayNameQuery", "emailQuery", "firstNameQuery", "inUserEmailsQuery", "inUserIdsQuery", "lastNameQuery", "loginNameQuery", "nickNameQuery", "notQuery", "orQuery", "organizationIdQuery", "phoneQuery", "stateQuery", "typeQuery", "userNameQuery"] + __properties: ClassVar[List[str]] = ["andQuery", "displayNameQuery", "emailQuery", "firstNameQuery", "inUserEmailsQuery", "inUserIdsQuery", "lastNameQuery", "loginNameQuery", "metadataKeyFilter", "metadataValueFilter", "nickNameQuery", "notQuery", "orQuery", "organizationIdQuery", "phoneQuery", "stateQuery", "typeQuery", "userNameQuery"] model_config = ConfigDict( populate_by_name=True, @@ -120,6 +124,12 @@ def to_dict(self) -> Dict[str, Any]: # override the default output from pydantic by calling `to_dict()` of login_name_query if self.login_name_query: _dict['loginNameQuery'] = self.login_name_query.to_dict() + # override the default output from pydantic by calling `to_dict()` of metadata_key_filter + if self.metadata_key_filter: + _dict['metadataKeyFilter'] = self.metadata_key_filter.to_dict() + # override the default output from pydantic by calling `to_dict()` of metadata_value_filter + if self.metadata_value_filter: + _dict['metadataValueFilter'] = self.metadata_value_filter.to_dict() # override the default output from pydantic by calling `to_dict()` of nick_name_query if self.nick_name_query: _dict['nickNameQuery'] = self.nick_name_query.to_dict() @@ -164,6 +174,8 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: "inUserIdsQuery": UserServiceInUserIDQuery.from_dict(obj["inUserIdsQuery"]) if obj.get("inUserIdsQuery") is not None else None, "lastNameQuery": UserServiceLastNameQuery.from_dict(obj["lastNameQuery"]) if obj.get("lastNameQuery") is not None else None, "loginNameQuery": UserServiceLoginNameQuery.from_dict(obj["loginNameQuery"]) if obj.get("loginNameQuery") is not None else None, + "metadataKeyFilter": UserServiceMetadataKeyFilter.from_dict(obj["metadataKeyFilter"]) if obj.get("metadataKeyFilter") is not None else None, + "metadataValueFilter": UserServiceMetadataValueFilter.from_dict(obj["metadataValueFilter"]) if obj.get("metadataValueFilter") is not None else None, "nickNameQuery": UserServiceNickNameQuery.from_dict(obj["nickNameQuery"]) if obj.get("nickNameQuery") is not None else None, "notQuery": UserServiceNotQuery.from_dict(obj["notQuery"]) if obj.get("notQuery") is not None else None, "orQuery": UserServiceOrQuery.from_dict(obj["orQuery"]) if obj.get("orQuery") is not None else None,