text: # Copyright (c) 2021 AccelByte Inc. All Rights Reserved.
  # This is licensed software from AccelByte Inc, for limitations
  # and restrictions contact your company contract manager.
  # 
  # Code generated. DO NOT EDIT!
  
  # template file: justice_py_sdk_codegen/__main__.py
  
  # pylint: disable=duplicate-code
  # pylint: disable=line-too-long
  # pylint: disable=missing-function-docstring
  # pylint: disable=missing-function-docstring
  # pylint: disable=missing-module-docstring
  # pylint: disable=too-many-arguments
  # pylint: disable=too-many-branches
  # pylint: disable=too-many-instance-attributes
  # pylint: disable=too-many-lines
  # pylint: disable=too-many-locals
  # pylint: disable=too-many-public-methods
  # pylint: disable=too-many-return-statements
  # pylint: disable=too-many-statements
  # pylint: disable=unused-import
  
  from typing import Any, Dict, List, Optional, Tuple, Union
  
  from ....core import HeaderStr
  from ....core import get_namespace as get_services_namespace
  from ....core import run_request
  from ....core import run_request_async
  from ....core import same_doc_as
  
  from ..models import ErrorEntity
  from ..models import PassCreate
  from ..models import PassInfo
  from ..models import PassUpdate
  from ..models import UserPassGrant
  from ..models import UserSeasonSummary
  from ..models import ValidationErrorEntity
  
  from ..operations.pass_ import CreatePass
  from ..operations.pass_ import DeletePass
  from ..operations.pass_ import GetPass
  from ..operations.pass_ import GrantUserPass
  from ..operations.pass_ import QueryPasses
  from ..operations.pass_ import UpdatePass
  
  
  @same_doc_as(CreatePass)
  def create_pass(season_id: str, body: Optional[PassCreate] = None, namespace: Optional[str] = None, x_additional_headers: Optional[Dict[str, str]] = None, **kwargs):
      if namespace is None:
          namespace, error = get_services_namespace()
          if error:
              return None, error
      request = CreatePass.create(
          season_id=season_id,
          body=body,
          namespace=namespace,
      )
      return run_request(request, additional_headers=x_additional_headers, **kwargs)
  
  
  @same_doc_as(CreatePass)
  async def create_pass_async(season_id: str, body: Optional[PassCreate] = None, namespace: Optional[str] = None, x_additional_headers: Optional[Dict[str, str]] = None, **kwargs):
      if namespace is None:
          namespace, error = get_services_namespace()
          if error:
              return None, error
      request = CreatePass.create(
          season_id=season_id,
          body=body,
          namespace=namespace,
      )
      return await run_request_async(request, additional_headers=x_additional_headers, **kwargs)
  
  
  @same_doc_as(DeletePass)
  def delete_pass(code: str, season_id: str, namespace: Optional[str] = None, x_additional_headers: Optional[Dict[str, str]] = None, **kwargs):
      if namespace is None:
          namespace, error = get_services_namespace()
          if error:
              return None, error
      request = DeletePass.create(
          code=code,
          season_id=season_id,
          namespace=namespace,
      )
      return run_request(request, additional_headers=x_additional_headers, **kwargs)
  
  
  @same_doc_as(DeletePass)
  async def delete_pass_async(code: str, season_id: str, namespace: Optional[str] = None, x_additional_headers: Optional[Dict[str, str]] = None, **kwargs):
      if namespace is None:
          namespace, error = get_services_namespace()
          if error:
              return None, error
      request = DeletePass.create(
          code=code,
          season_id=season_id,
          namespace=namespace,
      )
      return await run_request_async(request, additional_headers=x_additional_headers, **kwargs)
  
  
  @same_doc_as(GetPass)
  def get_pass(code: str, season_id: str, namespace: Optional[str] = None, x_additional_headers: Optional[Dict[str, str]] = None, **kwargs):
      if namespace is None:
          namespace, error = get_services_namespace()
          if error:
              return None, error
      request = GetPass.create(
          code=code,
          season_id=season_id,
          namespace=namespace,
      )
      return run_request(request, additional_headers=x_additional_headers, **kwargs)
  
  
  @same_doc_as(GetPass)
  async def get_pass_async(code: str, season_id: str, namespace: Optional[str] = None, x_additional_headers: Optional[Dict[str, str]] = None, **kwargs):
      if namespace is None:
          namespace, error = get_services_namespace()
          if error:
              return None, error
      request = GetPass.create(
          code=code,
          season_id=season_id,
          namespace=namespace,
      )
      return await run_request_async(request, additional_headers=x_additional_headers, **kwargs)
  
  
  @same_doc_as(GrantUserPass)
  def grant_user_pass(user_id: str, body: Optional[UserPassGrant] = None, namespace: Optional[str] = None, x_additional_headers: Optional[Dict[str, str]] = None, **kwargs):
      if namespace is None:
          namespace, error = get_services_namespace()
          if error:
              return None, error
      request = GrantUserPass.create(
          user_id=user_id,
          body=body,
          namespace=namespace,
      )
      return run_request(request, additional_headers=x_additional_headers, **kwargs)
  
  
  @same_doc_as(GrantUserPass)
  async def grant_user_pass_async(user_id: str, body: Optional[UserPassGrant] = None, namespace: Optional[str] = None, x_additional_headers: Optional[Dict[str, str]] = None, **kwargs):
      if namespace is None:
          namespace, error = get_services_namespace()
          if error:
              return None, error
      request = GrantUserPass.create(
          user_id=user_id,
          body=body,
          namespace=namespace,
      )
      return await run_request_async(request, additional_headers=x_additional_headers, **kwargs)
  
  
  @same_doc_as(QueryPasses)
  def query_passes(season_id: str, namespace: Optional[str] = None, x_additional_headers: Optional[Dict[str, str]] = None, **kwargs):
      if namespace is None:
          namespace, error = get_services_namespace()
          if error:
              return None, error
      request = QueryPasses.create(
          season_id=season_id,
          namespace=namespace,
      )
      return run_request(request, additional_headers=x_additional_headers, **kwargs)
  
  
  @same_doc_as(QueryPasses)
  async def query_passes_async(season_id: str, namespace: Optional[str] = None, x_additional_headers: Optional[Dict[str, str]] = None, **kwargs):
      if namespace is None:
          namespace, error = get_services_namespace()
          if error:
              return None, error
      request = QueryPasses.create(
          season_id=season_id,
          namespace=namespace,
      )
      return await run_request_async(request, additional_headers=x_additional_headers, **kwargs)
  
  
  @same_doc_as(UpdatePass)
  def update_pass(code: str, season_id: str, body: Optional[PassUpdate] = None, namespace: Optional[str] = None, x_additional_headers: Optional[Dict[str, str]] = None, **kwargs):
      if namespace is None:
          namespace, error = get_services_namespace()
          if error:
              return None, error
      request = UpdatePass.create(
          code=code,
          season_id=season_id,
          body=body,
          namespace=namespace,
      )
      return run_request(request, additional_headers=x_additional_headers, **kwargs)
  
  
  @same_doc_as(UpdatePass)
  async def update_pass_async(code: str, season_id: str, body: Optional[PassUpdate] = None, namespace: Optional[str] = None, x_additional_headers: Optional[Dict[str, str]] = None, **kwargs):
      if namespace is None:
          namespace, error = get_services_namespace()
          if error:
              return None, error
      request = UpdatePass.create(
          code=code,
          season_id=season_id,
          body=body,
          namespace=namespace,
      )
      return await run_request_async(request, additional_headers=x_additional_headers, **kwargs)
  