import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api._Api;

import java.io.File;
import java.util.*;

public class _ApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        _Api apiInstance = new _Api();
        SaveExpenseRequest body = ; // SaveExpenseRequest | 
        Long teamId = 789; // Long | 해당 지출이 저장될 teamId
        try {
            SaveExpenseResponse result = apiInstance.addExpense(body, teamId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#addExpense");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api._Api;

public class _ApiExample {

    public static void main(String[] args) {
        _Api apiInstance = new _Api();
        SaveExpenseRequest body = ; // SaveExpenseRequest | 
        Long teamId = 789; // Long | 해당 지출이 저장될 teamId
        try {
            SaveExpenseResponse result = apiInstance.addExpense(body, teamId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#addExpense");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
SaveExpenseRequest *body = ; // 
Long *teamId = 789; // 해당 지출이 저장될 teamId

_Api *apiInstance = [[_Api alloc] init];

// 지출 내역 저장
[apiInstance addExpenseWith:body
    teamId:teamId
              completionHandler: ^(SaveExpenseResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KakaoTechCampusJeongSanApi_ = require('kakao_tech_campus__jeong_san__api_');
var defaultClient = KakaoTechCampusJeongSanApi_.ApiClient.instance;


var api = new KakaoTechCampusJeongSanApi_._Api()
var body = ; // {{SaveExpenseRequest}} 
var teamId = 789; // {{Long}} 해당 지출이 저장될 teamId

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addExpense(bodyteamId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class addExpenseExample
    {
        public void main()
        {


            var apiInstance = new _Api();
            var body = new SaveExpenseRequest(); // SaveExpenseRequest | 
            var teamId = 789;  // Long | 해당 지출이 저장될 teamId

            try
            {
                // 지출 내역 저장
                SaveExpenseResponse result = apiInstance.addExpense(body, teamId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling _Api.addExpense: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\Api_Api();
$body = ; // SaveExpenseRequest | 
$teamId = 789; // Long | 해당 지출이 저장될 teamId

try {
    $result = $api_instance->addExpense($body, $teamId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling _Api->addExpense: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::_Api;


my $api_instance = WWW::SwaggerClient::_Api->new();
my $body = WWW::SwaggerClient::Object::SaveExpenseRequest->new(); # SaveExpenseRequest | 
my $teamId = 789; # Long | 해당 지출이 저장될 teamId

eval { 
    my $result = $api_instance->addExpense(body => $body, teamId => $teamId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling _Api->addExpense: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client._Api()
body =  # SaveExpenseRequest | 
teamId = 789 # Long | 해당 지출이 저장될 teamId

try: 
    # 지출 내역 저장
    api_response = api_instance.add_expense(body, teamId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling _Api->addExpense: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api._Api;

import java.io.File;
import java.util.*;

public class _ApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        _Api apiInstance = new _Api();
        Image body = ; // Image | 
        try {
            ParsedReceiptResponse result = apiInstance.analyzeReceipt(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#analyzeReceipt");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api._Api;

public class _ApiExample {

    public static void main(String[] args) {
        _Api apiInstance = new _Api();
        Image body = ; // Image | 
        try {
            ParsedReceiptResponse result = apiInstance.analyzeReceipt(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#analyzeReceipt");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Image *body = ; // 

_Api *apiInstance = [[_Api alloc] init];

// 영수증 내역 분석&조회 API
[apiInstance analyzeReceiptWith:body
              completionHandler: ^(ParsedReceiptResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KakaoTechCampusJeongSanApi_ = require('kakao_tech_campus__jeong_san__api_');
var defaultClient = KakaoTechCampusJeongSanApi_.ApiClient.instance;


var api = new KakaoTechCampusJeongSanApi_._Api()
var body = ; // {{Image}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.analyzeReceipt(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class analyzeReceiptExample
    {
        public void main()
        {


            var apiInstance = new _Api();
            var body = new Image(); // Image | 

            try
            {
                // 영수증 내역 분석&조회 API
                ParsedReceiptResponse result = apiInstance.analyzeReceipt(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling _Api.analyzeReceipt: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\Api_Api();
$body = ; // Image | 

try {
    $result = $api_instance->analyzeReceipt($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling _Api->analyzeReceipt: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::_Api;


my $api_instance = WWW::SwaggerClient::_Api->new();
my $body = WWW::SwaggerClient::Object::Image->new(); # Image | 

eval { 
    my $result = $api_instance->analyzeReceipt(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling _Api->analyzeReceipt: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client._Api()
body =  # Image | 

try: 
    # 영수증 내역 분석&조회 API
    api_response = api_instance.analyze_receipt(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling _Api->analyzeReceipt: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api._Api;

import java.io.File;
import java.util.*;

public class _ApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        _Api apiInstance = new _Api();
        ChangeExpensesStateRequest body = ; // ChangeExpensesStateRequest | 
        Long teamId = 789; // Long | 상태 변경될 지출들의 모임 ID
        try {
            JeongsanApiResponseVoid result = apiInstance.changeExpensesStatus(body, teamId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#changeExpensesStatus");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api._Api;

public class _ApiExample {

    public static void main(String[] args) {
        _Api apiInstance = new _Api();
        ChangeExpensesStateRequest body = ; // ChangeExpensesStateRequest | 
        Long teamId = 789; // Long | 상태 변경될 지출들의 모임 ID
        try {
            JeongsanApiResponseVoid result = apiInstance.changeExpensesStatus(body, teamId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#changeExpensesStatus");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
ChangeExpensesStateRequest *body = ; // 
Long *teamId = 789; // 상태 변경될 지출들의 모임 ID

_Api *apiInstance = [[_Api alloc] init];

// 지출 상태 변경 요청 API
[apiInstance changeExpensesStatusWith:body
    teamId:teamId
              completionHandler: ^(JeongsanApiResponseVoid output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KakaoTechCampusJeongSanApi_ = require('kakao_tech_campus__jeong_san__api_');
var defaultClient = KakaoTechCampusJeongSanApi_.ApiClient.instance;


var api = new KakaoTechCampusJeongSanApi_._Api()
var body = ; // {{ChangeExpensesStateRequest}} 
var teamId = 789; // {{Long}} 상태 변경될 지출들의 모임 ID

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.changeExpensesStatus(bodyteamId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class changeExpensesStatusExample
    {
        public void main()
        {


            var apiInstance = new _Api();
            var body = new ChangeExpensesStateRequest(); // ChangeExpensesStateRequest | 
            var teamId = 789;  // Long | 상태 변경될 지출들의 모임 ID

            try
            {
                // 지출 상태 변경 요청 API
                JeongsanApiResponseVoid result = apiInstance.changeExpensesStatus(body, teamId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling _Api.changeExpensesStatus: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\Api_Api();
$body = ; // ChangeExpensesStateRequest | 
$teamId = 789; // Long | 상태 변경될 지출들의 모임 ID

try {
    $result = $api_instance->changeExpensesStatus($body, $teamId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling _Api->changeExpensesStatus: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::_Api;


my $api_instance = WWW::SwaggerClient::_Api->new();
my $body = WWW::SwaggerClient::Object::ChangeExpensesStateRequest->new(); # ChangeExpensesStateRequest | 
my $teamId = 789; # Long | 상태 변경될 지출들의 모임 ID

eval { 
    my $result = $api_instance->changeExpensesStatus(body => $body, teamId => $teamId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling _Api->changeExpensesStatus: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client._Api()
body =  # ChangeExpensesStateRequest | 
teamId = 789 # Long | 상태 변경될 지출들의 모임 ID

try: 
    # 지출 상태 변경 요청 API
    api_response = api_instance.change_expenses_status(body, teamId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling _Api->changeExpensesStatus: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api._Api;

import java.io.File;
import java.util.*;

public class _ApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        _Api apiInstance = new _Api();
        Long teamId = 789; // Long | 종료를 원하는 모임의 id
        try {
            apiInstance.closeTeam(teamId);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#closeTeam");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api._Api;

public class _ApiExample {

    public static void main(String[] args) {
        _Api apiInstance = new _Api();
        Long teamId = 789; // Long | 종료를 원하는 모임의 id
        try {
            apiInstance.closeTeam(teamId);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#closeTeam");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Long *teamId = 789; // 종료를 원하는 모임의 id

_Api *apiInstance = [[_Api alloc] init];

// 모임 종료 API
[apiInstance closeTeamWith:teamId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KakaoTechCampusJeongSanApi_ = require('kakao_tech_campus__jeong_san__api_');
var defaultClient = KakaoTechCampusJeongSanApi_.ApiClient.instance;


var api = new KakaoTechCampusJeongSanApi_._Api()
var teamId = 789; // {{Long}} 종료를 원하는 모임의 id

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.closeTeam(teamId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class closeTeamExample
    {
        public void main()
        {


            var apiInstance = new _Api();
            var teamId = 789;  // Long | 종료를 원하는 모임의 id

            try
            {
                // 모임 종료 API
                apiInstance.closeTeam(teamId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling _Api.closeTeam: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\Api_Api();
$teamId = 789; // Long | 종료를 원하는 모임의 id

try {
    $api_instance->closeTeam($teamId);
} catch (Exception $e) {
    echo 'Exception when calling _Api->closeTeam: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::_Api;


my $api_instance = WWW::SwaggerClient::_Api->new();
my $teamId = 789; # Long | 종료를 원하는 모임의 id

eval { 
    $api_instance->closeTeam(teamId => $teamId);
};
if ($@) {
    warn "Exception when calling _Api->closeTeam: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client._Api()
teamId = 789 # Long | 종료를 원하는 모임의 id

try: 
    # 모임 종료 API
    api_instance.close_team(teamId)
except ApiException as e:
    print("Exception when calling _Api->closeTeam: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api._Api;

import java.io.File;
import java.util.*;

public class _ApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        _Api apiInstance = new _Api();
        CreateTeamRequest body = ; // CreateTeamRequest | 
        String name = name_example; // String | 15글자 이내의 모임 이름. 모임의 owner 기준 동일한 모임 이름을 사용할 수 없음
        String subject = subject_example; // String | 모임의 목적. 이모지 사용
        String members = members_example; // String | 모임에 초대할 사용자들 ID
        try {
            JeongsanApiResponseCreateTeamResponse result = apiInstance.createTeam(body, name, subject, members);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#createTeam");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api._Api;

public class _ApiExample {

    public static void main(String[] args) {
        _Api apiInstance = new _Api();
        CreateTeamRequest body = ; // CreateTeamRequest | 
        String name = name_example; // String | 15글자 이내의 모임 이름. 모임의 owner 기준 동일한 모임 이름을 사용할 수 없음
        String subject = subject_example; // String | 모임의 목적. 이모지 사용
        String members = members_example; // String | 모임에 초대할 사용자들 ID
        try {
            JeongsanApiResponseCreateTeamResponse result = apiInstance.createTeam(body, name, subject, members);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#createTeam");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
CreateTeamRequest *body = ; // 
String *name = name_example; // 15글자 이내의 모임 이름. 모임의 owner 기준 동일한 모임 이름을 사용할 수 없음 (optional)
String *subject = subject_example; // 모임의 목적. 이모지 사용 (optional)
String *members = members_example; // 모임에 초대할 사용자들 ID (optional)

_Api *apiInstance = [[_Api alloc] init];

// 모임 생성 API
[apiInstance createTeamWith:body
    name:name
    subject:subject
    members:members
              completionHandler: ^(JeongsanApiResponseCreateTeamResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KakaoTechCampusJeongSanApi_ = require('kakao_tech_campus__jeong_san__api_');
var defaultClient = KakaoTechCampusJeongSanApi_.ApiClient.instance;


var api = new KakaoTechCampusJeongSanApi_._Api()
var body = ; // {{CreateTeamRequest}} 
var opts = { 
  'name': name_example // {{String}} 15글자 이내의 모임 이름. 모임의 owner 기준 동일한 모임 이름을 사용할 수 없음
  'subject': subject_example // {{String}} 모임의 목적. 이모지 사용
  'members': members_example // {{String}} 모임에 초대할 사용자들 ID
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createTeam(body, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createTeamExample
    {
        public void main()
        {


            var apiInstance = new _Api();
            var body = new CreateTeamRequest(); // CreateTeamRequest | 
            var name = name_example;  // String | 15글자 이내의 모임 이름. 모임의 owner 기준 동일한 모임 이름을 사용할 수 없음 (optional) 
            var subject = subject_example;  // String | 모임의 목적. 이모지 사용 (optional) 
            var members = members_example;  // String | 모임에 초대할 사용자들 ID (optional) 

            try
            {
                // 모임 생성 API
                JeongsanApiResponseCreateTeamResponse result = apiInstance.createTeam(body, name, subject, members);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling _Api.createTeam: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\Api_Api();
$body = ; // CreateTeamRequest | 
$name = name_example; // String | 15글자 이내의 모임 이름. 모임의 owner 기준 동일한 모임 이름을 사용할 수 없음
$subject = subject_example; // String | 모임의 목적. 이모지 사용
$members = members_example; // String | 모임에 초대할 사용자들 ID

try {
    $result = $api_instance->createTeam($body, $name, $subject, $members);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling _Api->createTeam: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::_Api;


my $api_instance = WWW::SwaggerClient::_Api->new();
my $body = WWW::SwaggerClient::Object::CreateTeamRequest->new(); # CreateTeamRequest | 
my $name = name_example; # String | 15글자 이내의 모임 이름. 모임의 owner 기준 동일한 모임 이름을 사용할 수 없음
my $subject = subject_example; # String | 모임의 목적. 이모지 사용
my $members = members_example; # String | 모임에 초대할 사용자들 ID

eval { 
    my $result = $api_instance->createTeam(body => $body, name => $name, subject => $subject, members => $members);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling _Api->createTeam: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client._Api()
body =  # CreateTeamRequest | 
name = name_example # String | 15글자 이내의 모임 이름. 모임의 owner 기준 동일한 모임 이름을 사용할 수 없음 (optional)
subject = subject_example # String | 모임의 목적. 이모지 사용 (optional)
members = members_example # String | 모임에 초대할 사용자들 ID (optional)

try: 
    # 모임 생성 API
    api_response = api_instance.create_team(body, name=name, subject=subject, members=members)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling _Api->createTeam: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api._Api;

import java.io.File;
import java.util.*;

public class _ApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        _Api apiInstance = new _Api();
        Long teamId = 789; // Long | 지출 내역 조회를 원하는 모임의 ID
        String state = state_example; // String | 지출 내역의 상태를 지정하는 쿼리 파라미터(`ongoing`, `pending`, `completed`)
        Boolean isChecked = true; // Boolean | `정산 중`상태의 지출 목록 중 사용자의 현재 선택한 상태를 지정하는 쿼리 파라미터
        try {
            ExpenseResponse result = apiInstance.getAllExpenses(teamId, state, isChecked);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#getAllExpenses");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api._Api;

public class _ApiExample {

    public static void main(String[] args) {
        _Api apiInstance = new _Api();
        Long teamId = 789; // Long | 지출 내역 조회를 원하는 모임의 ID
        String state = state_example; // String | 지출 내역의 상태를 지정하는 쿼리 파라미터(`ongoing`, `pending`, `completed`)
        Boolean isChecked = true; // Boolean | `정산 중`상태의 지출 목록 중 사용자의 현재 선택한 상태를 지정하는 쿼리 파라미터
        try {
            ExpenseResponse result = apiInstance.getAllExpenses(teamId, state, isChecked);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#getAllExpenses");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Long *teamId = 789; // 지출 내역 조회를 원하는 모임의 ID
String *state = state_example; // 지출 내역의 상태를 지정하는 쿼리 파라미터(`ongoing`, `pending`, `completed`)
Boolean *isChecked = true; // `정산 중`상태의 지출 목록 중 사용자의 현재 선택한 상태를 지정하는 쿼리 파라미터 (optional)

_Api *apiInstance = [[_Api alloc] init];

// 지출 내역 목록 조회 API
[apiInstance getAllExpensesWith:teamId
    state:state
    isChecked:isChecked
              completionHandler: ^(ExpenseResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KakaoTechCampusJeongSanApi_ = require('kakao_tech_campus__jeong_san__api_');
var defaultClient = KakaoTechCampusJeongSanApi_.ApiClient.instance;


var api = new KakaoTechCampusJeongSanApi_._Api()
var teamId = 789; // {{Long}} 지출 내역 조회를 원하는 모임의 ID
var state = state_example; // {{String}} 지출 내역의 상태를 지정하는 쿼리 파라미터(`ongoing`, `pending`, `completed`)
var opts = { 
  'isChecked': true // {{Boolean}} `정산 중`상태의 지출 목록 중 사용자의 현재 선택한 상태를 지정하는 쿼리 파라미터
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAllExpenses(teamId, state, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getAllExpensesExample
    {
        public void main()
        {


            var apiInstance = new _Api();
            var teamId = 789;  // Long | 지출 내역 조회를 원하는 모임의 ID
            var state = state_example;  // String | 지출 내역의 상태를 지정하는 쿼리 파라미터(`ongoing`, `pending`, `completed`)
            var isChecked = true;  // Boolean | `정산 중`상태의 지출 목록 중 사용자의 현재 선택한 상태를 지정하는 쿼리 파라미터 (optional) 

            try
            {
                // 지출 내역 목록 조회 API
                ExpenseResponse result = apiInstance.getAllExpenses(teamId, state, isChecked);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling _Api.getAllExpenses: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\Api_Api();
$teamId = 789; // Long | 지출 내역 조회를 원하는 모임의 ID
$state = state_example; // String | 지출 내역의 상태를 지정하는 쿼리 파라미터(`ongoing`, `pending`, `completed`)
$isChecked = true; // Boolean | `정산 중`상태의 지출 목록 중 사용자의 현재 선택한 상태를 지정하는 쿼리 파라미터

try {
    $result = $api_instance->getAllExpenses($teamId, $state, $isChecked);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling _Api->getAllExpenses: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::_Api;


my $api_instance = WWW::SwaggerClient::_Api->new();
my $teamId = 789; # Long | 지출 내역 조회를 원하는 모임의 ID
my $state = state_example; # String | 지출 내역의 상태를 지정하는 쿼리 파라미터(`ongoing`, `pending`, `completed`)
my $isChecked = true; # Boolean | `정산 중`상태의 지출 목록 중 사용자의 현재 선택한 상태를 지정하는 쿼리 파라미터

eval { 
    my $result = $api_instance->getAllExpenses(teamId => $teamId, state => $state, isChecked => $isChecked);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling _Api->getAllExpenses: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client._Api()
teamId = 789 # Long | 지출 내역 조회를 원하는 모임의 ID
state = state_example # String | 지출 내역의 상태를 지정하는 쿼리 파라미터(`ongoing`, `pending`, `completed`)
isChecked = true # Boolean | `정산 중`상태의 지출 목록 중 사용자의 현재 선택한 상태를 지정하는 쿼리 파라미터 (optional)

try: 
    # 지출 내역 목록 조회 API
    api_response = api_instance.get_all_expenses(teamId, state, isChecked=isChecked)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling _Api->getAllExpenses: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api._Api;

import java.io.File;
import java.util.*;

public class _ApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        _Api apiInstance = new _Api();
        try {
            CategoryListResponse result = apiInstance.getCategoryList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#getCategoryList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api._Api;

public class _ApiExample {

    public static void main(String[] args) {
        _Api apiInstance = new _Api();
        try {
            CategoryListResponse result = apiInstance.getCategoryList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#getCategoryList");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

_Api *apiInstance = [[_Api alloc] init];

// 카테고리 목록 조회 API
[apiInstance getCategoryListWithCompletionHandler: 
              ^(CategoryListResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KakaoTechCampusJeongSanApi_ = require('kakao_tech_campus__jeong_san__api_');
var defaultClient = KakaoTechCampusJeongSanApi_.ApiClient.instance;


var api = new KakaoTechCampusJeongSanApi_._Api()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getCategoryList(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getCategoryListExample
    {
        public void main()
        {


            var apiInstance = new _Api();

            try
            {
                // 카테고리 목록 조회 API
                CategoryListResponse result = apiInstance.getCategoryList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling _Api.getCategoryList: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\Api_Api();

try {
    $result = $api_instance->getCategoryList();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling _Api->getCategoryList: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::_Api;


my $api_instance = WWW::SwaggerClient::_Api->new();

eval { 
    my $result = $api_instance->getCategoryList();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling _Api->getCategoryList: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client._Api()

try: 
    # 카테고리 목록 조회 API
    api_response = api_instance.get_category_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling _Api->getCategoryList: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api._Api;

import java.io.File;
import java.util.*;

public class _ApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        _Api apiInstance = new _Api();
        Long expenseId = 789; // Long | 
        try {
            ExpenseDetailResponse result = apiInstance.getExpenseDetails(expenseId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#getExpenseDetails");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api._Api;

public class _ApiExample {

    public static void main(String[] args) {
        _Api apiInstance = new _Api();
        Long expenseId = 789; // Long | 
        try {
            ExpenseDetailResponse result = apiInstance.getExpenseDetails(expenseId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#getExpenseDetails");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Long *expenseId = 789; // 

_Api *apiInstance = [[_Api alloc] init];

// 지출 선택 현황 조회 API
[apiInstance getExpenseDetailsWith:expenseId
              completionHandler: ^(ExpenseDetailResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KakaoTechCampusJeongSanApi_ = require('kakao_tech_campus__jeong_san__api_');
var defaultClient = KakaoTechCampusJeongSanApi_.ApiClient.instance;


var api = new KakaoTechCampusJeongSanApi_._Api()
var expenseId = 789; // {{Long}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getExpenseDetails(expenseId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getExpenseDetailsExample
    {
        public void main()
        {


            var apiInstance = new _Api();
            var expenseId = 789;  // Long | 

            try
            {
                // 지출 선택 현황 조회 API
                ExpenseDetailResponse result = apiInstance.getExpenseDetails(expenseId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling _Api.getExpenseDetails: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\Api_Api();
$expenseId = 789; // Long | 

try {
    $result = $api_instance->getExpenseDetails($expenseId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling _Api->getExpenseDetails: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::_Api;


my $api_instance = WWW::SwaggerClient::_Api->new();
my $expenseId = 789; # Long | 

eval { 
    my $result = $api_instance->getExpenseDetails(expenseId => $expenseId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling _Api->getExpenseDetails: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client._Api()
expenseId = 789 # Long | 

try: 
    # 지출 선택 현황 조회 API
    api_response = api_instance.get_expense_details(expenseId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling _Api->getExpenseDetails: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api._Api;

import java.io.File;
import java.util.*;

public class _ApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        _Api apiInstance = new _Api();
        Long teamId = 789; // Long | 조회를 원하는 모임 ID
        try {
            JeongsanApiResponseExpenseResponse result = apiInstance.getExpensesIPaid(teamId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#getExpensesIPaid");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api._Api;

public class _ApiExample {

    public static void main(String[] args) {
        _Api apiInstance = new _Api();
        Long teamId = 789; // Long | 조회를 원하는 모임 ID
        try {
            JeongsanApiResponseExpenseResponse result = apiInstance.getExpensesIPaid(teamId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#getExpensesIPaid");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Long *teamId = 789; // 조회를 원하는 모임 ID

_Api *apiInstance = [[_Api alloc] init];

// 내가 지불한 지출 내역 조회 API
[apiInstance getExpensesIPaidWith:teamId
              completionHandler: ^(JeongsanApiResponseExpenseResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KakaoTechCampusJeongSanApi_ = require('kakao_tech_campus__jeong_san__api_');
var defaultClient = KakaoTechCampusJeongSanApi_.ApiClient.instance;


var api = new KakaoTechCampusJeongSanApi_._Api()
var teamId = 789; // {{Long}} 조회를 원하는 모임 ID

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getExpensesIPaid(teamId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getExpensesIPaidExample
    {
        public void main()
        {


            var apiInstance = new _Api();
            var teamId = 789;  // Long | 조회를 원하는 모임 ID

            try
            {
                // 내가 지불한 지출 내역 조회 API
                JeongsanApiResponseExpenseResponse result = apiInstance.getExpensesIPaid(teamId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling _Api.getExpensesIPaid: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\Api_Api();
$teamId = 789; // Long | 조회를 원하는 모임 ID

try {
    $result = $api_instance->getExpensesIPaid($teamId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling _Api->getExpensesIPaid: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::_Api;


my $api_instance = WWW::SwaggerClient::_Api->new();
my $teamId = 789; # Long | 조회를 원하는 모임 ID

eval { 
    my $result = $api_instance->getExpensesIPaid(teamId => $teamId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling _Api->getExpensesIPaid: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client._Api()
teamId = 789 # Long | 조회를 원하는 모임 ID

try: 
    # 내가 지불한 지출 내역 조회 API
    api_response = api_instance.get_expenses_i_paid(teamId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling _Api->getExpensesIPaid: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api._Api;

import java.io.File;
import java.util.*;

public class _ApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        _Api apiInstance = new _Api();
        Long teamId = 789; // Long | 멤버 초대 현황을 조회하려는 모임의 id
        try {
            InvitationStatusResponse result = apiInstance.getInvitationStatus(teamId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#getInvitationStatus");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api._Api;

public class _ApiExample {

    public static void main(String[] args) {
        _Api apiInstance = new _Api();
        Long teamId = 789; // Long | 멤버 초대 현황을 조회하려는 모임의 id
        try {
            InvitationStatusResponse result = apiInstance.getInvitationStatus(teamId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#getInvitationStatus");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Long *teamId = 789; // 멤버 초대 현황을 조회하려는 모임의 id

_Api *apiInstance = [[_Api alloc] init];

// 모임 멤버 초대 현황 조회 API
[apiInstance getInvitationStatusWith:teamId
              completionHandler: ^(InvitationStatusResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KakaoTechCampusJeongSanApi_ = require('kakao_tech_campus__jeong_san__api_');
var defaultClient = KakaoTechCampusJeongSanApi_.ApiClient.instance;


var api = new KakaoTechCampusJeongSanApi_._Api()
var teamId = 789; // {{Long}} 멤버 초대 현황을 조회하려는 모임의 id

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getInvitationStatus(teamId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getInvitationStatusExample
    {
        public void main()
        {


            var apiInstance = new _Api();
            var teamId = 789;  // Long | 멤버 초대 현황을 조회하려는 모임의 id

            try
            {
                // 모임 멤버 초대 현황 조회 API
                InvitationStatusResponse result = apiInstance.getInvitationStatus(teamId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling _Api.getInvitationStatus: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\Api_Api();
$teamId = 789; // Long | 멤버 초대 현황을 조회하려는 모임의 id

try {
    $result = $api_instance->getInvitationStatus($teamId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling _Api->getInvitationStatus: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::_Api;


my $api_instance = WWW::SwaggerClient::_Api->new();
my $teamId = 789; # Long | 멤버 초대 현황을 조회하려는 모임의 id

eval { 
    my $result = $api_instance->getInvitationStatus(teamId => $teamId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling _Api->getInvitationStatus: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client._Api()
teamId = 789 # Long | 멤버 초대 현황을 조회하려는 모임의 id

try: 
    # 모임 멤버 초대 현황 조회 API
    api_response = api_instance.get_invitation_status(teamId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling _Api->getInvitationStatus: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api._Api;

import java.io.File;
import java.util.*;

public class _ApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        _Api apiInstance = new _Api();
        Long teamId = 789; // Long | 멤버 카카오 아이디를 조회하려는 모임의 id
        try {
            MemberKakaoIdResponse result = apiInstance.getMemberKakaoId(teamId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#getMemberKakaoId");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api._Api;

public class _ApiExample {

    public static void main(String[] args) {
        _Api apiInstance = new _Api();
        Long teamId = 789; // Long | 멤버 카카오 아이디를 조회하려는 모임의 id
        try {
            MemberKakaoIdResponse result = apiInstance.getMemberKakaoId(teamId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#getMemberKakaoId");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Long *teamId = 789; // 멤버 카카오 아이디를 조회하려는 모임의 id

_Api *apiInstance = [[_Api alloc] init];

// 모임 멤버 카카오 아이디 조회 API
[apiInstance getMemberKakaoIdWith:teamId
              completionHandler: ^(MemberKakaoIdResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KakaoTechCampusJeongSanApi_ = require('kakao_tech_campus__jeong_san__api_');
var defaultClient = KakaoTechCampusJeongSanApi_.ApiClient.instance;


var api = new KakaoTechCampusJeongSanApi_._Api()
var teamId = 789; // {{Long}} 멤버 카카오 아이디를 조회하려는 모임의 id

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getMemberKakaoId(teamId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getMemberKakaoIdExample
    {
        public void main()
        {


            var apiInstance = new _Api();
            var teamId = 789;  // Long | 멤버 카카오 아이디를 조회하려는 모임의 id

            try
            {
                // 모임 멤버 카카오 아이디 조회 API
                MemberKakaoIdResponse result = apiInstance.getMemberKakaoId(teamId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling _Api.getMemberKakaoId: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\Api_Api();
$teamId = 789; // Long | 멤버 카카오 아이디를 조회하려는 모임의 id

try {
    $result = $api_instance->getMemberKakaoId($teamId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling _Api->getMemberKakaoId: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::_Api;


my $api_instance = WWW::SwaggerClient::_Api->new();
my $teamId = 789; # Long | 멤버 카카오 아이디를 조회하려는 모임의 id

eval { 
    my $result = $api_instance->getMemberKakaoId(teamId => $teamId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling _Api->getMemberKakaoId: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client._Api()
teamId = 789 # Long | 멤버 카카오 아이디를 조회하려는 모임의 id

try: 
    # 모임 멤버 카카오 아이디 조회 API
    api_response = api_instance.get_member_kakao_id(teamId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling _Api->getMemberKakaoId: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api._Api;

import java.io.File;
import java.util.*;

public class _ApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        _Api apiInstance = new _Api();
        try {
            JeongsanApiResponseGetPayLinkResponse result = apiInstance.getPayLink();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#getPayLink");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api._Api;

public class _ApiExample {

    public static void main(String[] args) {
        _Api apiInstance = new _Api();
        try {
            JeongsanApiResponseGetPayLinkResponse result = apiInstance.getPayLink();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#getPayLink");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

_Api *apiInstance = [[_Api alloc] init];

// 송금 링크 조회 API
[apiInstance getPayLinkWithCompletionHandler: 
              ^(JeongsanApiResponseGetPayLinkResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KakaoTechCampusJeongSanApi_ = require('kakao_tech_campus__jeong_san__api_');
var defaultClient = KakaoTechCampusJeongSanApi_.ApiClient.instance;


var api = new KakaoTechCampusJeongSanApi_._Api()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getPayLink(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getPayLinkExample
    {
        public void main()
        {


            var apiInstance = new _Api();

            try
            {
                // 송금 링크 조회 API
                JeongsanApiResponseGetPayLinkResponse result = apiInstance.getPayLink();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling _Api.getPayLink: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\Api_Api();

try {
    $result = $api_instance->getPayLink();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling _Api->getPayLink: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::_Api;


my $api_instance = WWW::SwaggerClient::_Api->new();

eval { 
    my $result = $api_instance->getPayLink();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling _Api->getPayLink: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client._Api()

try: 
    # 송금 링크 조회 API
    api_response = api_instance.get_pay_link()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling _Api->getPayLink: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api._Api;

import java.io.File;
import java.util.*;

public class _ApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        _Api apiInstance = new _Api();
        Long expenseId = 789; // Long | 조회할 지출 ID
        try {
            PersonalExpenseDetailResponse result = apiInstance.getPersonalExpenseDetails(expenseId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#getPersonalExpenseDetails");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api._Api;

public class _ApiExample {

    public static void main(String[] args) {
        _Api apiInstance = new _Api();
        Long expenseId = 789; // Long | 조회할 지출 ID
        try {
            PersonalExpenseDetailResponse result = apiInstance.getPersonalExpenseDetails(expenseId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#getPersonalExpenseDetails");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Long *expenseId = 789; // 조회할 지출 ID

_Api *apiInstance = [[_Api alloc] init];

// 지출 상세 내역 조회
[apiInstance getPersonalExpenseDetailsWith:expenseId
              completionHandler: ^(PersonalExpenseDetailResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KakaoTechCampusJeongSanApi_ = require('kakao_tech_campus__jeong_san__api_');
var defaultClient = KakaoTechCampusJeongSanApi_.ApiClient.instance;


var api = new KakaoTechCampusJeongSanApi_._Api()
var expenseId = 789; // {{Long}} 조회할 지출 ID

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getPersonalExpenseDetails(expenseId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getPersonalExpenseDetailsExample
    {
        public void main()
        {


            var apiInstance = new _Api();
            var expenseId = 789;  // Long | 조회할 지출 ID

            try
            {
                // 지출 상세 내역 조회
                PersonalExpenseDetailResponse result = apiInstance.getPersonalExpenseDetails(expenseId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling _Api.getPersonalExpenseDetails: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\Api_Api();
$expenseId = 789; // Long | 조회할 지출 ID

try {
    $result = $api_instance->getPersonalExpenseDetails($expenseId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling _Api->getPersonalExpenseDetails: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::_Api;


my $api_instance = WWW::SwaggerClient::_Api->new();
my $expenseId = 789; # Long | 조회할 지출 ID

eval { 
    my $result = $api_instance->getPersonalExpenseDetails(expenseId => $expenseId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling _Api->getPersonalExpenseDetails: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client._Api()
expenseId = 789 # Long | 조회할 지출 ID

try: 
    # 지출 상세 내역 조회
    api_response = api_instance.get_personal_expense_details(expenseId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling _Api->getPersonalExpenseDetails: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api._Api;

import java.io.File;
import java.util.*;

public class _ApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        _Api apiInstance = new _Api();
        Long teamId = 789; // Long | 조회를 원하는 모임의 ID
        try {
            TeamResponse result = apiInstance.getTeam(teamId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#getTeam");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api._Api;

public class _ApiExample {

    public static void main(String[] args) {
        _Api apiInstance = new _Api();
        Long teamId = 789; // Long | 조회를 원하는 모임의 ID
        try {
            TeamResponse result = apiInstance.getTeam(teamId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#getTeam");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Long *teamId = 789; // 조회를 원하는 모임의 ID

_Api *apiInstance = [[_Api alloc] init];

// 모임 조회 API
[apiInstance getTeamWith:teamId
              completionHandler: ^(TeamResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KakaoTechCampusJeongSanApi_ = require('kakao_tech_campus__jeong_san__api_');
var defaultClient = KakaoTechCampusJeongSanApi_.ApiClient.instance;


var api = new KakaoTechCampusJeongSanApi_._Api()
var teamId = 789; // {{Long}} 조회를 원하는 모임의 ID

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTeam(teamId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTeamExample
    {
        public void main()
        {


            var apiInstance = new _Api();
            var teamId = 789;  // Long | 조회를 원하는 모임의 ID

            try
            {
                // 모임 조회 API
                TeamResponse result = apiInstance.getTeam(teamId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling _Api.getTeam: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\Api_Api();
$teamId = 789; // Long | 조회를 원하는 모임의 ID

try {
    $result = $api_instance->getTeam($teamId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling _Api->getTeam: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::_Api;


my $api_instance = WWW::SwaggerClient::_Api->new();
my $teamId = 789; # Long | 조회를 원하는 모임의 ID

eval { 
    my $result = $api_instance->getTeam(teamId => $teamId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling _Api->getTeam: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client._Api()
teamId = 789 # Long | 조회를 원하는 모임의 ID

try: 
    # 모임 조회 API
    api_response = api_instance.get_team(teamId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling _Api->getTeam: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api._Api;

import java.io.File;
import java.util.*;

public class _ApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        _Api apiInstance = new _Api();
        Boolean isClosed = true; // Boolean | 모임의 현재 상태(진행 중, 종료)
        try {
            TeamResponse result = apiInstance.getTeams(isClosed);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#getTeams");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api._Api;

public class _ApiExample {

    public static void main(String[] args) {
        _Api apiInstance = new _Api();
        Boolean isClosed = true; // Boolean | 모임의 현재 상태(진행 중, 종료)
        try {
            TeamResponse result = apiInstance.getTeams(isClosed);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#getTeams");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Boolean *isClosed = true; // 모임의 현재 상태(진행 중, 종료)

_Api *apiInstance = [[_Api alloc] init];

// 모임 목록 조회 API
[apiInstance getTeamsWith:isClosed
              completionHandler: ^(TeamResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KakaoTechCampusJeongSanApi_ = require('kakao_tech_campus__jeong_san__api_');
var defaultClient = KakaoTechCampusJeongSanApi_.ApiClient.instance;


var api = new KakaoTechCampusJeongSanApi_._Api()
var isClosed = true; // {{Boolean}} 모임의 현재 상태(진행 중, 종료)

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTeams(isClosed, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTeamsExample
    {
        public void main()
        {


            var apiInstance = new _Api();
            var isClosed = true;  // Boolean | 모임의 현재 상태(진행 중, 종료)

            try
            {
                // 모임 목록 조회 API
                TeamResponse result = apiInstance.getTeams(isClosed);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling _Api.getTeams: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\Api_Api();
$isClosed = true; // Boolean | 모임의 현재 상태(진행 중, 종료)

try {
    $result = $api_instance->getTeams($isClosed);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling _Api->getTeams: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::_Api;


my $api_instance = WWW::SwaggerClient::_Api->new();
my $isClosed = true; # Boolean | 모임의 현재 상태(진행 중, 종료)

eval { 
    my $result = $api_instance->getTeams(isClosed => $isClosed);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling _Api->getTeams: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client._Api()
isClosed = true # Boolean | 모임의 현재 상태(진행 중, 종료)

try: 
    # 모임 목록 조회 API
    api_response = api_instance.get_teams(isClosed)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling _Api->getTeams: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api._Api;

import java.io.File;
import java.util.*;

public class _ApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        _Api apiInstance = new _Api();
        TransferTargetRequest body = ; // TransferTargetRequest | 송금 요청할 지출 id 목록
        Long teamId = 789; // Long | 송금 요청 대상 및 금액 조회하려는 모임의 id
        try {
            array[TransferTargetResponse] result = apiInstance.getTransferTargetList(body, teamId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#getTransferTargetList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api._Api;

public class _ApiExample {

    public static void main(String[] args) {
        _Api apiInstance = new _Api();
        TransferTargetRequest body = ; // TransferTargetRequest | 송금 요청할 지출 id 목록
        Long teamId = 789; // Long | 송금 요청 대상 및 금액 조회하려는 모임의 id
        try {
            array[TransferTargetResponse] result = apiInstance.getTransferTargetList(body, teamId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#getTransferTargetList");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
TransferTargetRequest *body = ; // 송금 요청할 지출 id 목록
Long *teamId = 789; // 송금 요청 대상 및 금액 조회하려는 모임의 id

_Api *apiInstance = [[_Api alloc] init];

// 송금 요청 대상 및 금액 조회 API
[apiInstance getTransferTargetListWith:body
    teamId:teamId
              completionHandler: ^(array[TransferTargetResponse] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KakaoTechCampusJeongSanApi_ = require('kakao_tech_campus__jeong_san__api_');
var defaultClient = KakaoTechCampusJeongSanApi_.ApiClient.instance;


var api = new KakaoTechCampusJeongSanApi_._Api()
var body = ; // {{TransferTargetRequest}} 송금 요청할 지출 id 목록
var teamId = 789; // {{Long}} 송금 요청 대상 및 금액 조회하려는 모임의 id

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTransferTargetList(bodyteamId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getTransferTargetListExample
    {
        public void main()
        {


            var apiInstance = new _Api();
            var body = new TransferTargetRequest(); // TransferTargetRequest | 송금 요청할 지출 id 목록
            var teamId = 789;  // Long | 송금 요청 대상 및 금액 조회하려는 모임의 id

            try
            {
                // 송금 요청 대상 및 금액 조회 API
                array[TransferTargetResponse] result = apiInstance.getTransferTargetList(body, teamId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling _Api.getTransferTargetList: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\Api_Api();
$body = ; // TransferTargetRequest | 송금 요청할 지출 id 목록
$teamId = 789; // Long | 송금 요청 대상 및 금액 조회하려는 모임의 id

try {
    $result = $api_instance->getTransferTargetList($body, $teamId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling _Api->getTransferTargetList: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::_Api;


my $api_instance = WWW::SwaggerClient::_Api->new();
my $body = WWW::SwaggerClient::Object::TransferTargetRequest->new(); # TransferTargetRequest | 송금 요청할 지출 id 목록
my $teamId = 789; # Long | 송금 요청 대상 및 금액 조회하려는 모임의 id

eval { 
    my $result = $api_instance->getTransferTargetList(body => $body, teamId => $teamId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling _Api->getTransferTargetList: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client._Api()
body =  # TransferTargetRequest | 송금 요청할 지출 id 목록
teamId = 789 # Long | 송금 요청 대상 및 금액 조회하려는 모임의 id

try: 
    # 송금 요청 대상 및 금액 조회 API
    api_response = api_instance.get_transfer_target_list(body, teamId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling _Api->getTransferTargetList: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api._Api;

import java.io.File;
import java.util.*;

public class _ApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        _Api apiInstance = new _Api();
        Long teamId = 789; // Long | 
        try {
            JeongsanApiResponseVoid result = apiInstance.joinTeam(teamId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#joinTeam");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api._Api;

public class _ApiExample {

    public static void main(String[] args) {
        _Api apiInstance = new _Api();
        Long teamId = 789; // Long | 
        try {
            JeongsanApiResponseVoid result = apiInstance.joinTeam(teamId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#joinTeam");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Long *teamId = 789; // 

_Api *apiInstance = [[_Api alloc] init];

// 모임 초대 수락 API
[apiInstance joinTeamWith:teamId
              completionHandler: ^(JeongsanApiResponseVoid output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KakaoTechCampusJeongSanApi_ = require('kakao_tech_campus__jeong_san__api_');
var defaultClient = KakaoTechCampusJeongSanApi_.ApiClient.instance;


var api = new KakaoTechCampusJeongSanApi_._Api()
var teamId = 789; // {{Long}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.joinTeam(teamId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class joinTeamExample
    {
        public void main()
        {


            var apiInstance = new _Api();
            var teamId = 789;  // Long | 

            try
            {
                // 모임 초대 수락 API
                JeongsanApiResponseVoid result = apiInstance.joinTeam(teamId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling _Api.joinTeam: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\Api_Api();
$teamId = 789; // Long | 

try {
    $result = $api_instance->joinTeam($teamId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling _Api->joinTeam: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::_Api;


my $api_instance = WWW::SwaggerClient::_Api->new();
my $teamId = 789; # Long | 

eval { 
    my $result = $api_instance->joinTeam(teamId => $teamId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling _Api->joinTeam: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client._Api()
teamId = 789 # Long | 

try: 
    # 모임 초대 수락 API
    api_response = api_instance.join_team(teamId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling _Api->joinTeam: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api._Api;

import java.io.File;
import java.util.*;

public class _ApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        _Api apiInstance = new _Api();
        LoginRequest body = ; // LoginRequest | 
        String email = email_example; // String | 카카오 회원 정보의 이메일
        try {
            JeongsanApiResponseLoginResponse result = apiInstance.login(body, email);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#login");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api._Api;

public class _ApiExample {

    public static void main(String[] args) {
        _Api apiInstance = new _Api();
        LoginRequest body = ; // LoginRequest | 
        String email = email_example; // String | 카카오 회원 정보의 이메일
        try {
            JeongsanApiResponseLoginResponse result = apiInstance.login(body, email);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#login");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
LoginRequest *body = ; // 
String *email = email_example; // 카카오 회원 정보의 이메일 (optional)

_Api *apiInstance = [[_Api alloc] init];

// 로그인 API
[apiInstance loginWith:body
    email:email
              completionHandler: ^(JeongsanApiResponseLoginResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KakaoTechCampusJeongSanApi_ = require('kakao_tech_campus__jeong_san__api_');
var defaultClient = KakaoTechCampusJeongSanApi_.ApiClient.instance;


var api = new KakaoTechCampusJeongSanApi_._Api()
var body = ; // {{LoginRequest}} 
var opts = { 
  'email': email_example // {{String}} 카카오 회원 정보의 이메일
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.login(body, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class loginExample
    {
        public void main()
        {


            var apiInstance = new _Api();
            var body = new LoginRequest(); // LoginRequest | 
            var email = email_example;  // String | 카카오 회원 정보의 이메일 (optional) 

            try
            {
                // 로그인 API
                JeongsanApiResponseLoginResponse result = apiInstance.login(body, email);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling _Api.login: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\Api_Api();
$body = ; // LoginRequest | 
$email = email_example; // String | 카카오 회원 정보의 이메일

try {
    $result = $api_instance->login($body, $email);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling _Api->login: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::_Api;


my $api_instance = WWW::SwaggerClient::_Api->new();
my $body = WWW::SwaggerClient::Object::LoginRequest->new(); # LoginRequest | 
my $email = email_example; # String | 카카오 회원 정보의 이메일

eval { 
    my $result = $api_instance->login(body => $body, email => $email);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling _Api->login: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client._Api()
body =  # LoginRequest | 
email = email_example # String | 카카오 회원 정보의 이메일 (optional)

try: 
    # 로그인 API
    api_response = api_instance.login(body, email=email)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling _Api->login: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api._Api;

import java.io.File;
import java.util.*;

public class _ApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        _Api apiInstance = new _Api();
        Image body = ; // Image | 
        try {
            JeongsanApiResponseVoid result = apiInstance.mockAnalyzeReceipt(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#mockAnalyzeReceipt");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api._Api;

public class _ApiExample {

    public static void main(String[] args) {
        _Api apiInstance = new _Api();
        Image body = ; // Image | 
        try {
            JeongsanApiResponseVoid result = apiInstance.mockAnalyzeReceipt(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#mockAnalyzeReceipt");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Image *body = ; // 

_Api *apiInstance = [[_Api alloc] init];

// 영수증 내역 분석&조회 API 테스트
[apiInstance mockAnalyzeReceiptWith:body
              completionHandler: ^(JeongsanApiResponseVoid output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KakaoTechCampusJeongSanApi_ = require('kakao_tech_campus__jeong_san__api_');
var defaultClient = KakaoTechCampusJeongSanApi_.ApiClient.instance;


var api = new KakaoTechCampusJeongSanApi_._Api()
var body = ; // {{Image}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.mockAnalyzeReceipt(body, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class mockAnalyzeReceiptExample
    {
        public void main()
        {


            var apiInstance = new _Api();
            var body = new Image(); // Image | 

            try
            {
                // 영수증 내역 분석&조회 API 테스트
                JeongsanApiResponseVoid result = apiInstance.mockAnalyzeReceipt(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling _Api.mockAnalyzeReceipt: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\Api_Api();
$body = ; // Image | 

try {
    $result = $api_instance->mockAnalyzeReceipt($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling _Api->mockAnalyzeReceipt: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::_Api;


my $api_instance = WWW::SwaggerClient::_Api->new();
my $body = WWW::SwaggerClient::Object::Image->new(); # Image | 

eval { 
    my $result = $api_instance->mockAnalyzeReceipt(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling _Api->mockAnalyzeReceipt: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client._Api()
body =  # Image | 

try: 
    # 영수증 내역 분석&조회 API 테스트
    api_response = api_instance.mock_analyze_receipt(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling _Api->mockAnalyzeReceipt: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api._Api;

import java.io.File;
import java.util.*;

public class _ApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        _Api apiInstance = new _Api();
        RefreshRequest body = ; // RefreshRequest | 
        String refreshToken = refreshToken_example; // String | 서비스 서버 리프레시 토큰
        try {
            JeongsanApiResponseRefreshResponse result = apiInstance.refresh(body, refreshToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#refresh");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api._Api;

public class _ApiExample {

    public static void main(String[] args) {
        _Api apiInstance = new _Api();
        RefreshRequest body = ; // RefreshRequest | 
        String refreshToken = refreshToken_example; // String | 서비스 서버 리프레시 토큰
        try {
            JeongsanApiResponseRefreshResponse result = apiInstance.refresh(body, refreshToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#refresh");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
RefreshRequest *body = ; // 
String *refreshToken = refreshToken_example; // 서비스 서버 리프레시 토큰 (optional)

_Api *apiInstance = [[_Api alloc] init];

// 액세스 토큰 재발급 API
[apiInstance refreshWith:body
    refreshToken:refreshToken
              completionHandler: ^(JeongsanApiResponseRefreshResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KakaoTechCampusJeongSanApi_ = require('kakao_tech_campus__jeong_san__api_');
var defaultClient = KakaoTechCampusJeongSanApi_.ApiClient.instance;


var api = new KakaoTechCampusJeongSanApi_._Api()
var body = ; // {{RefreshRequest}} 
var opts = { 
  'refreshToken': refreshToken_example // {{String}} 서비스 서버 리프레시 토큰
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.refresh(body, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class refreshExample
    {
        public void main()
        {


            var apiInstance = new _Api();
            var body = new RefreshRequest(); // RefreshRequest | 
            var refreshToken = refreshToken_example;  // String | 서비스 서버 리프레시 토큰 (optional) 

            try
            {
                // 액세스 토큰 재발급 API
                JeongsanApiResponseRefreshResponse result = apiInstance.refresh(body, refreshToken);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling _Api.refresh: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\Api_Api();
$body = ; // RefreshRequest | 
$refreshToken = refreshToken_example; // String | 서비스 서버 리프레시 토큰

try {
    $result = $api_instance->refresh($body, $refreshToken);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling _Api->refresh: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::_Api;


my $api_instance = WWW::SwaggerClient::_Api->new();
my $body = WWW::SwaggerClient::Object::RefreshRequest->new(); # RefreshRequest | 
my $refreshToken = refreshToken_example; # String | 서비스 서버 리프레시 토큰

eval { 
    my $result = $api_instance->refresh(body => $body, refreshToken => $refreshToken);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling _Api->refresh: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client._Api()
body =  # RefreshRequest | 
refreshToken = refreshToken_example # String | 서비스 서버 리프레시 토큰 (optional)

try: 
    # 액세스 토큰 재발급 API
    api_response = api_instance.refresh(body, refreshToken=refreshToken)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling _Api->refresh: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api._Api;

import java.io.File;
import java.util.*;

public class _ApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        _Api apiInstance = new _Api();
        RegisterRequest body = ; // RegisterRequest | 
        String nickname = nickname_example; // String | 카카오 회원 정보의 닉네임
        String email = email_example; // String | 카카오 회원 정보의 이메일
        String profileImage = profileImage_example; // String | 카카오 회원 정보의 프로필 URL
        try {
            JeongsanApiResponseLoginResponse result = apiInstance.register(body, nickname, email, profileImage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#register");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api._Api;

public class _ApiExample {

    public static void main(String[] args) {
        _Api apiInstance = new _Api();
        RegisterRequest body = ; // RegisterRequest | 
        String nickname = nickname_example; // String | 카카오 회원 정보의 닉네임
        String email = email_example; // String | 카카오 회원 정보의 이메일
        String profileImage = profileImage_example; // String | 카카오 회원 정보의 프로필 URL
        try {
            JeongsanApiResponseLoginResponse result = apiInstance.register(body, nickname, email, profileImage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#register");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
RegisterRequest *body = ; // 
String *nickname = nickname_example; // 카카오 회원 정보의 닉네임 (optional)
String *email = email_example; // 카카오 회원 정보의 이메일 (optional)
String *profileImage = profileImage_example; // 카카오 회원 정보의 프로필 URL (optional)

_Api *apiInstance = [[_Api alloc] init];

// 회원가입 API
[apiInstance registerWith:body
    nickname:nickname
    email:email
    profileImage:profileImage
              completionHandler: ^(JeongsanApiResponseLoginResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KakaoTechCampusJeongSanApi_ = require('kakao_tech_campus__jeong_san__api_');
var defaultClient = KakaoTechCampusJeongSanApi_.ApiClient.instance;


var api = new KakaoTechCampusJeongSanApi_._Api()
var body = ; // {{RegisterRequest}} 
var opts = { 
  'nickname': nickname_example // {{String}} 카카오 회원 정보의 닉네임
  'email': email_example // {{String}} 카카오 회원 정보의 이메일
  'profileImage': profileImage_example // {{String}} 카카오 회원 정보의 프로필 URL
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.register(body, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class registerExample
    {
        public void main()
        {


            var apiInstance = new _Api();
            var body = new RegisterRequest(); // RegisterRequest | 
            var nickname = nickname_example;  // String | 카카오 회원 정보의 닉네임 (optional) 
            var email = email_example;  // String | 카카오 회원 정보의 이메일 (optional) 
            var profileImage = profileImage_example;  // String | 카카오 회원 정보의 프로필 URL (optional) 

            try
            {
                // 회원가입 API
                JeongsanApiResponseLoginResponse result = apiInstance.register(body, nickname, email, profileImage);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling _Api.register: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\Api_Api();
$body = ; // RegisterRequest | 
$nickname = nickname_example; // String | 카카오 회원 정보의 닉네임
$email = email_example; // String | 카카오 회원 정보의 이메일
$profileImage = profileImage_example; // String | 카카오 회원 정보의 프로필 URL

try {
    $result = $api_instance->register($body, $nickname, $email, $profileImage);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling _Api->register: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::_Api;


my $api_instance = WWW::SwaggerClient::_Api->new();
my $body = WWW::SwaggerClient::Object::RegisterRequest->new(); # RegisterRequest | 
my $nickname = nickname_example; # String | 카카오 회원 정보의 닉네임
my $email = email_example; # String | 카카오 회원 정보의 이메일
my $profileImage = profileImage_example; # String | 카카오 회원 정보의 프로필 URL

eval { 
    my $result = $api_instance->register(body => $body, nickname => $nickname, email => $email, profileImage => $profileImage);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling _Api->register: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client._Api()
body =  # RegisterRequest | 
nickname = nickname_example # String | 카카오 회원 정보의 닉네임 (optional)
email = email_example # String | 카카오 회원 정보의 이메일 (optional)
profileImage = profileImage_example # String | 카카오 회원 정보의 프로필 URL (optional)

try: 
    # 회원가입 API
    api_response = api_instance.register(body, nickname=nickname, email=email, profileImage=profileImage)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling _Api->register: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api._Api;

import java.io.File;
import java.util.*;

public class _ApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        _Api apiInstance = new _Api();
        SavePersonalExpenseRequest body = ; // SavePersonalExpenseRequest | 
        Long teamId = 789; // Long | 요청 멤버가 속한 모임의 ID
        Long expenseId = 789; // Long | 선택한 아이템이 속한 지출의 ID
        try {
            apiInstance.savePersonalExpense(body, teamId, expenseId);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#savePersonalExpense");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api._Api;

public class _ApiExample {

    public static void main(String[] args) {
        _Api apiInstance = new _Api();
        SavePersonalExpenseRequest body = ; // SavePersonalExpenseRequest | 
        Long teamId = 789; // Long | 요청 멤버가 속한 모임의 ID
        Long expenseId = 789; // Long | 선택한 아이템이 속한 지출의 ID
        try {
            apiInstance.savePersonalExpense(body, teamId, expenseId);
        } catch (ApiException e) {
            System.err.println("Exception when calling _Api#savePersonalExpense");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
SavePersonalExpenseRequest *body = ; // 
Long *teamId = 789; // 요청 멤버가 속한 모임의 ID
Long *expenseId = 789; // 선택한 아이템이 속한 지출의 ID

_Api *apiInstance = [[_Api alloc] init];

// 지출 내역 저장(선택 완료) API
[apiInstance savePersonalExpenseWith:body
    teamId:teamId
    expenseId:expenseId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var KakaoTechCampusJeongSanApi_ = require('kakao_tech_campus__jeong_san__api_');
var defaultClient = KakaoTechCampusJeongSanApi_.ApiClient.instance;


var api = new KakaoTechCampusJeongSanApi_._Api()
var body = ; // {{SavePersonalExpenseRequest}} 
var teamId = 789; // {{Long}} 요청 멤버가 속한 모임의 ID
var expenseId = 789; // {{Long}} 선택한 아이템이 속한 지출의 ID

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.savePersonalExpense(bodyteamIdexpenseId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class savePersonalExpenseExample
    {
        public void main()
        {


            var apiInstance = new _Api();
            var body = new SavePersonalExpenseRequest(); // SavePersonalExpenseRequest | 
            var teamId = 789;  // Long | 요청 멤버가 속한 모임의 ID
            var expenseId = 789;  // Long | 선택한 아이템이 속한 지출의 ID

            try
            {
                // 지출 내역 저장(선택 완료) API
                apiInstance.savePersonalExpense(body, teamId, expenseId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling _Api.savePersonalExpense: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\Api_Api();
$body = ; // SavePersonalExpenseRequest | 
$teamId = 789; // Long | 요청 멤버가 속한 모임의 ID
$expenseId = 789; // Long | 선택한 아이템이 속한 지출의 ID

try {
    $api_instance->savePersonalExpense($body, $teamId, $expenseId);
} catch (Exception $e) {
    echo 'Exception when calling _Api->savePersonalExpense: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::_Api;


my $api_instance = WWW::SwaggerClient::_Api->new();
my $body = WWW::SwaggerClient::Object::SavePersonalExpenseRequest->new(); # SavePersonalExpenseRequest | 
my $teamId = 789; # Long | 요청 멤버가 속한 모임의 ID
my $expenseId = 789; # Long | 선택한 아이템이 속한 지출의 ID

eval { 
    $api_instance->savePersonalExpense(body => $body, teamId => $teamId, expenseId => $expenseId);
};
if ($@) {
    warn "Exception when calling _Api->savePersonalExpense: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client._Api()
body =  # SavePersonalExpenseRequest | 
teamId = 789 # Long | 요청 멤버가 속한 모임의 ID
expenseId = 789 # Long | 선택한 아이템이 속한 지출의 ID

try: 
    # 지출 내역 저장(선택 완료) API
    api_instance.save_personal_expense(body, teamId, expenseId)
except ApiException as e:
    print("Exception when calling _Api->savePersonalExpense: %s\n" % e)