fjffkç®€å•çš„å’–å•¡åº—ç§‘å¼€å‘2æ–¹æ³•2
çŽ¯æ»çš†å±±ä¹Ÿã€‚å…¶è¥¿å—è¯¸å³°ï¼Œæž—å£‘å°¤ç¾Žï¼Œæœ›ä¹‹è”šç„¶è€Œæ·±ç§€è€…ï¼Œç…çŠä¹Ÿã€‚å±±è¡Œå…­ä¸ƒé‡Œï¼Œæ¸é—»æ°´å£°æ½ºæ½ºï¼Œè€Œæ³»å‡ºäºŽä¸¤å³°ä¹‹é—´è€…ï¼Œé…¿æ³‰ä¹Ÿ

???????????????????????????????

??????????????/?????????????????

............/...................

.........................../...

???????????????????????????????

>>>>>>>>>>>>>/>>>>>>>>>>>>>>>>>


Ã¿Ã˜Ã¿Ã  JFIF      Ã¿Ã› â€ž 	 ( %!1!%)+//.383,7(-.+

                                                                                                   

-%%-////---/-.+/--+------/------/--0+--/-/-----.-----Ã¿Ã€  Â¥2" Ã¿Ã„               Ã¿Ã„ J  	     ! 1AQ"aqÂ2â€˜#BRâ€šÂ¡ÃÃ‘3brâ€™Â¢Â±Ã‚Ã°$CSÆ’Â²Ã¡4câ€œ%DsÃ“Ã±Ã¿Ã„              Ã¿Ã„ *        !1AQaâ€˜"2q3ÂÂ±Ã°#bÂ¡Ã¿Ãš   ? Â¼QxJQaÃuÃ²Â¸ZÃ¶ ÃšÃ¼8,ÃÃšÃº
"SSn<rÃ§Ã¹â€“Â´Ã¢Eâ€”^ÂªBÃ–9Ã€\â€ Â¸ÂÃ”ÂÃTÂ­ÃƒÃ›5
Ã«dÂ´Â³Ã#Ã;Ãž38Å“Ã®Â Â¶HÂ£M:wÃŽ3â€¦Â³â€¦Ã¢pÃ”F&â€šFKÂ¸9â€žÃ¢4Ã GEÃµÂªfÂÃ¿ â€˜Ã±(ÃŸwÂ­pÅ½F|ÃˆÂ¥Ã¹Â®hÃ¤Ã°ÃÃ‘Â¶Â¹â€˜[Ã’inÃ™WÂ¶Ã¹Ã±YËœQ{â€ºK"iÅ¡Ã’[Ãš8Å¾Ã«\FÂ¹@-?v"Ã”Uâ€,Ã¬Ã¶Å¾kÃ¿ {Iâ€¡Â£Å¡Ã?e
rÂÃ­V
?>
.........................................
.............................................................................                                                  


<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

>>>>>>>>>>>>>/>>>>>>>>>>>>>>>>>>

<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>


dsdfPK     S%W]b+¨ñÍ  Í    laravel/src/Facades/OpenAI.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Laravel\Facades;

use Illuminate\Support\Facades\Facade;
use OpenAI\Contracts\ResponseContract;
use OpenAI\Laravel\Testing\OpenAIFake;
use OpenAI\Responses\StreamResponse;

/**
 * @method static \OpenAI\Resources\Assistants assistants()
 * @method static \OpenAI\Resources\Audio audio()
 * @method static \OpenAI\Resources\Batches batches()
 * @method static \OpenAI\Resources\Chat chat()
 * @method static \OpenAI\Resources\Completions completions()
 * @method static \OpenAI\Resources\Containers containers()
 * @method static \OpenAI\Resources\Embeddings embeddings()
 * @method static \OpenAI\Resources\Edits edits()
 * @method static \OpenAI\Resources\Files files()
 * @method static \OpenAI\Resources\FineTunes fineTunes()
 * @method static \OpenAI\Resources\FineTuning fineTuning()
 * @method static \OpenAI\Resources\Images images()
 * @method static \OpenAI\Resources\Models models()
 * @method static \OpenAI\Resources\Moderations moderations()
 * @method static \OpenAI\Resources\Realtime realtime()
 * @method static \OpenAI\Resources\Responses responses()
 * @method static \OpenAI\Resources\Threads threads()
 * @method static \OpenAI\Resources\VectorStores vectorStores()
 */
final class OpenAI extends Facade
{
    /**
     * Get the registered name of the component.
     */
    protected static function getFacadeAccessor(): string
    {
        return 'openai';
    }

    /**
     * @param  array<array-key, ResponseContract|StreamResponse|string>  $responses
     */
    public static function fake(array $responses = []): OpenAIFake /** @phpstan-ignore-line */
    {
        $fake = new OpenAIFake($responses);
        self::swap($fake);

        return $fake;
    }
}
PK     S%W]fuW³q   q   "  laravel/src/Testing/OpenAIFake.phpnu „[µü¤        <?php

namespace OpenAI\Laravel\Testing;

use OpenAI\Testing\ClientFake;

class OpenAIFake extends ClientFake {}
PK     S%W]ƒZÅ  Å  *  laravel/src/Exceptions/ApiKeyIsMissing.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Laravel\Exceptions;

use InvalidArgumentException;

/**
 * @internal
 */
final class ApiKeyIsMissing extends InvalidArgumentException
{
    /**
     * Create a new exception instance.
     */
    public static function create(): self
    {
        return new self(
            'The OpenAI API Key is missing. Please publish the [openai.php] configuration file and set the [api_key].'
        );
    }
}
PK     S%W]O:±‡  ‡    laravel/src/Support/View.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Laravel\Support;

use Symfony\Component\Console\Output\OutputInterface;
use Termwind\Termwind;

use function Termwind\render;
use function Termwind\renderUsing;

/**
 * @internal
 */
final class View
{
    /**
     * The implementation of the output.
     */
    private static OutputInterface $output;

    /**
     * Renders views using the given Output instance.
     */
    public static function renderUsing(OutputInterface $output): void
    {
        self::$output = $output;
    }

    /**
     * Renders the given view.
     *
     * @param  array<string, mixed>  $data
     */
    public static function render(string $path, array $data = []): void
    {
        $contents = self::compile($path, $data);

        $existing = Termwind::getRenderer();

        renderUsing(self::$output);

        try {
            render($contents);
        } finally {
            renderUsing($existing);
        }
    }

    /**
     * Compiles the given view.
     *
     * @param  array<string, mixed>  $data
     */
    private static function compile(string $path, array $data): string
    {
        extract($data);

        ob_start();

        $path = str_replace('.', '/', $path);

        include sprintf('%s/../../resources/views/%s.php', __DIR__, $path);

        $contents = ob_get_contents();

        ob_clean();

        return (string) $contents;
    }
}
PK     S%W]K£S†  †  '  laravel/src/Commands/InstallCommand.phpnu „[µü¤        <?php

namespace OpenAI\Laravel\Commands;

use Illuminate\Console\Command;
use OpenAI\Laravel\ServiceProvider;
use OpenAI\Laravel\Support\View;

class InstallCommand extends Command
{
    private const LINKS = [
        'Repository'          => 'https://github.com/openai-php/laravel',
        'OpenAI PHP Docs'     => 'https://github.com/openai-php/client#readme',
        'Join us on Telegram' => 'https://t.me/+66GDs6UM6RcxY2U8',
    ];

    private const FUNDING_LINKS = [
        'Sponsor Sandro' => 'https://github.com/sponsors/gehrisandro',
        'Sponsor Nuno'   => 'https://github.com/sponsors/nunomaduro',
    ];

    protected $signature = 'openai:install';

    protected $description = 'Prepares the OpenAI client for use.';

    public function handle(): void
    {
        View::renderUsing($this->output);

        View::render('components.badge', [
            'type'    => 'INFO',
            'content' => 'Installing OpenAI for Laravel.',
        ]);

        $this->copyConfig();

        View::render('components.new-line');

        $this->addEnvKeys('.env');
        $this->addEnvKeys('.env.example');

        View::render('components.new-line');

        $wantsToSupport = $this->askToStarRepository();

        $this->showLinks();

        View::render('components.badge', [
            'type'    => 'INFO',
            'content' => 'Open your .env and add your OpenAI API key and organization id.',
        ]);

        if ($wantsToSupport) {
            $this->openRepositoryInBrowser();
        }
    }

    private function copyConfig(): void
    {
        if (file_exists(config_path('openai.php'))) {
            View::render('components.two-column-detail', [
                'left'  => 'config/openai.php',
                'right' => 'File already exists.',
            ]);

            return;
        }

        View::render('components.two-column-detail', [
            'left'  => 'config/openai.php',
            'right' => 'File created.',
        ]);

        $this->callSilent('vendor:publish', [
            '--provider' => ServiceProvider::class,
        ]);
    }

    private function addEnvKeys(string $envFile): void
    {
        if (! is_writable(base_path($envFile))) {
            View::render('components.two-column-detail', [
                'left'  => $envFile,
                'right' => 'File is not writable.',
            ]);

            return;
        }

        $fileContent = file_get_contents(base_path($envFile));

        if ($fileContent === false) {
            return;
        }

        if (str_contains($fileContent, 'OPENAI_API_KEY')) {
            View::render('components.two-column-detail', [
                'left'  => $envFile,
                'right' => 'Variables already exists.',
            ]);

            return;
        }

        file_put_contents(base_path($envFile), PHP_EOL . 'OPENAI_API_KEY=' . PHP_EOL . 'OPENAI_ORGANIZATION=' . PHP_EOL, FILE_APPEND);

        View::render('components.two-column-detail', [
            'left'  => $envFile,
            'right' => 'OPENAI_API_KEY and OPENAI_ORGANIZATION variables added.',
        ]);
    }

    private function askToStarRepository(): bool
    {
        if (! $this->input->isInteractive()) {
            return false;
        }

        return $this->confirm(' <options=bold>Wanna show OpenAI for Laravel some love by starring it on GitHub?</>', false);
    }

    private function openRepositoryInBrowser(): void
    {
        if (PHP_OS_FAMILY == 'Darwin') {
            exec('open https://github.com/openai-php/laravel');
        }
        if (PHP_OS_FAMILY == 'Windows') {
            exec('start https://github.com/openai-php/laravel');
        }
        if (PHP_OS_FAMILY == 'Linux') {
            exec('xdg-open https://github.com/openai-php/laravel');
        }
    }

    private function showLinks(): void
    {
        $links = [
            ...self::LINKS,
            ...rand(0, 1) ? self::FUNDING_LINKS : array_reverse(self::FUNDING_LINKS, true),
        ];

        foreach ($links as $message => $link) {
            View::render('components.two-column-detail', [
                'left'  => $message,
                'right' => $link,
            ]);
        }
    }
}
PK     S%W]B£ÕI	  	    laravel/src/ServiceProvider.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Laravel;

use Illuminate\Contracts\Support\DeferrableProvider;
use Illuminate\Support\ServiceProvider as BaseServiceProvider;
use OpenAI;
use OpenAI\Client;
use OpenAI\Contracts\ClientContract;
use OpenAI\Laravel\Commands\InstallCommand;
use OpenAI\Laravel\Exceptions\ApiKeyIsMissing;

/**
 * @internal
 */
final class ServiceProvider extends BaseServiceProvider implements DeferrableProvider
{
    /**
     * Register any application services.
     */
    public function register(): void
    {
        $this->app->singleton(ClientContract::class, static function (): Client {
            $apiKey = config('openai.api_key');
            $organization = config('openai.organization');
            $project = config('openai.project');
            $baseUri = config('openai.base_uri');

            if (! is_string($apiKey) || ($organization !== null && ! is_string($organization))) {
                throw ApiKeyIsMissing::create();
            }

            $client = OpenAI::factory()
                ->withApiKey($apiKey)
                ->withOrganization($organization)
                ->withHttpHeader('OpenAI-Beta', 'assistants=v2')
                ->withHttpClient(new \GuzzleHttp\Client(['timeout' => config('openai.request_timeout', 30)]));

            if (is_string($project)) {
                $client->withProject($project);
            }

            if (is_string($baseUri)) {
                $client->withBaseUri($baseUri);
            }

            return $client->make();
        });

        $this->app->alias(ClientContract::class, 'openai');
        $this->app->alias(ClientContract::class, Client::class);
    }

    /**
     * Bootstrap any application services.
     */
    public function boot(): void
    {
        if ($this->app->runningInConsole()) {
            $this->publishes([
                __DIR__ . '/../config/openai.php' => config_path('openai.php'),
            ]);

            $this->commands([
                InstallCommand::class,
            ]);
        }
    }

    /**
     * Get the services provided by the provider.
     *
     * @return array<int, string>
     */
    public function provides(): array
    {
        return [
            Client::class,
            ClientContract::class,
            'openai',
        ];
    }
}
PK     S%W]0Bá‘¿  ¿    laravel/composer.jsonnu „[µü¤        {
    "name": "openai-php/laravel",
    "description": "OpenAI PHP for Laravel is a supercharged PHP API client that allows you to interact with the Open AI API",
    "keywords": ["laravel","php", "openai", "sdk", "codex", "GPT-3", "DALL-E", "api", "client", "natural", "language", "processing"],
    "license": "MIT",
    "authors": [
        {
            "name": "Nuno Maduro",
            "email": "enunomaduro@gmail.com"
        }
    ],
    "require": {
        "php": "^8.2.0",
        "guzzlehttp/guzzle": "^7.9.3",
        "laravel/framework": "^10",
        "openai-php/client": "^0.15.0"
    },
    "require-dev": {
        "laravel/pint": "^1.22.0",
        "pestphp/pest": "^3.8.2|^4.0.0",
        "pestphp/pest-plugin-arch": "^3.1.1|^4.0.0",
        "phpstan/phpstan": "^1.12.25",
        "symfony/var-dumper": "^7.2.6"
    },
    "autoload": {
        "psr-4": {
            "OpenAI\\Laravel\\": "src/"
        }
    },
    "autoload-dev": {
        "psr-4": {
            "Tests\\": "tests/"
        }
    },
    "minimum-stability": "dev",
    "prefer-stable": true,
    "config": {
        "sort-packages": true,
        "preferred-install": "dist",
        "allow-plugins": {
            "pestphp/pest-plugin": true,
            "php-http/discovery": true
        }
    },
    "extra": {
        "laravel": {
            "providers": [
                "OpenAI\\Laravel\\ServiceProvider"
            ]
        }
    },
    "scripts": {
        "lint": "pint -v",
        "test:lint": "pint --test -v",
        "test:types": "phpstan analyse --ansi",
        "test:unit": "pest --colors=always",
        "test": [
            "@test:lint",
            "@test:types",
            "@test:unit"
        ]
    }
}
PK     S%W]E_>	I  I    laravel/LICENSE.mdnu „[µü¤        The MIT License (MIT)

Copyright (c) Nuno Maduro <enunomaduro@gmail.com>

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
PK     S%W]º{>ö      /  laravel/resources/views/components/new-line.phpnu „[µü¤        <div></div>
PK     S%W]Ùêf¢  ¢  ,  laravel/resources/views/components/badge.phpnu „[µü¤        <?php

/** @var string $type */
/** @var string $content */
[$bgBadgeColor, $bgBadgeText] = match ($type) {
    'INFO'  => ['blue', 'INFO'],
    'ERROR' => ['red', 'ERROR'],
};

?>

<div class="my-1">
    <span class="ml-2 px-1 bg-<?php echo $bgBadgeColor ?>-600 font-bold"><?php echo htmlspecialchars($bgBadgeText) ?></span>
    <span class="ml-1">
        <?php echo htmlspecialchars($content) ?>
    </span>
</div>
PK     S%W]dÂ¾FL  L  8  laravel/resources/views/components/two-column-detail.phpnu „[µü¤        <div class="flex mx-2 max-w-150">
    <span>
        <?php echo htmlspecialchars($left) ?>
    </span>
    <span class="flex-1 content-repeat-[.] text-gray ml-1"></span>
    <?php if ($right !== '') { ?>
        <span class="ml-1 text-gray">
            <?php echo htmlspecialchars($right) ?>
        </span>
    <?php } ?>
</div>

PK     S%W]p;Ÿ?  ?    laravel/config/openai.phpnu „[µü¤        <?php

return [

    /*
    |--------------------------------------------------------------------------
    | OpenAI API Key and Organization
    |--------------------------------------------------------------------------
    |
    | Here you may specify your OpenAI API Key and organization. This will be
    | used to authenticate with the OpenAI API - you can find your API key
    | and organization on your OpenAI dashboard, at https://openai.com.
    */

    'api_key'      => env('OPENAI_API_KEY'),
    'organization' => env('OPENAI_ORGANIZATION'),

    /*
    |--------------------------------------------------------------------------
    | OpenAI API Project
    |--------------------------------------------------------------------------
    |
    | Here you may specify your OpenAI API project. This is used optionally in
    | situations where you are using a legacy user API key and need association
    | with a project. This is not required for the newer API keys.
    */
    'project' => env('OPENAI_PROJECT'),

    /*
    |--------------------------------------------------------------------------
    | OpenAI Base URL
    |--------------------------------------------------------------------------
    |
    | Here you may specify your OpenAI API base URL used to make requests. This
    | is needed if using a custom API endpoint. Defaults to: api.openai.com/v1
    */
    'base_uri' => env('OPENAI_BASE_URL'),

    /*
    |--------------------------------------------------------------------------
    | Request Timeout
    |--------------------------------------------------------------------------
    |
    | The timeout may be used to specify the maximum number of seconds to wait
    | for a response. By default, the client will time out after 30 seconds.
    */

    'request_timeout' => env('OPENAI_REQUEST_TIMEOUT', 30),
];
PK     S%W]$õµWÃ  Ã  '  client/src/ValueObjects/ResourceUri.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\ValueObjects;

use OpenAI\Contracts\StringableContract;

/**
 * @internal
 */
final class ResourceUri implements StringableContract
{
    /**
     * Creates a new ResourceUri value object.
     */
    private function __construct(private readonly string $uri)
    {
        // ..
    }

    /**
     * Creates a new ResourceUri value object that creates the given resource.
     */
    public static function create(string $resource): self
    {
        return new self($resource);
    }

    /**
     * Creates a new ResourceUri value object that uploads to the given resource.
     */
    public static function upload(string $resource): self
    {
        return new self($resource);
    }

    /**
     * Creates a new ResourceUri value object that lists the given resource.
     */
    public static function list(string $resource): self
    {
        return new self($resource);
    }

    /**
     * Creates a new ResourceUri value object that retrieves the given resource.
     */
    public static function retrieve(string $resource, string $id, string $suffix): self
    {
        return new self("{$resource}/{$id}{$suffix}");
    }

    /**
     * Creates a new ResourceUri value object that modifies the given resource.
     */
    public static function modify(string $resource, string $id): self
    {
        return new self("{$resource}/{$id}");
    }

    /**
     * Creates a new ResourceUri value object that retrieves the given resource content.
     */
    public static function retrieveContent(string $resource, string $id): self
    {
        return new self("{$resource}/{$id}/content");
    }

    /**
     * Creates a new ResourceUri value object that cancels the given resource.
     */
    public static function cancel(string $resource, string $id): self
    {
        return new self("{$resource}/{$id}/cancel");
    }

    /**
     * Creates a new ResourceUri value object that deletes the given resource.
     */
    public static function delete(string $resource, string $id): self
    {
        return new self("{$resource}/{$id}");
    }

    /**
     * {@inheritDoc}
     */
    public function toString(): string
    {
        return $this->uri;
    }
}
PK     S%W]]¯”  ”  /  client/src/ValueObjects/Transporter/Headers.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\ValueObjects\Transporter;

use OpenAI\Enums\Transporter\ContentType;
use OpenAI\ValueObjects\ApiKey;

/**
 * @internal
 */
final class Headers
{
    /**
     * Creates a new Headers value object.
     *
     * @param  array<string, string>  $headers
     */
    private function __construct(private readonly array $headers)
    {
        // ..
    }

    /**
     * Creates a new Headers value object
     */
    public static function create(): self
    {
        return new self([]);
    }

    /**
     * Creates a new Headers value object with the given API token.
     */
    public static function withAuthorization(ApiKey $apiKey): self
    {
        return new self([
            'Authorization' => "Bearer {$apiKey->toString()}",
        ]);
    }

    /**
     * Creates a new Headers value object, with the given content type, and the existing headers.
     */
    public function withContentType(ContentType $contentType, string $suffix = ''): self
    {
        return new self([
            ...$this->headers,
            'Content-Type' => $contentType->value . $suffix,
        ]);
    }

    /**
     * Creates a new Headers value object, with the given organization, and the existing headers.
     */
    public function withOrganization(string $organization): self
    {
        return new self([
            ...$this->headers,
            'OpenAI-Organization' => $organization,
        ]);
    }

    /**
     * Creates a new Headers value object, with the given project, and the existing headers.
     */
    public function withProject(string $project): self
    {
        return new self([
            ...$this->headers,
            'OpenAI-Project' => $project,
        ]);
    }

    /**
     * Creates a new Headers value object, with the newly added header, and the existing headers.
     */
    public function withCustomHeader(string $name, string $value): self
    {
        return new self([
            ...$this->headers,
            $name => $value,
        ]);
    }

    /**
     * @return array<string, string> $headers
     */
    public function toArray(): array
    {
        return $this->headers;
    }
}
PK     S%W]òÃ¸  ¸  0  client/src/ValueObjects/Transporter/Response.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\ValueObjects\Transporter;

use OpenAI\Responses\Meta\MetaInformation;

/**
 * @template-covariant TData of array|string
 *
 * @internal
 */
final class Response
{
    /**
     * Creates a new Response value object.
     *
     * @param  TData  $data
     */
    private function __construct(
        private readonly array|string $data,
        private readonly MetaInformation $meta
    ) {
        // ..
    }

    /**
     * Creates a new Response value object from the given data and meta information.
     *
     * @param  TData  $data
     * @param  array<string, array<int, string>>  $headers
     *
     * @return Response<TData>
     */
    public static function from(array|string $data, array $headers): self
    {
        // @phpstan-ignore-next-line
        $meta = MetaInformation::from($headers);

        return new self($data, $meta);
    }

    /**
     * Returns the response data.
     *
     * @return TData
     */
    public function data(): array|string
    {
        return $this->data;
    }

    /**
     * Returns the meta information.
     */
    public function meta(): MetaInformation
    {
        return $this->meta;
    }
}
PK     S%W]Ÿ,J–  –  3  client/src/ValueObjects/Transporter/QueryParams.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\ValueObjects\Transporter;

/**
 * @internal
 */
final class QueryParams
{
    /**
     * Creates a new Query Params value object.
     *
     * @param  array<string, string|int>  $params
     */
    private function __construct(private readonly array $params)
    {
        // ..
    }

    /**
     * Creates a new Query Params value object
     */
    public static function create(): self
    {
        return new self([]);
    }

    /**
     * Creates a new Query Params value object, with the newly added param, and the existing params.
     */
    public function withParam(string $name, string|int $value): self
    {
        return new self([
            ...$this->params,
            $name => $value,
        ]);
    }

    /**
     * @return array<string, string|int>
     */
    public function toArray(): array
    {
        return $this->params;
    }
}
PK     S%W]ö¡Ô•      /  client/src/ValueObjects/Transporter/Payload.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\ValueObjects\Transporter;

use Http\Discovery\Psr17Factory;
use Http\Message\MultipartStream\MultipartStreamBuilder;
use OpenAI\Contracts\Request;
use OpenAI\Enums\Transporter\ContentType;
use OpenAI\Enums\Transporter\Method;
use OpenAI\ValueObjects\ResourceUri;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\StreamInterface;

/**
 * @internal
 */
final class Payload
{
    /**
     * Creates a new Request value object.
     *
     * @param  array<string, mixed>  $parameters
     */
    private function __construct(
        private readonly ContentType $contentType,
        private readonly Method $method,
        private readonly ResourceUri $uri,
        private readonly array $parameters = [],
    ) {
        // ..
    }

    /**
     * Creates a new Payload value object from the given parameters.
     *
     * @param  array<string, mixed>  $parameters
     */
    public static function list(string $resource, array $parameters = []): self
    {
        $contentType = ContentType::JSON;
        $method = Method::GET;
        $uri = ResourceUri::list($resource);

        return new self($contentType, $method, $uri, $parameters);
    }

    /**
     * Creates a new Payload value object from the given parameters.
     *
     * @param  array<string, mixed>  $parameters
     */
    public static function retrieve(string $resource, string $id, string $suffix = '', array $parameters = []): self
    {
        $contentType = ContentType::JSON;
        $method = Method::GET;
        $uri = ResourceUri::retrieve($resource, $id, $suffix);

        return new self($contentType, $method, $uri, $parameters);
    }

    /**
     * Creates a new Payload value object from the given parameters.
     *
     * @param  array<string, mixed>  $parameters
     */
    public static function modify(string $resource, string $id, array $parameters = []): self
    {
        $contentType = ContentType::JSON;
        $method = Method::POST;
        $uri = ResourceUri::modify($resource, $id);

        return new self($contentType, $method, $uri, $parameters);
    }

    /**
     * Creates a new Payload value object from the given parameters.
     */
    public static function retrieveContent(string $resource, string $id): self
    {
        $contentType = ContentType::JSON;
        $method = Method::GET;
        $uri = ResourceUri::retrieveContent($resource, $id);

        return new self($contentType, $method, $uri);
    }

    /**
     * Creates a new Payload value object from the given parameters.
     *
     * @param  array<string, mixed>  $parameters
     */
    public static function create(string $resource, array $parameters): self
    {
        $contentType = ContentType::JSON;
        $method = Method::POST;
        $uri = ResourceUri::create($resource);

        return new self($contentType, $method, $uri, $parameters);
    }

    /**
     * Creates a new Payload value object from the given parameters.
     *
     * @param  array<string, mixed>  $parameters
     */
    public static function upload(string $resource, array $parameters): self
    {
        $contentType = ContentType::MULTIPART;
        $method = Method::POST;
        $uri = ResourceUri::upload($resource);

        return new self($contentType, $method, $uri, $parameters);
    }

    /**
     * Creates a new Payload value object from the given parameters.
     */
    public static function cancel(string $resource, string $id): self
    {
        $contentType = ContentType::JSON;
        $method = Method::POST;
        $uri = ResourceUri::cancel($resource, $id);

        return new self($contentType, $method, $uri);
    }

    /**
     * Creates a new Payload value object from the given parameters.
     */
    public static function delete(string $resource, string $id): self
    {
        $contentType = ContentType::JSON;
        $method = Method::DELETE;
        $uri = ResourceUri::delete($resource, $id);

        return new self($contentType, $method, $uri);
    }

    /**
     * Creates a new Psr 7 Request instance.
     */
    public function toRequest(BaseUri $baseUri, Headers $headers, QueryParams $queryParams): RequestInterface
    {
        $psr17Factory = new Psr17Factory;

        $body = null;

        $uri = $baseUri->toString() . $this->uri->toString();

        $queryParams = $queryParams->toArray();
        if ($this->method === Method::GET) {
            $queryParams = [...$queryParams, ...$this->parameters];
        }

        if ($queryParams !== []) {
            $uri .= '?' . http_build_query($queryParams);
        }

        $headers = $headers->withContentType($this->contentType);

        if ($this->method === Method::POST) {
            if ($this->contentType === ContentType::MULTIPART) {
                $streamBuilder = new MultipartStreamBuilder($psr17Factory);

                /** @var array<string, StreamInterface|string|int|float|bool|array<int, string>> $parameters */
                $parameters = $this->parameters;

                foreach ($parameters as $key => $value) {
                    if (is_int($value) || is_float($value) || is_bool($value)) {
                        $value = (string) $value;
                    }

                    if (is_array($value)) {
                        foreach ($value as $nestedValue) {
                            $streamBuilder->addResource($key . '[]', $nestedValue);
                        }

                        continue;
                    }

                    $streamBuilder->addResource($key, $value);
                }

                $body = $streamBuilder->build();

                $headers = $headers->withContentType($this->contentType, '; boundary=' . $streamBuilder->getBoundary());
            } else {
                $body = $psr17Factory->createStream(json_encode($this->parameters, JSON_THROW_ON_ERROR|JSON_UNESCAPED_UNICODE));
            }
        }

        $request = $psr17Factory->createRequest($this->method->value, $uri);

        if ($body instanceof StreamInterface) {
            $request = $request->withBody($body);
        }

        foreach ($headers->toArray() as $name => $value) {
            $request = $request->withHeader($name, $value);
        }

        return $request;
    }
}
PK     S%W]di›?  ?  /  client/src/ValueObjects/Transporter/BaseUri.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\ValueObjects\Transporter;

use OpenAI\Contracts\StringableContract;

/**
 * @internal
 */
final class BaseUri implements StringableContract
{
    /**
     * Creates a new Base URI value object.
     */
    private function __construct(private readonly string $baseUri)
    {
        // ..
    }

    /**
     * Creates a new Base URI value object.
     */
    public static function from(string $baseUri): self
    {
        return new self($baseUri);
    }

    /**
     * {@inheritdoc}
     */
    public function toString(): string
    {
        foreach (['http://', 'https://'] as $protocol) {
            if (str_starts_with($this->baseUri, $protocol)) {
                return "{$this->baseUri}/";
            }
        }

        return "https://{$this->baseUri}/";
    }
}
PK     S%W]B@9w)  )  "  client/src/ValueObjects/ApiKey.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\ValueObjects;

use OpenAI\Contracts\StringableContract;

/**
 * @internal
 */
final class ApiKey implements StringableContract
{
    /**
     * Creates a new API token value object.
     */
    private function __construct(public readonly string $apiKey)
    {
        // ..
    }

    public static function from(string $apiKey): self
    {
        return new self($apiKey);
    }

    /**
     * {@inheritdoc}
     */
    public function toString(): string
    {
        return $this->apiKey;
    }
}
PK     S%W]Bdá-  -    client/src/Factory.phpnu „[µü¤        <?php

namespace OpenAI;

use Closure;
use Exception;
use GuzzleHttp\Client as GuzzleClient;
use Http\Discovery\Psr18ClientDiscovery;
use OpenAI\Transporters\HttpTransporter;
use OpenAI\ValueObjects\ApiKey;
use OpenAI\ValueObjects\Transporter\BaseUri;
use OpenAI\ValueObjects\Transporter\Headers;
use OpenAI\ValueObjects\Transporter\QueryParams;
use Psr\Http\Client\ClientInterface;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
use Symfony\Component\HttpClient\Psr18Client;

final class Factory
{
    /**
     * The API key for the requests.
     */
    private ?string $apiKey = null;

    /**
     * The organization for the requests.
     */
    private ?string $organization = null;

    /**
     * The project for the requests.
     */
    private ?string $project = null;

    /**
     * The HTTP client for the requests.
     */
    private ?ClientInterface $httpClient = null;

    /**
     * The base URI for the requests.
     */
    private ?string $baseUri = null;

    /**
     * The HTTP headers for the requests.
     *
     * @var array<string, string>
     */
    private array $headers = [];

    /**
     * The query parameters for the requests.
     *
     * @var array<string, string|int>
     */
    private array $queryParams = [];

    private ?Closure $streamHandler = null;

    /**
     * Sets the API key for the requests.
     */
    public function withApiKey(string $apiKey): self
    {
        $this->apiKey = trim($apiKey);

        return $this;
    }

    /**
     * Sets the organization for the requests.
     */
    public function withOrganization(?string $organization): self
    {
        $this->organization = $organization;

        return $this;
    }

    /**
     * Sets the project for the requests.
     */
    public function withProject(?string $project): self
    {
        $this->project = $project;

        return $this;
    }

    /**
     * Sets the HTTP client for the requests.
     * If no client is provided the factory will try to find one using PSR-18 HTTP Client Discovery.
     */
    public function withHttpClient(ClientInterface $client): self
    {
        $this->httpClient = $client;

        return $this;
    }

    /**
     * Sets the stream handler for the requests. Not required when using Guzzle.
     */
    public function withStreamHandler(Closure $streamHandler): self
    {
        $this->streamHandler = $streamHandler;

        return $this;
    }

    /**
     * Sets the base URI for the requests.
     * If no URI is provided the factory will use the default OpenAI API URI.
     */
    public function withBaseUri(string $baseUri): self
    {
        $this->baseUri = $baseUri;

        return $this;
    }

    /**
     * Adds a custom HTTP header to the requests.
     */
    public function withHttpHeader(string $name, string $value): self
    {
        $this->headers[$name] = $value;

        return $this;
    }

    /**
     * Adds a custom query parameter to the request url.
     */
    public function withQueryParam(string $name, string $value): self
    {
        $this->queryParams[$name] = $value;

        return $this;
    }

    /**
     * Creates a new Open AI Client.
     */
    public function make(): Client
    {
        $headers = Headers::create();

        if ($this->apiKey !== null) {
            $headers = Headers::withAuthorization(ApiKey::from($this->apiKey));
        }

        if ($this->organization !== null) {
            $headers = $headers->withOrganization($this->organization);
        }

        if ($this->project !== null) {
            $headers = $headers->withProject($this->project);
        }

        foreach ($this->headers as $name => $value) {
            $headers = $headers->withCustomHeader($name, $value);
        }

        $baseUri = BaseUri::from($this->baseUri ?: 'api.openai.com/v1');

        $queryParams = QueryParams::create();
        foreach ($this->queryParams as $name => $value) {
            $queryParams = $queryParams->withParam($name, $value);
        }

        $client = $this->httpClient ??= Psr18ClientDiscovery::find();

        $sendAsync = $this->makeStreamHandler($client);

        $transporter = new HttpTransporter($client, $baseUri, $headers, $queryParams, $sendAsync);

        return new Client($transporter);
    }

    /**
     * Creates a new stream handler for "stream" requests.
     */
    private function makeStreamHandler(ClientInterface $client): Closure
    {
        if (! is_null($this->streamHandler)) {
            return $this->streamHandler;
        }

        if ($client instanceof GuzzleClient) {
            return fn (RequestInterface $request): ResponseInterface => $client->send($request, ['stream' => true]);
        }

        if ($client instanceof Psr18Client) { // @phpstan-ignore-line
            return fn (RequestInterface $request): ResponseInterface => $client->sendRequest($request); // @phpstan-ignore-line
        }

        return function (RequestInterface $_): never {
            throw new Exception('To use stream requests you must provide an stream handler closure via the OpenAI factory.');
        };
    }
}
PK     S%W]¿!Ã  Ã    client/src/OpenAI.phpnu „[µü¤        <?php

declare(strict_types=1);

use OpenAI\Client;
use OpenAI\Factory;

final class OpenAI
{
    /**
     * Creates a new Open AI Client with the given API token.
     */
    public static function client(string $apiKey, ?string $organization = null, ?string $project = null): Client
    {
        return self::factory()
            ->withApiKey($apiKey)
            ->withOrganization($organization)
            ->withProject($project)
            ->withHttpHeader('OpenAI-Beta', 'assistants=v2')
            ->make();
    }

    /**
     * Creates a new factory instance to configure a custom Open AI Client
     */
    public static function factory(): Factory
    {
        return new Factory;
    }
}
PK     S%W]œÅ0    +  client/src/Testing/Requests/TestRequest.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Requests;

final class TestRequest
{
    /**
     * @param  array<string, mixed>  $args
     */
    public function __construct(protected string $resource, protected string $method, protected array $args) {}

    public function resource(): string
    {
        return $this->resource;
    }

    public function method(): string
    {
        return $this->method;
    }

    /**
     * @return array<string, mixed>
     */
    public function args(): array
    {
        return $this->args;
    }
}
PK     S%W]ÞÔš8  8  !  client/src/Testing/ClientFake.phpnu „[µü¤        <?php

namespace OpenAI\Testing;

use Exception;
use OpenAI\Contracts\ClientContract;
use OpenAI\Contracts\Resources\VectorStoresContract;
use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseStreamContract;
use OpenAI\Responses\StreamResponse;
use OpenAI\Testing\Requests\TestRequest;
use OpenAI\Testing\Resources\AssistantsTestResource;
use OpenAI\Testing\Resources\AudioTestResource;
use OpenAI\Testing\Resources\BatchesTestResource;
use OpenAI\Testing\Resources\ChatTestResource;
use OpenAI\Testing\Resources\CompletionsTestResource;
use OpenAI\Testing\Resources\EditsTestResource;
use OpenAI\Testing\Resources\EmbeddingsTestResource;
use OpenAI\Testing\Resources\FilesTestResource;
use OpenAI\Testing\Resources\FineTunesTestResource;
use OpenAI\Testing\Resources\FineTuningTestResource;
use OpenAI\Testing\Resources\ImagesTestResource;
use OpenAI\Testing\Resources\ModelsTestResource;
use OpenAI\Testing\Resources\ModerationsTestResource;
use OpenAI\Testing\Resources\RealtimeTestResource;
use OpenAI\Testing\Resources\ResponsesTestResource;
use OpenAI\Testing\Resources\ThreadsTestResource;
use OpenAI\Testing\Resources\VectorStoresTestResource;
use PHPUnit\Framework\Assert as PHPUnit;
use Throwable;

class ClientFake implements ClientContract
{
    /**
     * @var array<array-key, TestRequest>
     */
    private array $requests = [];

    /**
     * @param  array<array-key, ResponseContract|StreamResponse|Throwable|string>  $responses
     */
    public function __construct(protected array $responses = []) {}

    /**
     * @param  array<array-key, ResponseContract|StreamResponse|Throwable|string>  $responses
     */
    public function addResponses(array $responses): void
    {
        $this->responses = [...$this->responses, ...$responses];
    }

    public function assertSent(string $resource, callable|int|null $callback = null): void
    {
        if (is_int($callback)) {
            $this->assertSentTimes($resource, $callback);

            return;
        }

        PHPUnit::assertTrue(
            $this->sent($resource, $callback) !== [],
            "The expected [{$resource}] request was not sent."
        );
    }

    private function assertSentTimes(string $resource, int $times = 1): void
    {
        $count = count($this->sent($resource));

        PHPUnit::assertSame(
            $times, $count,
            "The expected [{$resource}] resource was sent {$count} times instead of {$times} times."
        );
    }

    /**
     * @return mixed[]
     */
    private function sent(string $resource, ?callable $callback = null): array
    {
        if (! $this->hasSent($resource)) {
            return [];
        }

        $callback = $callback ?: fn (): bool => true;

        return array_filter($this->resourcesOf($resource), fn (TestRequest $resource) => $callback($resource->method(), ...$resource->args()));
    }

    private function hasSent(string $resource): bool
    {
        return $this->resourcesOf($resource) !== [];
    }

    public function assertNotSent(string $resource, ?callable $callback = null): void
    {
        PHPUnit::assertCount(
            0, $this->sent($resource, $callback),
            "The unexpected [{$resource}] request was sent."
        );
    }

    public function assertNothingSent(): void
    {
        $resourceNames = implode(
            separator: ', ',
            array: array_map(fn (TestRequest $request): string => $request->resource(), $this->requests)
        );

        PHPUnit::assertEmpty($this->requests, 'The following requests were sent unexpectedly: ' . $resourceNames);
    }

    /**
     * @return array<array-key, TestRequest>
     */
    private function resourcesOf(string $type): array
    {
        return array_filter($this->requests, fn (TestRequest $request): bool => $request->resource() === $type);
    }

    public function record(TestRequest $request): ResponseContract|ResponseStreamContract|string
    {
        $this->requests[] = $request;

        $response = array_shift($this->responses);

        if (is_null($response)) {
            throw new Exception('No fake responses left.');
        }

        if ($response instanceof Throwable) {
            throw $response;
        }

        return $response;
    }

    public function responses(): ResponsesTestResource
    {
        return new ResponsesTestResource($this);
    }

    public function realtime(): RealtimeTestResource
    {
        return new RealtimeTestResource($this);
    }

    public function completions(): CompletionsTestResource
    {
        return new CompletionsTestResource($this);
    }

    public function chat(): ChatTestResource
    {
        return new ChatTestResource($this);
    }

    public function embeddings(): EmbeddingsTestResource
    {
        return new EmbeddingsTestResource($this);
    }

    public function audio(): AudioTestResource
    {
        return new AudioTestResource($this);
    }

    public function edits(): EditsTestResource
    {
        return new EditsTestResource($this);
    }

    public function files(): FilesTestResource
    {
        return new FilesTestResource($this);
    }

    public function models(): ModelsTestResource
    {
        return new ModelsTestResource($this);
    }

    public function fineTunes(): FineTunesTestResource
    {
        return new FineTunesTestResource($this);
    }

    public function fineTuning(): FineTuningTestResource
    {
        return new FineTuningTestResource($this);
    }

    public function moderations(): ModerationsTestResource
    {
        return new ModerationsTestResource($this);
    }

    public function images(): ImagesTestResource
    {
        return new ImagesTestResource($this);
    }

    public function assistants(): AssistantsTestResource
    {
        return new AssistantsTestResource($this);
    }

    public function threads(): ThreadsTestResource
    {
        return new ThreadsTestResource($this);
    }

    public function batches(): BatchesTestResource
    {
        return new BatchesTestResource($this);
    }

    public function vectorStores(): VectorStoresContract
    {
        return new VectorStoresTestResource($this);
    }
}
PK     S%W](º{;Ü  Ü  2  client/src/Testing/Responses/Concerns/Fakeable.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Testing\Responses\Concerns;

use OpenAI\Responses\Meta\MetaInformation;

trait Fakeable
{
    /**
     * @param  array<string, mixed>  $override
     */
    public static function fake(array $override = [], ?MetaInformation $meta = null): static
    {
        $class = str_replace('OpenAI\\Responses\\', 'OpenAI\\Testing\\Responses\\Fixtures\\', static::class) . 'Fixture';

        return static::from(
            self::buildAttributes($class::ATTRIBUTES, $override),
            $meta ?? self::fakeResponseMetaInformation(),
        );
    }

    /**
     * @return mixed[]
     */
    private static function buildAttributes(array $original, array $override): array
    {
        $new = [];

        foreach ($original as $key => $entry) {
            $new[$key] = is_array($entry)
                ? self::buildAttributes($entry, $override[$key] ?? [])
                : $override[$key] ?? $entry;
            unset($override[$key]);
        }

        // we are going to append all remaining overrides
        foreach ($override as $key => $value) {
            $new[$key] = $value;
        }

        return $new;
    }

    public static function fakeResponseMetaInformation(): MetaInformation
    {
        return MetaInformation::from([
            'openai-model'                   => ['gpt-3.5-turbo-instruct'],
            'openai-organization'            => ['org-1234'],
            'openai-processing-ms'           => ['410'],
            'openai-version'                 => ['2020-10-01'],
            'x-ratelimit-limit-requests'     => ['3000'],
            'x-ratelimit-limit-tokens'       => ['250000'],
            'x-ratelimit-remaining-requests' => ['2999'],
            'x-ratelimit-remaining-tokens'   => ['249989'],
            'x-ratelimit-reset-requests'     => ['20ms'],
            'x-ratelimit-reset-tokens'       => ['2ms'],
            'x-request-id'                   => ['3813fa4fa3f17bdf0d7654f0f49ebab4'],
        ]);
    }
}
PK     S%W]gÝ§ëT  T  E  client/src/Testing/Responses/Concerns/FakeableForStreamedResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Testing\Responses\Concerns;

use Http\Discovery\Psr17FactoryDiscovery;
use OpenAI\Responses\StreamResponse;

trait FakeableForStreamedResponse
{
    /**
     * @param  resource  $resource
     */
    public static function fake($resource = null): StreamResponse
    {
        if ($resource === null) {
            $filename = str_replace(['OpenAI\Responses', '\\'], [__DIR__ . '/../Fixtures/', '/'], static::class) . 'Fixture.txt';
            $resource = fopen($filename, 'r');
        }

        $stream = Psr17FactoryDiscovery::findStreamFactory()
            ->createStreamFromResource($resource);

        $response = Psr17FactoryDiscovery::findResponseFactory()
            ->createResponse()
            ->withBody($stream);

        return new StreamResponse(static::class, $response);
    }
}
PK     S%W]6C£  £  M  client/src/Testing/Responses/Fixtures/Assistants/AssistantResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Assistants;

final class AssistantResponseFixture
{
    public const ATTRIBUTES = [
        'id'              => 'asst_SMzoVX8XmCZEg1EbMHoAm8tc',
        'object'          => 'assistant',
        'created_at'      => 1_699_619_403,
        'name'            => 'Math Tutor',
        'description'     => null,
        'model'           => 'gpt-4',
        'instructions'    => 'You are a personal math tutor.',
        'tools'           => [],
        'tool_resources'  => [],
        'metadata'        => [],
        'temperature'     => 0.7,
        'top_p'           => 1.0,
        'response_format' => 'text',
    ];
}
PK     S%W]Èï€ô  ô  Q  client/src/Testing/Responses/Fixtures/Assistants/AssistantListResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Assistants;

final class AssistantListResponseFixture
{
    public const ATTRIBUTES = [
        'object' => 'list',
        'data'   => [
            [
                'id'              => 'asst_SMzoVX8XmCZEg1EbMHoAm8tc',
                'object'          => 'assistant',
                'created_at'      => 1_699_619_403,
                'name'            => 'Math Tutor',
                'description'     => null,
                'model'           => 'gpt-4',
                'instructions'    => 'You are a personal math tutor.',
                'tools'           => [],
                'tool_resources'  => [],
                'metadata'        => [],
                'temperature'     => 0.7,
                'top_p'           => 1.0,
                'response_format' => 'text',
            ],
        ],
        'first_id' => 'asst_SMzoVX8XmCZEg1EbMHoAm8tc',
        'last_id'  => 'asst_SMzoVX8XmCZEg1EbMHoAm8tc',
        'has_more' => false,
    ];
}
PK     S%W]9­Ä    S  client/src/Testing/Responses/Fixtures/Assistants/AssistantDeleteResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Assistants;

final class AssistantDeleteResponseFixture
{
    public const ATTRIBUTES = [
        'id'      => 'asst_SMzoVX8XmCZEg1EbMHoAm8tc',
        'object'  => 'assistant.deleted',
        'deleted' => true,
    ];
}
PK     S%W]³Þ*P    K  client/src/Testing/Responses/Fixtures/Moderations/CreateResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Moderations;

final class CreateResponseFixture
{
    public const ATTRIBUTES = [
        'id'      => 'modr-5MWoLO',
        'model'   => 'text-moderation-001',
        'results' => [
            [
                'categories' => [
                    'hate'                   => false,
                    'hate/threatening'       => true,
                    'harassment'             => false,
                    'harassment/threatening' => false,
                    'self-harm'              => false,
                    'self-harm/intent'       => false,
                    'self-harm/instructions' => false,
                    'sexual'                 => false,
                    'sexual/minors'          => false,
                    'violence'               => true,
                    'violence/graphic'       => false,
                ],
                'category_scores' => [
                    'hate'                   => 0.22714105248451233,
                    'hate/threatening'       => 0.4132447838783264,
                    'harassment'             => 0.1602763684674149,
                    'harassment/threatening' => 0.1602763684674149,
                    'self-harm'              => 0.005232391878962517,
                    'self-harm/intent'       => 0.005134391873962517,
                    'self-harm/instructions' => 0.005132591874962517,
                    'sexual'                 => 0.01407341007143259,
                    'sexual/minors'          => 0.0038522258400917053,
                    'violence'               => 0.9223177433013916,
                    'violence/graphic'       => 0.036865197122097015,
                ],
                'flagged' => true,
            ],
        ],
    ];
}
PK     S%W]:Y}r ×   ×  ?  client/src/Testing/Responses/Fixtures/Audio/speech-streamed.mp3nu „[µü¤        ÿóäÄ b<9¸YÀ 6–3€US%sŽ³¾ó®3\°ÀÖÉŠ©ÃiëÉó™ÒØ)v|YC$s2×¨:C–Ì³k<(Þç4¦z”!:$Ð cÍÎ%\iÈ˜ê'±pa{<Ä¶| !©†æŒ
!qË¾YrÍ —ÓF/FÇa†(B"¢‚2È}Ûklí¯Ãôò·mv*EØâR»líÇŽ,:ÇgjfYó*Mi:†^m*ÏK&ÚÛ_£vØz™¡,¶e“,Ú?ÃIŽÛ²î\K_ú8ÜÒä.à  a: Ô$#äÒÒ å³ ŒÎs”R88Øƒ °ºbBl¸ênýÓ¾êÞZ³Î8@ÜÃ@‹á¬;/’"yeÀ!-—½ü-!hFî½J¬×ºªJ;CZœ,‚
9%«7@árŒÄ0‹¯ûä;’É¶¶ÎáäL3œÊ…0$  ˆ8[t]r9CùŒ?Ž\?oþ½¸âÂ-×\_9\7/”3¶¿<à%áwÀµ™l Ó*ÓÜvÃ¸vÂ€Bb"ƒžr:y0Pa‚ŒšiÙ÷-	Ê-˜È:ß2”“}M4³«JU…ÿlàmÃ1„£R13ƒ¶o?V$*Ñ¡ð}ÿóäÄJy”:0›Ø Î‡FkTgŽìÒ~ÃçÍtvKGz¦bElRfÌŠd ÁÃ)Dq/KÐ}Öi†è„aBhLd¡†0Pb§aPƒ,èéŠŒ‰$„NýúYø8Ó€« B q!1À!Šà1Ñ¢ê,ÀH¡„
@I€¥òçâ î`ÖÈ˜ÇHIDÁC†(4
DL* á2…£Ù† ¿¦˜dÕX:ì–NJK³Ì¡’HÍ8èÄED( bs@Œ˜Hªl¤ÆbD 3`32²£I01˜(tÀHA·ŸlË(ÔQ{öãÏ B£†c¡i€,D`ÊZ!/`(<a‚ côÅ@y‚ƒ€‰R8Æ	ÁB>``¥F@Hc41q=2 ¹‘AûqˆbqåQNßÂAn‘–CÆÆ†_n(²#-`yˆÄQ¨»©` 1Ñ´K/(ÁÀ.à 0ÁÄ ËE²;èv,Š1Š–Dª$©Qè
ø±|‡*HÈ¸ä0<)1üš1åt:Ò•:T¤4r3Ä„8`…2”3Qá4Î¨2ç1ðM28¡2tê& …ÿóäÄ6_\:NÝÈ ò ÐÁ`N|‚ fZõ³PP©É
ÉC€a³Ä™¦)¬š¥2¾;u=`”M:”¸ (T&V÷…@UµDaˆÂ$( .r©È”ë”Ñ?KµaUÌ©þ‡¢Ô´ÞÿJëF¥øLÇ£ïú°*TŠ%AEp \2Àç¡û­y¯Ý¥gí!ÉžLÆ–°
M¶fb@‚D/S	U­ºÕiÉj®\XÌµÙ]™ë‘×eÉq_ØÎ1÷õ¬µÙlš††A”ü5Z4×šó:aÎíWeé†fyœjv4ý?Õ¥ÏóÌû3—¥xØÜ®’[KÅZt‘õ´ÑÙC†Ò–ª3Wí’¶ì­ê‡!ö)Ê]I=¸)Õ~¥÷b±˜6S|áOì Ë`Xzyº¶®®x]·qÈ‰¸°ÌAèvã²¨£[¥Ž8¼
ÿ5Øô<ùÃó¹C`?$a2žb’¨hj"  d·ƒ°b”d%	~` ‡ôa€Þ`æJcu	`"…€a2¼`. ²`+rs@æ
ži&BÐ4üZevHcãÀ óHe5€ÑaÛ0èÉ‘¤Ú!Éê>aÙÉŠM‰´ÐtÓÍ88ã[Œ,(ØYÂÀÃ@Åå1ÿóäÄ‹w<9üþô”ÃG  ±›plcšY<I¨6\tÑš0
C”€IÜHJ—J[TŠ1¨Ž¥b¯i«™[¤›Ê&›»]qe­xD4PX©ƒ 8,@X"0HLúãoéÚ;ôŽlc‚èÕ¢2¤ˆÆ&LPT‘$ùmœ]ä¾/ñm—RÃ-•8@2×ÚƒØ”Z5 Þ€g\‚U*eÔ¡©‚Ã\WUàjKEvÆž·†–tYjÂ³˜)æqžº ;e©ÊªÍz	]²5)iÍv¢“Nr¬$2c5¥¢ò¬e“Z.\.E3pHƒ¶Ëùj€Djh:ªf
ý]­Á‹¨+bžVÖ*ã.æêÞ»,µ–©.J š²Õâ_&d-¥„ªL$†‹2§¨ 2744é}™{”ó^QVJª«ÔT Ñfª­1‘#’ñ0„@DK³H¨cÊì†XVšzPû Cž3#ƒá{1h“¡L0¥
SPÏ0~!ãàê1ƒ  ‚0V£àD%Ãà0;3p/030 Á )
qZB€ÂIú_Ó pTP0Tp4‘‡X˜ÑˆÞ%qfBe˜`ÿóäÄ|9Ì1^Ð Q	m‹ðp‰+:Ã LŠa $„(rQ	P`°äà‘dIa‚£Ì(á &l¦bÎ€@‰lCÅAË'0ñr€á!ˆÐPª2”È+F,ÑÒ(hY…dx*
‡ SÕñL@@ Ë‚ÎW	AF–… &-4µäK“±QERø µ~HB² qI(0È&D„ä#\à€c^lêy{†@(ßvxB DKqW°°s@&•Ä‘3Ä……‚`CÄ[r`¨Ø±—ìªÁItÒ—kvPÄqnÂNÁŒ ‚Ìq”¶ÿ1pÀŒ©Ì]A`J`ƒ2d9@$ T P+­õ‚G­5/LFàµÊÁ´ä:.ÉØu›¦»-“|ÓfÔöO…pÞ7WÕ„0T“0 Š€›¬ âªD¢à €e‰HÎRÐd- ­Õ‚Ai À07ó$0S à €±‚¸˜HñŠ¨+˜©ƒ * Àà5Y‚(Ë\€LãSxÄÀ¸(‰gš«¦í8Æ\ G¦€(¦¦©ŽaÃ€6Âa0`ÿóäÄcyÜ:(3žè ºcÈ*
#Œ}
úbH‚ð;jn¡áI‡`YP0$A	ÌÊ“ Ø—ÄItzÊÏGç¹
Ê`HB&j® !YeäQ›ÌCŽ‚h“ p,—H 0d]M.‚â®X( e‘bKeîñE(0àH&„ j5—‘8`åˆ` p2
™ö–¯uJ+9Zí‰e%˜bYy¬#ºßŸ‡Ü»¹Ã²©k¢ü)7ˆ¿7íËä2:´ô–L(]ÈüŽBû¿ólîrØ›fk-¢¶‰V¬8`ÙUI[Pp° .4´5S!J
€ª¤šâK…>ŸÉ¤–B@  ý º»¶¹KQ¿v"Ò¤„.‡×ÄUjKr€AÀav‹œÌ
ÀC@B Dap `˜D$
 `q  `0|% ðhÐ-  Gò¨: ˜L†%é0)€£@Ñ€ ƒA• CAqÀ°ÂðxÀàc ‚›Ê!ŠPè6c{ªvÿêqÊ^eá¼"ÌCƒÂ üÃÀlÄ€ôÅ T40¼ 0`S1 0 0ˆW1„z2Tˆ1Ü`B" „ÃÅð,h£&YÿóäÄNsD:,­ÝØ 4f’FZk¤æ¾Šr,çÆo¡fŠc¥frŠ”fŒÆœ,e†°„`&Úr4‚8T	0Ós1tX1€Ó1à@0¬ÐRÌ¤,À€Œpp!XÂ	Œøx²‚  2!£ 1²A“?E2qT[&é‰Ž˜èùqŒ4T&¢Æ»AÀê"\„0
  X€e'À  €çÈ@*c¡ñ‡@2"${Ü k½¯ÃWXšò/â6;«5 PrÛÊš)‡±UƒTìK ×¯¬‚–ýh!£qL6ÄY@Pœµ†ê°ò6º‡%¯½{H„„d”ÏIuË^Ùhî¡-5áÛoã,›‡›£ x6òÄep¹ZWŒAÒØ›¦ÿÊ4ÿ7xÿ2è²ê ÷]€C¯kMX®w…¼PI„A—`¨ew½ÌEË•:ÉÊiëUH¯èjÄf^÷:‘7ö•Úšòîw›´1:Ñ¹t~…®fÕ†ÌÙ‰6ú¤ÌDlÆü§LhEDÑ”žŒ€Q”ÔåwMPÎÌÆŒBÌVCdÀ”9L}ÌÜËÌŒï“0Î0FŒÁ\Åæ“W³M†O2±xÇÆC7 ¤  ÀÓ‡`ÃL÷ÿóäÄTq„:0÷2˜2ÙTÄ	C!ÐŽíÞ1¢´3Va£ŽS&›$šX‹7,=˜MapR¢ŒÚ*1H@T dj O˜ü’˜l<  \e~pFšø‰‚02p[”†,;HDP1F)ˆOð¸ ÈÌÇN Vz¿0k%ì$Rüi$Â-š“˜%@I‡ÐÂ¦ZñKpm]Ú4šJç	–U	­‰D¬®*†5Ô¸ï¤ŠÝZE®_Kü³(	[ì)Î–¯ì±¤«tI	RéLûMz3NVM»Ómù·ì‰º£êÊAåöà—³ZŠò`ÐÜ1—eÅ‘5õyÀÏ«3jó`‚–e!ŸÙ:ñjmë™rYÚ&ä¶Þ¨y‘«Q0.ëh­9¦G]HiÂ•1A”Â ™µªÇ¡»QéCX|ˆü]òS"q%­B&ÙùDî@Œ™z¦=L•ÄGUûJN“<ŠRÀ€DÁ¡TÉä¤ñpl8ö¥ªH£#îcèt3DÉQ$]4Å`&„žd"äÀK ²F`,üfÃ
\`¸a¯jùò˜Ú%GÄFh$jä&$@(*dÿóäÄahŒ:`îò’„E¥â`'A0î±uÍBS@ §(¡¦N@¶i#ŸÕ|EáCEÔ.ã@@a†Z fXº&˜’`Ž0¶lH*Jš5íÂ¢rn_AN<+N_ÖÁ0Y“C`MmV:
ì/Ötî@P²Ò& 9ÖìäAñ‡&iðk1ªl_øyå†¸…‡"Zã90§5¹<,Ñ‹¹pcîõ½ÝÍ·+}ZS?]—ñaö]§J òF^w¡ÙÉ]ÌA±§Êzäù?EçN‹JêÀÔÎt¾´·nZÜ”0TVF[÷m• ‚a¡Òî&JõºŸO` e†0Ç,Â Õb1Å$‘]­©’tD‰ˆ¨(¡‰@š`gÐ\h"ö	%º_1ŠuÖ»'Pòê˜$0ÐPqÆHH¼¬&8€dr¨‹v	-žU@$Ôip°ÐX(	0H°Ë”³O 0aÓ    3`I0Ë#’Î6Oó  1TÍ2ã)Ì2R6·Lheç4 S¥[e¹¹	Â Ñ‰%›EIþwŸ›1Ç™8$ yá$Ì=èØ8Bb¥†O v¥g$˜d bÁ¦
Dh(B~jÂÿóäÄ‘b”:Hç¶(6:\_(‚] i|,¤”è˜”(ç^$à³—É²ÌÈ§]Ôª‚T—=XšÁ…Š-µîa‚†H
¦€°‰&ÃÜÚÀ"‡4‰f3®[°Ë§»PJ'é®ò5KWR×æ“+qžPV­ZS†_Ùl¦íìipÊÔ»ªÓÖi«g„õ{Ò¨j].½jüªÕÉš
Üš±’ORÃPŠtaQèzäu ¼eëwã-ÖË‡A¾YÃ°ÔBD™²¨´ý<Ã_m¼7¢lù¬?òèž‰eár9-vZÄÔ=r'fàyS/¼Î{ÐÂ#Oüº?°Cv"2ØËñvLAME3.100UUUUUUUUUUUUUUUUUUUU0)ã pÉ€  :†9ƒ‚|&!úóf˜N‹“†ü×]™¦‡é*	%—P i0G*ðh`‘çyÒ ’:Á–	¢Š`ÀŽY‡”˜ˆ‚?–È`À ŒDœã(Í`XÕP‹ÄA†F|Ý§PŽ:a"„¦(blÓ'¢¡â@ôX‚Ì ÖÒƒÜŸ`‚ ¸ŽóôÒaÕ¤ÐŸÙ«qš	sq~¦™SÍ,C$Ön*•„¤Š+y ÿóäÄ¼cÜ:, ÷v(¢qx‘ìÄHŒœ°ËÊˆ€€+Ð* a Æ2‡)ëX®,;EW	Þ‡ŸéëÒ«R™ÚYß”ò#f¶õùwÇzÇ_ÞóëeÚ\y¬ñ«K¬é#Yvõ,3;_CÑÖ³=‘Ã´¯:gNU˜“:zYË-`LºýjðNƒV	+U‘ö´“ªžÖ
d ,Fí@ÑÕmBJ`Èå5aÛ°êÒ~ÚK½2ÈQ4¸¨ªÉh¡K™1y–"‘9:”($¼™²˜©Š@ *õ`•ó*KâÙ ´žƒªLAME3.1000`
¶c)²`Õpaâ€ðcVb4 jW 0c †ža‹$`’|`V„6aD*a `
 „`Y€\Q ÒŒaæœ(4‘…L$<Á!‹ªb@£$6aBd˜‚&1iÁƒ*÷ 
`ÃŠ:#L1Ò "íe£;æœ$g°ô1¨Ž)7YQsº*ZÂ"“VtÀW%È•PBm AÓÈE5 ¬,ªE›Š¨1 Y(Q'iŒCj„Ò„nXfl‰ñ#¦5™&•,ÉC9Ù}ÐºXKÌ˜Î*A—U3Ø¥ˆ‚U<š¢ÿóäÄörT9Øþ°˜É:˜€ŸÆ'´ÃzÌ|Ež¯Ä©ˆ¬ˆ£$r"P—Bt',À$Ïcé à¯u¬µ’¡½`K™0¡2÷…®fÄ—T©©5™¨»_¥¾²é@—šH±†´¬ë¡îNW=@SI‡™P”hà¸“‰òHäGHÖžæXi ÉÌÑ`ñËêªêiR_‚ÊPQäª0Q„¾ª…ïARç/ôØZ0K,Ia`rÚòqÖ„ðÂˆHiÄ€ád¤ýRÕºà àÅ—Ò á5ôd5‘ZêLAMEªœ>ÛÐÄELN…üÂ°Œ0ˆÅ|AL:ÍŒÈ0=>†ØÊÑÌéÊìÉüÚÌDËTËÌéÍlÊ$\ÌRElÄdLDÅ|CÌÂè#&ÃÃ‹`Æ(I’ùc‚ê"y!Û™k F¨nÄ+Ãì¨½"%¡†rÊc’él€‹œ$lŠ [ÐQ¦@‘!ÐU€ó(È1@‚‚[`‰$F Px ((‚s€PéÌ`s@ixS½1ÄEFŒYÓ90ÃÈ–\‚6¤1j‰¶m@‘XÍ)/ºÁ¢´âƒOöŒ½ŒcP‘²P+ÿóäÄúsT9Ä
öpÜæË•z— º€†¤X÷à^ BXâ"¤ˆ€ó*hC>,‚¸Geâ€a@ éP;%cH kÎ_fÑ2W¹5¤%¤¶8},Œj$³Ž*ê@|:0áÀÁSF$À\¶Cq÷_¨ˆšì"@T+æ]!â‡¼‰Â\'Uúw°ÇÝ=Q5¬¤4Ii$ÃCÅ”ä­‚a@¬Íh§[4Gîá-k«Å·&¸¶D€'!«C]ÒuTSMLÕ+þ^ÖJ»ŒToãnH<ˆðÃˆ¹Z40ÉêLAME3.100žmD@Ï1ìLNœÙ¶¬ÚtTÌ³ˆàðÀÂhêùØæK¼Á ààÄÕCÐç¤ÈF´Ç¼Ô#”ÒÂŒÈ±È@˜¤'˜	/ÑDKšÙ„`CTÃÜAVIÊCSdó$@ãÀÉ `]àïÐðµÀ73.)¦Ñ¬u€ÃÀ+\aÌf¨5`$MrÍ‚†$P`hªHN2 ¤”	ŒòR<P°`áƒ‰:Œª„!„ƒ„?×#™(¦+A+0JZDj ¢Ò$F€ÀQ†HS™4…C‘Qp©Š¦ ÁCÚ@ –ŒÂuIŒBŠ‰ÿóäÄörl9È
÷rãÕìpá`™q0«<dÈe†ˆ‚V†Fò QÀµ/áuÑ¬Db	*D›•³×%Ëdè Š¹H$¢ÐJa	ÈúZ£Qï“¡°¾M	EmËÝ0YÌµÔKåä[äºk--)Ú˜ëa\!£B-œ°¸eÉSfBªËuPÁäG%gªù‰À­(8çÍ[ÖÍm¡3õ:RÚGV4ªäEl¾–2a´š‰ëí§±vœ±œe9f·—;–µTQ[×›l^rô*dù[Í‹»©oUô<…ìùž½9“ù¹"LAMEˆÃ24&CÃ?qì0½#U1ó ÿ0xÓ  0s €'0ƒf0 àQ0j	³	 q(Ö(`ÀP0 ¤vBi€ÈÊD€ 8À
‚½TÉ¢®Œ’ÊièTÈA(›Ys+Ð‚ÈØë\æ,Fpèl°	ÈU!¦ŒBYˆ*Ü <ËÎo­äÀ˜Älœ TÕäÚ¡ú„E©2!KˆTÉ¤ƒ 5¡g@ÂÍ
†…„¨1gKxŒ°ÁAÐ0ÀAM&y{ i°ó'`˜Ë³$®\ ºiêÏ[YKhÿóäÄûsŒ9Ì3^È ”t—C62¦È2/úã¥,õLKõa!4 Ps ¥‹–¥O!Ñb@eÐLŽ hÜ`ùl>FºY¦"Æ·Õd6Ò“%2‰—V($*…Š©Sœ:eä‡d’_Èž_2ï¤€°MÍUT¸@z€-o™ò°®†î<REcSùœ¸¯ûôê½m/šú]Ä™r²É¥òü.‚ê^©Vç‡þ=EËfŒÙÿtRN»/p”¡×u]Æõu'ÒýyY£tP…aJQçÝúÇkn¢aª‚
¥ÿF5 ¦èÔ`@`PŠæ ‚fÂµŒ5²x'éÌÉ•Â„®„8_B`0"1ŒT(M73æ™Ä=.Ð4†f š&n”&CÆ€¥¬77Œ+I‚ KÚŒà Ù‚ÀÁ`hë¹|ÖqÔƒÂ_¯£üð¶ÁPt
†C *54´7q‚2í-8à74œR6ÑB§ù3÷C•8S_€à<0'P’Û¥É˜#@°²dq4fb¨`“Bn9¢hIË~Ë‹-¯ †`y|ïÇ^ñàT¾F	   Fl
a€Ä!ÌÌQ¼ÏÒìÌ¥øÊ\Õ@î3…©Ü1ÿóäÄÿ{œ:	è ±vŽæ8µU/	Ú²¬wÙ’.Æ~e¿4L£28¢%'„hñäe82bðÌLV
D‹s#ãJ¥œµ3{”˜Eè­Gù.—§¢¼¼—!ƒ»q)b¼‹¼-c- “5Js!°äœÆÁ F&+˜*‹ ÁÐÄÐôˆB `8^"­Å°Ë;7êöW¹ªXÌ®ÍiÄCí'C‘3K»-}›AË	jP…Y®„€]ñfo$‰†#E	†àÙ„A0P"€æF 	Cè@¬dhcpÈ`¨fa &\ÃÃQ¶`ˆTa<`0ƒLAME3.100UUUUUUUUUUUUUUUUUUUUUUUUUU€°¦McdÄ+†1 6g c›'¶e0fâðd¦—’,k¤æd§Xa~KæJChjmF½@èa††	@À` f-¡Dc\æ èa.æ ÀÐb@&=¢¼b`+¦Þf6‡†7BD>F}ÆN†k­fºš € Æ!„ÈÑÔÂQ°a˜~ £SŒCH00daøha€`BÌ0BáY€ 9@:$,˜d@Ñe£h´’Ê¢Èò×$æÿóäÄÀdä:4¡Þè Ž3v€ÄÜ5ã¿­-aÙâú* C #À˜¡Á€€!@*šâ€Z15'Pâ®UUÌm¦¼Ühal©îƒ/¶«¶SÊÚ¿Z)k¸¶Ê–3j‹^ŒËq¹ZÔj×f]–³]ŒÆe6yrUKÙ«f´ª%«rv§ú]w»ŒÍ-îe¼«jÞée0í®óšæ34¶»üÆÍëÖyË4¶~äºzôÅkö÷w*”÷íT¤©SV·•T×÷ˆË%0ÌÍZkR©ª¼îUªgWuYlFS»jj—[¥Ç:j5LAME3.100UUUUUU  æc bÁra F3ð@d~†	à^` ÆG'VcV!f!ØaŠÆ„f´ô@«¶eôc!–dú€§ý&æÃ !tÁÑðÉE¬Ò´ØÍ2€È³TÕt<…g6Y½9Bk5ú	4²â1‹9šŒ3„4<w5&?18c5Ú2¢7Ð¸8dP48s81Ò8*05€3±2}	5­¡6<³0 K1„@0 0<90\0°@0ð81ŠáAf E¡o‰•!À˜EŠ:¿
vÚ4™˜ÑÅRÐ_ab€Œ5(&”
ù–)˜0‚M1B$J˜ÿóäÄðpô:<÷r´Óž2eoü2 O…+iÆA=ïó²ë»nÄ‚âói®[¯k“±÷~aß—CHn/0þEH&ÿÃÌâ@ûµø‹_‹¾ä×åÍaû†ÉK[‘ÃÄË¹eÿßF¹aî;ÆãÇ„å¸ñ†¸û0Çâ>ïÉäë–Ó Ønir=û¿aËÚCñ¿ð{¹¨Ê!–WµˆL-¯Ì·7öe’–ŸJxÜüû¿NüF)*W›—Æ¡ˆÅ<®¤®$×(³ÕJMC‹5æá¼ùRJá¸´ì7RmLAMH
A à`¾¦Ædm˜…f'@àLF`f(x¦`¦`¶F ö`cÆÈcŠ- €]1ÃgÉ1´h0Œ1P±1`2¼Hˆ&•¦jÞ¦æ!…Ár”Ûú´ÜBäÍàdÅ±øÖLXËÿLõëDÖ6pÎé ê£0×´¸ÏSÇ°øÆgèÛS€ÈSÉc(Í§°ØiäÂxÍq@Ó7”Þ“ÐÁ$ÅA<À‘ÅQpÁ¬\)•&eÝ‚kÐ‚8ÇŸ	tÍIºXäØL##,ˆÜ;h]Á¦pF Ý¯6FÌÐ2á„€_Vì%z¦Ó™ò€Ã*^ÿóäÄüsä:=D÷t´¢-º°˜‘dÀÐ¦ Àä!A††Œ	
„—"Š^ÅS4§†³gí˜¸ÕåVÿÇcqéUYcÔñÉv¦ibR+2ëq™Ù¨z¼¦ŠS-ÕªyL¦¬SOÌÆkSSC6_ÙNz·%½v#3gbCÊqÊ9‡f_Àòø¬Üü¿(z¥†1½/—K¯LÃ]~b¸ÃÐÅHË»~!ˆÄÔ4ÿ»­ükA^&æÓÖ‚§@U4GÕ*B(Ás§”ûæ\òDÿeí}@TÝh¤B,äpRJj¿ðÕ0& ó pD0>ó49;,sˆ0DóÐ13o/Ã`zj‚ H0x“ B ó`2¡beP0„£ph0QsPA‰©‘è¤%€q˜˜)Q¦ÀñxÈ("Ì GüÖT®gC°À\LCÉÄ¶ Á¤?ŒƒƒÍNL	‡ƒãL£<Ã7J#ãHs‹ó.S.
Ss#Óƒ²"|Ä`”ÂEpÄP,€F•ƒŽ`¡Œ8K^)™˜T Àr„fN
JP€ÓWU˜‘’õù€‰AÌŽœšd¢(NdÿóäÄÿw4:8 ÷w(äÊiNæÎÅLPm0È…@Ì¦P`fgC¥Æ OTÈ0Ð 3á =…0Fš$¦Î:ï_îÊÞXFHÀãŒŸÌ¾Q{²Ã’ÎÚí7)¬áÌuô¿Ëš½‡1Õßîëý»uµOMj¾­Û•F¥Ó¦¢ö!™c“¹L}Ô’È%lºNàÊáÇ>~gOì;+hÐÜª6ý¾³îS(µ*‡bKµ”³ÎX_uÜƒ¡åÐö@5^Ê`ï:ì[Ë¢ŠQØØwÙLýk­Õ\Ubê™ÎS”É•Ä
Êç¹LAME3.100UUUUUUUUUUUUUUUUUPB@/04£
Ó79‹#Ã1v0´ù9jÙ—L)Œ¥É–>Œ!M0ÕÏ(MŒ7%ŒÌ„9ÏXELqŒ ($ÎNã(JðH\qËÞu8ÆŸýŒ›¦KÆ0&@æ©à Í‚6	ó0‹1h0˜ÅFÍ hÁAÌ…(ÅBXËÌ…èâÉ<|˜XÒmŽ´˜I0±ã;¾ÉÊé…“œ1›»è ÕØŒL Ö ‚€¬ÒFz8 Í›¬hÉÕA¦F ÿóäÄÛk”:< ÷v<’$ÈDF`"CÁ!`ø€¶yÔM–´ÆŸ(ðÁ‹:cÀ€Bƒ$µ/ÈARÄ	5$®Gb`7&wÑá—rîdL™ÆkÑ—V•Mn¥6°¥»ü½_xc†ßocÍßÏV~­ûøÕ±—á«ùU³…ú¼­ž[ÝlqÞ_[*µ®MZž™¿)¥«;K#™˜»	³¡Š>³°Ì¶!Ë`öuýpa¹G\Fö•µÜXÙsf\²¸iN«¸ÃV»îü2V.¨#Ôé°íÕàGH%£Ù…·ìúLÜ"NÃ†ÈLAME3.100UUUUUUUUUUUUUUUUUU!€˜$ )‚¨’éìcx!ƒˆˆ ÐÃÙŒwÁtŒÂtšŒaÊÜÁ4À¼Áð9ÌQäÅØŒ€ô†fxbžd 
`d
†!c<k&XæÁÄSDs4N,Ó?02Ãc³Œ1“Ù c	LVr5‹0Æd‘!±‚ÃÆ="}>b`!ƒ$B ¡ôÌ!T+.)„ƒ¦z'!8ÀCÌÖ^1Ð1ã0ˆœÓÂÓ2— -™¦gñéƒÃ†­lñqŒ†"˜¤haÃ"D€0ˆðÇÿóäÄämô:4÷ácL`#00t9kðúiS¢0°e@*0p  G´Ž
B´qƒ„ˆYUcô‚“Ó«oÈ¢XF±/W!)%3B½E[+q
ÓÇß×Ö³]ÛxÜ&€©npWÊâ¯’Øà=Ü{@­¯­n-um#tJk4bà¹µÕ™i›Û$pVJ¢~Â­•­R–=¨Ò¦N”ê%Z Y‹ñÔ4‚DV“[³Y39áÆç@¯ Œ¼Ñš[D`.N§e¹2XIPÀ1`‡#I	%-ÃÉLAME3.100UUUUUUUUUUUUUUUUUUUUUUUUhÀLŒ@Ì	p•òµBÌS°±L`S€K)+0vL QŒL€Rž±=Ì‚ KQ‘¶1ÛÈù‚â€€I¤öì±Q‹b„q“ÌI¹qõ“	‘iñÈI’
IÚ9Àa@LRŒäL	ÌTJE(Œ A¡ÑƒBùœÉ‰Ai
b0~lI¢ãO240æÊnV'*kè†B.h'8Z
˜ùº³
™Òi€Z‘‘ƒZ³¶€„&˜ t€Ö`Ð:ÿóäÄÞl\:$ÿv”íVå’‰É3%(-¶¥Î0 Ö!0Ð¤~Aêém×šVîÃ²™=yŠi¨ËßGZÓq+¥tÃŸ=0Xvõ¹ÊÙZ±¯©c.VLÚ™©+µÃ½¬ï@NŒ©Ú†àÙk£91K,¯Lú¿ö%¶¥•#3Û‡­Þ³;È—ÞùNç!çö+!Â‡§©ã±­ØÏ9œ§®n[R­5Â†5vCZf’]K0ü5§êŽä¥µ€gFÄIS?Õ]ÖRÁb/ªh£ìÕQžxUC+hÕ>ß›±—&s8%ÓªLAME3.100˜L 3ŒðšL<q‘LÓõ½LlB7AIŒƒ@Ì±=LÇñ`_WŒ( Œ Œ2FL€° 'À€˜`_˜q!§8€n“ `# (```L€ž`W ú`5€v`€`²„oÃ£FæYW›w iBÙ…Žâ¤³5ž0M0ièÍã‚Í
Æ4HÈÈÂ Âä2—	Å3ˆŒ. N`0PtB>Mz0H(!(äla°A0Ä$a¡‚@`a!‘æRt dð $‰Ä „SMX¯>[*jÏ ETÔ%¥jÏ›tMÐ(ÿóäÄör|:_à 1 @‚€¦–pÀà£	€ à4º§¬\]ÕäÜ]×†BÖ_çÙ‘N´ô$æç•Ô1Ê®Íè:àCô¯Ü©Â†!Oü¦iáyoÂ^§¾¥v î¿Š¬ç>øPRGËL¹—G1‰O³&÷:‘èn?“ÏÒ?o<®§¿DÓkØë	\¸%Ô‡®_·ÉTr†Q~‹	süáCöìP<u¼åRW¶XáFep+û33.m§¯Ö¬ðÓN;òØüB6ÿCÞ×eø.¹À2ÈiþrsvYkË551^žOB`HïÂ`Ì9O°ÕÔº¢\b"F›€ad
á…`– æà`>æà´`ÊÁ`
P’¼ÆB‡–Œü¸ÉN Æ<^`Áì,À Ì ¤ÊC‘Kø—æJaBÆD™L&c@áqAÀ"€EN”Eæ414Áb¡)¬“˜Øi†ˆ…ÇŒT(`< ÇXmÚWe
e!åð00õ˜É•‚0)€šP4~1/íí:žQw-Ü 	=$M@S™„Š™éŸµg¥L_É\ÅÀ(~sñGq’C
^dbfJ".0àó+˜Á(@™2Læÿß7ÿóäÄÿvÜ:,žØ Ý}"Á©»–‚t“Pw)jÍÒ½t˜YˆXydÂ†B£Eb@R¡`!¨+S¤&~¯eüËTÖ³×ì'6¥
ð8¼Kæ±JV¶ñ?(
1 “&1á“1ˆ ÁÂ"&–`¡‚P#='0qÐ`}ü«ó»§·_;ÔùçS;ÂÃÈ±€ ˆP$Éˆ\ÖAŒhph@Â ˜Ša©òÜ ÀÁBm¹ ‚‡a0Ù *±LäÇ¢Œˆ<ÐÇŠ‚LD<Q„ÁÉZ!*2!ó8,Zä
LAME3.100ªªªªªªªªªªªªªª(°‘€ñÊ!x âÁ‰@‚P4¾d³ïý
:3´ÜaûLY”ÏûÈÖU…€€@*Ý+3%¦˜JT,h„Ø3ÂÂ@d@¦Jô”ÚŠ&;vT¡‰Ž67DŒc@¤tXra×0 0á‘åµMeÎRc²aaÂ¤1–"å‚’† èº¢¨ª*y–²®ðiaÑLX,*	!bï˜D,RøŒ2ºpÒ\­ˆ.¢Ëdî¶f)…„KBê!(** |Ø %²ÁÚúP¡5¯ðÀÝ¤£W ¡ÿóäÄßlœ:<¡ÙÈ åw¥Y}Z‘zÕ¸ºH<^1’º+pMF€Å	Š¬!5Ñ|X¡àÖªB0 Bˆ ÂÕ¹ÕR¥ôÃBç žáPÁÃ¿Š”²ÅËL0¸¨ø@
-AsÑ>—%A€–µÿ
®ÍFB‹4kàÇÍÄ)š‚,q	Æ	&a@‘iˆ^œ	fX(Ëé¸ˆÄ“Y¨áRÂµ²Ç5Ð01(dPÃœc©PÃ@y+ò4Í ‡F€UH¨ê@,Ã03- BÏ2€Vƒ(2¡õLAME3.100UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU-•8x
[’Pd&·ê ¨Æ¯Ðõ¢†9
ŸT>Kæ¦ÅRM	ìYS1S¡<®“LÌÒ²0…Q\ìUn´eòœ*é¬ ¹jë§2µ6B¢Þ2ô&ã¾Úµá I† %èi(®˜—ÑV(*ß@rÒF_˜ã)@ÊÞâ-&€Å›Î­ëÜ'>˜lyL–ò5¡”M]=*žn›47ÕŸ0ç»ÍÚ
w•ä“%£t9J°×(ƒÆ½=ÿóäÄ·b´:J ÆqÐl½ÅÎRë«”¿Ä@±zK¹|b_ <iŠ¥éÄÃ\uV/	{é fïš{2Õ†Š(A÷¥®¡‹~Ü’~@¤ÕÂ›=íy4Kz
\E—-rƒ5ðp4*,ô§ÚPé\¹ëÁ´v ÇµÎ ¥ÎÚ÷¢€(0ðT äÌ4Á¤EÑ-.YQ"‚Ä#pÈ Ás€Tx(+´“Éà]æy­Î"Mî¦È¨[±Ü§™“hµb¦Ìf>3fì$Ô‰›ÐRâEõ‚[¬eLAME3.100UUUUUU`hÀ „B2ˆ<ž4ˆ2€KSâ£yÁ¤$4NÒÒhÌ@ÇTé$Tu°	¢a&”eóqLåM4‘2,ÔÃ-ˆ˜ã€£63U1¬Ši¸c¤ÀcˆTf¹}3ó!®ÁÐ/ãˆv!(8„6QÌg¦ÉR<@S]D’&J	_åz‹ÐñŠ	uK0‡îášÁ„˜D@fLÁÝEG`Å,
©SqT‰ê™#€™Tªw1S1¢C‰œ æí .…B3FH(¡‚“
™€ÀbM b§p\$°£¡VFC`ªÿóäÄðpÌ:5AYÈ ¡Ú	$ƒ„S˜!ƒ€KT24\€sÊÄ	6ÓÄ¡¾‚›Bƒ
[àÅ—ë7W«ìDiÃ%M]fœ[ÒÙ,	eYÓÌ½’€Ëæhªb ‰8ÀAÑ¡¥¦
Š¢‚œˆF6V*)¦€b„ †-JB­ØášsBEeÖb¦ª[½(01¤&…6Ì^mà t04ÂKa¦$M—dsI4‚HÑÀN%Dšƒ–EÜ•Z*že¸32…j T Ë B$¾a¤<±PJÐZÙxQEw*!…9ŒØÍ˜©‰"w9ñ•Áå˜]ƒy’ÙC˜¼™qš9˜pŽ™Šèh™(Œ™€È9c¤a›Y3AŒ¬™·’y¹˜º…ù£(3™3‚1Š¢„	Ø ê)„xd˜k„Y„H„ÉŒ‰Ç˜ÃƒHˆ
 ‚0ÄÐXÌ¨@@XˆÂ%T@&$€0<! F J e0P5 ‰ˆ!™‚8 ˜‚9‚(˜$á‚ €Ð05Â\Á¬ŒÁÀ°Œ ,Ád >CÀr0‘r :0 p	³ 0b€-ÿóäÄÿ}$:Džð@	 é  p\@
óÀœ
A< ÃAj`‚ P@§¿p-9Ëæ;Š¢ 7õƒ¨¹€€èÀìL  $d È€EÊ°_³ 
€‰0€±i†¿ÜLïÛ¯~Xt1Vê¢À—©ÖË™›cÍ»€Bt* 
bÓÝ·F~•Ñ«´Î!ËÒÈÄ†Ý‰_r—×€å±¹\;¦žš±M1S)D%žÆe.í,fvvõ6Ê«ïwwŸ0þScVj‡³X÷¿ªË,XÂÇË&éð¯nýHüŽ]¯¦Ï*<þÕnêµ<í-Ïù©ºLAME3.100ªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªª%c° 0£0&"o£FóàÌ2¤³ÐR‘¨{0)„ *˜9ù… š$‹X¯r	„ ‰hY0ˆŒHÈœ8ÁxDšÄ1Ÿ:Qf5v-‘<*˜8	§1£‹àÀp<¥àÐôÄ015›ˆ–›%°0èH
P  LÄQUy3“ASÊÓDÃ‚ÿóäÄ°`ãªLÞè³‚ xÖÆ €ÆŠæFF	 æ†$ +A$Œ,KŠ”Ã€90Ô`@`pÿ˜B˜³ò°À Á
UEõ «z’‹EŸ(¬jE×}Úok8…ÙSVfÀA V 3Ðh[—)ã[²¾dí:U™§¦û¤Ä™mÆòkñ¨‚Ü®ž—µ7Ìòå~sñýsXsùøó{ïó™ã»½ÿçwúÿçÿë?ßá†½×ÿ×þ¿?Ö·¯Ë,wÎãOÂª¹Y[,gÈÕÚLAME3.100ªªªÑÁ^…9RšIƒ@`1˜ y€P†é€h‚‚¼æh àa„€Î:6†µ%.bnÀ”0¹³ñh`.€¥xsh‚€°S˜) á‹‡y‚øs—8ÃäE¾¤Ã pÄÈJò‰šAFn˜Ô±‹¦L™€,¿ÑüÀÇ 0`2!&,>© ‘Â‰ªÆ˜,›Édƒf ™!ÀdOi±$Gu|q“ÃÅ$\Üb0¸\,¥SÀ&'@þZ 0$X$ ;˜ì„F
8e`ÙÜC3 C€ÿóäÄóq¼:@÷1Œ8P¢­éCG	úL„CJH£û&.Â+§ €"7† iŠjsB(\õ#9‹  b¢ª'-d9ÚVäöLè9™º)¯4èÀ\²ˆÌÌv&ïÓåƒ±…$¦š®¢ÎåjFV‘™¬5ÖÕ‹ÃlrSÅž7I]ÎÅàEÏ#pà(uä‡"­¼ªô0ÿÃô>”‘x”‚ž=RÔÜ=(ŒRÅ3‰Å¥*Ëñ›‡ëD0Èâ”íbÌ»ÉŒßWÃ­@+$¾ÊãŽŒyÙÝY;‘W¹…È%ðÃ—LAME3.100UUUUUUUUUUUUUUUUUUUÈð/‘  aZné`è–H,˜0˜.&Æ†e€Pqo4vh0¼0c@E5 ãp0 ¡`2˜C R0<3À2:ó `}0]£€É½Kèl`‘	•—5*ÂÀó,‚H€€ H´yÐÐááø.CE58Âà41ÀhÓÄ´ªHÃô«0phH.$Va¡¹ŽDæ*­˜±ˆ‚@ÐÈ$Ö
*ÒP„À  ã=O  ä á*¸Œ¢`°uD 1‘ˆ²¨ÿóäÄãm¼:Lï¸¨d,´g8d,Z84‘ +É~º‚¿˜g’%š¾ËºÓa•ð€¦E-EàªÊÐ°­»uRhèÅ µî–Ž´¹¸8öY”À˜‚îi¬å¯Wõ”Á.äeâªÌw5-X[´°3^ˆD ø¼95Nè=ò¸ià£—»Ñ
8¤·š¤b£Ý-‚çã—†Ô-p¢®Ìüj †ã°ûþì>Ñ÷Mü«¿”ñÚhr!/‡ÞGAHÝ9bTûÚ¡•ÒW–ÅêÙ‡¥‘È´õz§—ÀqIDªÂä‘ù”áOÃ·§¶LAME3.100ªªªªªªªªªªªªªªªªªªªªª‹Ü`â ”`‡¦>L#s  .0Oó10ò0d @ÀQ02s-€S00C0 a« ×˜ƒð˜GŒñ¦é,˜&°„0,¾:$5 71,d1Lw:[‘5<i0ŒƒFEãyy‹cÈ8ž1üø1S
€‚¢ÁŸ!($  ‡&“#ÄŒÆ;ˆ@a± Áñ‡ƒ€`*"Œ	O1”‚€Å1`Ä5àÅaœÂ`ÜÊB|Ê#<Ä!˜œì'IÉò
ìÃ˜"`;" @¦ˆÉ1¤A"ÿóäÄám:@÷tÔ@Œá`®)–6-,”†`J•* Ic6UZSì
ß6 ŸôÊÔgUé!S0>kÌ:*€7AX] àÀàmº-p8k\.ª™(ê¬™]ÌM›‹e«šú»5~­™r™MmÚµ_z¦åÞPç«RÚ*Iu©u¨âTÒÜkË+aœæë¸Æ%¸\–Fi2œ­n9Æ¶Û5&'ñ‡>˜—ÒI¬Q¿”³vf£‘:š›wò±R#.–r?=CA…=wãzÝä®5;vž96þ]‹óu©åuLAME3.100UUUUUUUUUUU"Ô
q‚Èo˜Æ²É×°o˜+„(˜›™Ÿà-˜{`”˜aÑ—¨5:q„È3˜¦Qª¹ªp1˜Xé›™¸AìÇÈÏÌ”4ÁDB˜ÂTCÄÀ¤L€ØF3æ|Fúaè$ L £‘°0=q`<0¡¸ƒ0Á“/3£q2%)žIœi…‚€
Í'Í€`a+Ì…´éÌô Ç“LÆ`ÙÏŒ`pÐGˆ&¼Ž+%+1ràRr]'B[—¥àL`¨ (I›5‘	ŽL§¡@P\˜ÿóäÄëo”:,öÙ>0l˜	U¤y3Û1„…0Yñ 0 €PÅÃ\ÂF ãAnYgÐÃ˜ÓiŸ’@béŒ€ €Á@‚rÊXÑƒ,Á¶
µ„Ék²/„T,F†ejÄè@­»^_˜›Á?ƒÞÌïV×‰ÊaÉØ/é%šU4Þ;\j™Ko}kU^|¾Ê™g#-¢x­Ñ>¡c}ëÎcq[ÇŒŸYâÌO=’Eç®“+Gc”L¡ÍÍÖ«Æ¿‚gèc™É-c'FD•PÝ˜-¦,ÌÕ0Ô“	±¹0Ô|SÕíí9ê?s4Ô 3
ã¥0èca1óÒˆ2I
U1dò1)s`ë0R„à†óôÂ}5pÚ­¡MôÛFi-N4“ŒÍÂ *\p6+ÀÌ¨ó)Dé:åìÛÂ³$Í@+2¹ðËãc†…€D 3Ãˆ†%€b¢ã)Ž"qcaŠ`á¤LQH`dÑ ÜÉ‚s
Ž#…‘ƒAÈ4Ÿ&tÁ Š\×fšË@Ÿa¬©a†BÂÙÝ(ØsÀAUjLâÑ±fÓ¨U á`y4Ô7ä1Í9NŽÿóäÄÿu$9ü ÷2¸~Ùá-Š SÀ2q7VPc¨=©	¨F8ðJc°{P’ai(aß DFœ\åD ˆå@ÍÅ†"”3§m!Z´ZfÜ—Su/êtÃ%@S¦[<Ö¡œÚì;.‚žjhM<Z=5.©^½µÞ¹b3¤Ÿ¤veKÊ»Ÿgji/õ©$œÒ?Ôñ‰l†j€aØ«)~²ìÆ&v<ï>’ê´ë<%í/‹Y& a€¯$Sgé|®¨}ù•LÆeQ§âm°ÉéX«éA¡µ1JR³‚õ>0­
Ap25Sà­0+S @%ã°*0Ns Ñ02 ÑX˜‚€	 q€P€Q ,‚0ð !ràH¡©
€¹BƒY\	
2â1£ã‘äD4D¼>DbàJ,ƒˆÇX aÑ‚¥Á€ /pàÒÿed .Êò"	'z]Œˆ—¦¥xÅ€’ù¥2Ú¨ b&µ3TeP†0MQ´ùWá@43dIÞ(¦ã" @QH TÌHÀÁ€‰ˆ‡Øh)`ÿóäÄýv´9Ì^Ø • '!DÆXpT5ÜG,¨#+~‡€‘ùž¥bíXª6¥-’d	’É[Öp÷2Df{HBEBZ£4gÅèD…¬#}n€•cWË¶, 7Ì][@`IP4úL†(AX" eq"tQñU–È¨
™¤›.j[%‡*‚(ûnOé}PÔp-RCÍ¬E£ŒU½^ò©$•4ƒëFÜ["Œ©²ÑXGMû-öHû Ÿ†ÕµXŒ%P2èwZMr¾ì¥.‘år,,¥þ€ÕÛlÇbÌ…b@¬U œ$†„B#–
oB sc>ÍY Èv&c „ž&¢"æ_ƒpk¹,0 S0O0Gs°ß0w3p˜~œv`Šf Z`†  :1ã #G¥H4Þ*ƒbT•Û—Ú– ˜˜€	€à —¨,™Z0A¿0…iˆhhÙËá€à8ˆøØ–¥Ó C0+£ Ð(8 @‡û—;ƒÏ-ëçb0™å¨N `C1P R·cýÖ¼±^
ÀºÒýk—9Ëæ\C°[0a³`06C ,€ *˜3€iƒH!ÿóäÄõ{Ô:$ð þ¿yÙüéõk¥œKˆüYÔ CK´²0   `   à20 ³
 0i³°?i Áƒ0„nÐÀ˜(Fw;ýßþî÷†~]†h× º€Š;ñ¨øWoù€Ð ‘‚àr™ Á@ƒ€ÐÀ˜ÌA´ÁÌL ÌÀ´Ì@<ÀøŒ@oûý½½åžxþýþ­óXËî°õ®¡‚0ÇRrž7?MÛ± ®Óæ"‰Ä`¢àP	1 €qeÆ€¤¨Æ` Æ€ ×Ëä£ G p P4Œ€!LU¨ ¨’T0$NS8¶+…ÝyeQúÊ„Ð 0WE1YË9†Ÿétjwæ½ME2ü5¥nH¥JÁÔÂ) «,¸-ë]BA47Q`¤ügRË®|RH£êé®H×N ÝÚÚŒ¦HÐà‚Ç¬iY"'a!ˆiû_Ì6	O ¢Á¡b§%ÔÚ6ÒV²ÄWðØ³Šû¨Úâah"C´K§˜˜A¢Ê	
P%8òAed(¨sæ&1¦kFe&C€ `ÂPËœ­¢ÉºÿóäÄØk¼:qÿÚÈ "D•@6…› 8ùµ‚"P9U®‚ÆÀIÌnmªºi#@0B©¯Á$óMÊ1Mo™²à²ã€ˆ\±‚ÓL.‚ bžQe/;	"=¬)C¾‚ 0¨HÇ8"ˆ„ù,Ø8p
)^ˆF0‹Q˜fž äÂ–]ßBRœ.Àj£Ã¨Š«¦X#X5U*   ÂAØa"`©ó	¦¸`âÇªº5–|úbŠEyz3’Ù(@ –&„bˆ Œ3˜¤lclº>LAME3.100ªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªÙ-ÅÂ@Td2C& À¬€eÆVFâ+,=–¢/‰¡I<ZUXT•!RèQ"M„Ð–^-C]uyÿóäÄ8BÜ:–XKÙÌN§åYúøéÅjŽTÑ eqa ©QZ#l!šÏ™°Ø—Ø ¨³È[Qç‹‰ÌsÓ|í`9JžL#ìa~-ƒàñÄŒšx½ùNo”BÄ3É¼ÂTÙ(ÒÆ-†ó1Ê£€à;t¡3I%q¢i”îx†2+ÐNdáe…éQ’\!©I¡v7Qô<?>²Òø  ¥å_ƒÃÒdÒÒÂœfJÎ²¤e‚á¨G`Éåã¸%‰jHÒXÖBrÜ•.£µR8™¢î¬´5LAME3.100UUUUß€@.cwµ#TÕ¥Û¸ÿZ«½R]—ÖµaškòÚ}RãK‡1•_¢‹MJäªÓR»‘¸—’˜ÓýrdNÌºâ™‹¾.C+iîsÿZ‡BÝqâµe!«Œ»¬À×8¿¢4ŠÅÀ£ÀV"JàÕÀ4PÆà çL²ÕA•‚sN@9tÌRF”7¥2cÒ$"Ã™ à9¨€€žehÆ$:e€¡€¦ÄRC0 ógt0±3 <t:5ˆà@ç™¹`fJ6ƒÌƒ¾ÂGªŒæ|¡•nžŒ›4E‘lˆi“ 5ÿóäÄòq|:Y€Îõà,<‰nÄ#Ñrá¡*®
b˜òÃ
ÃŽ0% ÌÂS(<1B.2JÌÀóH$½AÍL`SF @dÊ)0 ÂÊC´ÃšÁ%Pà Æ(©Œa‘‚€,á‘bÔ12ÁÁ Œ(C,a€F Æä 9
“<Œ” à#"fÌ¬`a0 r`ˆMšD&f˜`&+˜Ã 9“	`P˜­Aq!Å›Öê^&†Â¸
MÄG)T±1&®LAME3.100ªªªqšÈå.œÏÜµÛ9ÞúŸûåªÙažz»„f—cIZUÚ‘®Ü­‡âSï¬š8Ó™“&›b2g)¤°ÖiÚeLÙ”°WhP
¿—ÈÂ€YkrVÔ„0B°;'Z; ¹ˆ¡ITtÊŠÌ¬èÌÍ¼ 8ÂÌŒ`¬ËÌ]ËÌtÇ„CBã†ŠÀkgBé…BŒ¤À<b¥Æj,`Æælb£ÂðÊl˜P)…—ˆÊ„zTJ14Ä
4Ö£Y2†S„6@!2ã/1¤3‘  ¨¡1¥£ †´èi8ÈÌHÿóäÄóq¤:, Þó< Ç@Œ|0dhhrd¨¢ÓM,ÇŒ8”Hh+	OD7(	Å¨Bf‘¦ ¥A%
–4á²ðÑìXY¤+úe6@é0ÄŒØDÑ€jc	Syò&RÜÒ<°‚@2Ô5FKs ðR-u”­d¨k°p´Y°R«™É1Î0BX(€çŒ$MÁR™3ì-ÃãTä"j.
Ub¯‡²6Ì4kPw©£Èò^±þ‚XŠSâ‹V6 ¯’¥~ÝŠ£Òƒ*TÊV `%½„éi)ú1‰N³Lâ-0ÖÃÀ+0 † 9yLÀ`Àl@@.D` 2{pº€` 2g%Êu°È&$à²h	–E‚ÓH0)@ˆ C(ž°¬}º
€‚\Ö‡1¡1JO"êx˜0¨8„X˜† T0£ÜDth¢˜P©†ÀtÇÊe ™Ü B˜9Q£œx¡A3ñ‰™P9ž‚B$±´A’µèQ­N›‘Xè©‘ŒEˆæ|nc+É>„!æTncÁá ¦8f#fŒzX)3 ±B£‡`@ñ‡¡4X  
WÿóäÄÿwä9Ô^Ø   ã 	È± ŒŽ8†‹°øÐ [fpÈ‘=8)•ø°ÈˆT  )iL:ìý“,3¬†/<â Kz¥±ùÐ ¡*T¯K„^&”ù¨#„¹•ú:Š>¡ïKœ…J)0¥ê_æè^(u| B‘iiSiFR¥/Kê×„ 	(êÁ´ª®ÎË8³œãÕÙP±·q-!´õWŠ…íŸ hÐ8Pþe‰Î‘ð »ÛÅÉ"²ÎRÔÍy„Æ¼ä7Œ1t­ešòb°Ù˜ŠÓž0Ú1‡Ph"'4"‰b=­s4&Àø¤/¸`@\ÜÊÆê5È™Ž ÁÂcƒHˆ-€ÚDÛ‰†ø-2cÀQˆÆ&[ˆÊ‘ÔAÀð(ÀÍC=a4@09 È€ó€áúD˜L7T `™„LÆWW™1\c˜Aª™&Ý™ g£ƒÎ&—šÈ|T%½îÜÐðAW£àp`á"Ãyª¥4ŠÔãL¨]0¸ÒQ@u´ÅICVRŽE<9ƒiîGÄ¸·sdRÆ€ba ”ÇÓ… Â(àˆ"ÿóäÄò{ô: ã›à ™@ô*šle@AŒf`˜l.™hé±òi‹ÒøŠarŒÂÃÀx V8a)„CDCFŒæ"	€—!@Y‚Ë@Xd`jæT‡Œb	"^Ýü*rµ‰ªIid†h·m¹4”Ž—Q#ËÂªËm)¤¬ ÀŒ•h‚Å‡::“)2‘(\“©Í9a rAr1ÞdóÙ¼öeóüýêîô104Â  PÀxb˜h & AB J?”Õo±÷SÔ#Z† Š áÑ¶`˜hŒËËÐ]7áTyˆ0f¨ÈÈ 
P a(eÆ©Æ”n­%”‚V‚Ö!(*Xs	A€é‰±ˆAD °mJÁÀ!€zsM(xp,0,Q
Þ5˜m"Ù£ßLÕŒ&0, 0Ð9-BÀ Abo,|‘(ÁáV"…&/–p³#CóÌ(1 hÃ@ÑT·ÌH8h`‘Òz€3,!ãÁÂƒ)Ì "Á³…˜€ 1ÁFjO<gÂË¦I
LFF<Ã –  $Â€0àÿóäÄÕzô:nC™à !‰Æ˜4\$8Aá€Ù‡Âf ™à{Èæ&¼4`ÀÉˆH‚GcZp0è0HÓMZ§…xWh$a°‘`
b É09$` 	–A&¥ªk˜aQôTÁÀb`9† !t¹] 2‘­Äà«¯€îN;¤×ìPä €Æ¬ªàpV0ÔÐõH@"  x8T„E€E”0P	2ˆƒ“}šbü–<ï?-MØ{¯Ýwà×ªP7^_c	à«c€¨’|-÷i8Ô·ŽŒ¶¨š¼¹ž[vá†ç?#€°ÛHTÕ‘§RŒ€°ËÞÁZShØü®¼šŸHh`aY£c§9a˜9h1€ÊæóÌn.5#0ÚIA¥¡€†8JW’cÄ¤¸n])kì–×•¾é,ø8Z‡xiÂ€M
"¥" ÂA 	ƒ:n€Ñ'õ¢­`P!rü†0CX *a+À«#Â£I¦)ÕV°pa%·1AKŒhFÀ˜D&žVnŠ˜²Ti²‚qVó,´¬dÂ1BSÅg¶&e‡!*1ÿóäÄ¼fœd¡ÜÐL ñ!«ä¼-tÁ3g¨F.ìèÃ’3èI’5¦HÉ˜,!™YlSÐH0\hŒ£"0I³¡4Â~Á€L0T­Œ#Ò›BŸ0Å†ÑYlqaŸ$2Mh%[Kº¿bÂ f!ƒ ’Ut*<©™ÒrµNmÞUÌÛUŒÉTAQ5:byþgSwœ')Êu±ˆ»P5iuÚHµ,J‡B©p”¹-uÉ¦¶þØ_¥”ÕÉö~£SñWJ-‡³Æ…ÝÆ3¬¥2I]$ºÔj{
³4¶a—öŒÊi†å’Õ@4 äÁ”N6—ðÌD>Œ7Å,9MÜÉ8Çt<Ä$ÍmdÎx¦LpÄÅž©‚´
Æâ†Oƒ E‚ñ‡0d• „Ã˜LP¨3Ø(À€s4­Í~2i8ÊÃkÇ§cÕc‹QŒÔæ9ª Ó5C˜MMêh3ŒÖ‚“;…Ì°A1˜(Òió
Œž$1!tÇ‡C#L˜W1Ú\ÊÆ
Œ†)1@ØyÜgÄ‰·Žg¬$ir™‚†Ï›Ie£!—€S™6`ÐY ðFƒ0àÌÐ"ÑpÆKÓ#!@†AøÓº,3'Ì’3RxÿóäÄôt\:8÷4ØÌ;iÍùÓ
€ Lð_1ŠÔñŒ"™ab†HøÓ…QàApK ´uÖUKÆú²øZ¶DRÔ-}Vw{ Î>4‘¬i¦jY0’LNHy”Ëaœâ2ì›±Ù‰uHµû³´XÖÂ–––šzíœ3¹M•q¥±M[9]Ú“ÑÙliÙŒCÑfuÚž»•áG(é©fâÓ¯ünrzÆMhÍë>óI_ÖG·'vg_‡ù4!†œã¼Œ ;¯ƒÈ¥0Ê¶A±yK^n™5Õ"ÃŸ÷©Þ‚ŸØ£N7<ÿÀŠ@XƒÈÁ°	ÍúBpÃÐ"ÁÂŒ`°œ&r¤D`ºf’&„l'5¦‚†)#ýZ& †2ˆ†:;ç¦¦/‚F§m‹ÆPæÄ*y¸„a‰ @PH3ùã4¬G2¼¯3+d401PÞ4m®7æ¨1,H“JƒeÍ£„Ì€*LTHW†š †
%FJIƒ À iƒ†Ì“€S|h”ÀÁ‘éÀ`HÇFÓ:+Lz 0xèØêã°³Ì¼l28ØÍfUŒø2XÊê‚'À:J1± 2à$Î3?ŠE&*•e¤G
Œ(0ÿóäÄõs,:4÷xX Ö.aoL#0$F ÄÀøŠÐ¾,[b NäC ‚ñ  ©‚ I"D ¥/‚›å¨Û-8J5;£«KZQ„f–é¨íO_–ÌRUµ…j÷®rÆv.gÚ[Yû˜k·°Âíû]¥µH´šõº8ß¦kBgá»Î+ÿ1Ñ8î<æDÝ÷B#ÂòÅ™Üº™qŒ-ƒ—óåµ—v+#gô=Œ¥Õr[úœÏSNŸå3rPit=?ŽÂ§3Væ³U{ÚŽTÈØØ›hØ˜LAME3.100UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU ž­¥È #‡ÙžÓ™†éƒØfI¡P,˜`¸`669ƒðG˜Dƒ¨XdŒƒBpÅÀóÂÏc†&E@F7œz
j)±Q&|IØ9\:L;ÏÈå`BLP64ÉÐÈ- 4jc"lÙ2Íæ2†1Q@æ±jÂ 5@kE°/q“TÀŒ	á%©µQ5†/d•D!=c!f( 2ßC1ŒYƒW Û-4DÐdÍ!3 WBJ¡ÔÌ1f
ƒN9ÿóäÄÀdÔ:@÷4Œˆ—8Áˆ-­&#O#r`Yl}\¾ÌÉ1›jXó•nV×)Æ¶ÿÍ.µ_@àNê1$swØúš­­Å¸ï?ÙV©Ú[´UT‹ýˆåb,Ë©i‹Ê_I}¨
ÍŽÎ¿°åITª­Ì!ë‘({uèjj¤*K&™Þ›Íyâv©ÓE’ö:½`Ê¶ž–[w¨e¶®åÚÒš)uÉLª]©Tmù€¦c.Õ5CT·¡îËu^3‹A´õWuêm®ÒÞŒÐV•5¨%®Å(ÜV’¹štfÅ4Ìaþ•LAME3.100UUUUUUUUUUUUUUUUUUUUUUUUU0%Àà0A‚!0>G
3C-ª2¶Eè0jÁ[15Õ0§À–0,@0ÚG¿1ºÄT1d60„7*º7Ì]	á1ƒñá¨XP1”…1(0XK1Ô8'ä=d1D«18•N5@)0Ü	0$q4X*0C¡à¶c@pbHŒD?Sñ¿|L!§6Ñ`(04H81ÉÝÐ†ÌU¡ÔÎ @EPBÙi  M2ŒY¼Q%6Ipáê“*Æ#PPh€†™ @‰ ª„ÌØlQ\ÊÍÌàÁGŒÿóäÄÝl: ÿvtE‡Œ($žÌ=l¯Už` 5*Óûn#”Í]µuÛŽ—À°À)`Óx¼‰Œ®S2BÿÀÒÚå©ØÔÍ<‚U~S‚âq%m‹7%@ˆ«m¸)KŒÂó®†.CŠŠHnJ"˜¨ªé@3­v@ïÊî–Ð<ñ«ñ(v’SÄg*¸¶aú“8fÃÓZy­Æ£Ó•Oj’›žž‡íÉ®ÐÒÆj\ïeQ¬¥Ð|Ô«öaªo±KO3W¯+Ë#<±S²›×©ièãV±ÃÓxå±ªYNJLAMEªª0OÂ¯0ÌÄ¥0RBB>ÞÈU4Pƒ0©Cc1w®¦6UÊT1«Ã¤0ˆÆ­1æ ê0cC_0ß0RÃh0WÁ0‘Ar0+@ó0[@æ0 E
 †` 4LÀ+|Ð4 ”ƒ4“ AsDžóª ³Aƒ³Šsˆ3CSÆÃÁaÑ\Ã TÄ”Ê!Ü0h0<00|0´0&XÁ ‘V6c
ÂAá8B
‰ã ÕŸ¬p. >…ñq4ÝšR«'2êZÕ¢ ¬P¬i(`È(`0>`(
aÔM0ræ¿0¼ wuÜ‚imÿóäÄùsD9ô_è ·& òP5ÙÖe<ýO³÷‘ÀUH×L2V¤s_­Ûu`E³@P|Ž-_”4xn>Üdµ¦“ÔˆDìYBóBÅvú¸å@H°Îâ4õgXŒ«s²ÊÔÜýIê(L7¤›Ç)ê$»’ˆj[I$p¯Ü¥w`&ù÷r­Õ½oáPÔõ=ÈzÔ­”ÎÄçÞÉT†Ur£P41K;Ï´ËKk²G¡þ€e¬n¦u¶þYƒÞ,a.Ãäø»±–<Ó_›¾w!¦‰Î38Ó?”[4À 1jMeÆ/æWŠf€%†8†™
&f8a…ÙXl`˜F,• ÃÂrçŠ€DB4iB™"$ @kQ|Ü¢HàD{D `Êƒ)‚±µšÐHH`Lb 0 (Á"d«hBý,	©vVc‘©Ç&/˜¨8`à@( (`bAŒ„b )ãQGã~ã™<†c0Ø@<ÍÃ. 1hÔÇ@³–u3Ù,ÄgKÀ	Ú	dBõŽÆ¡À‚Ø0`à1o Ç"Ó€YÁ•ƒÆ‘„˜Š`ÁAƒÏ&‘@&&7µ’l§¿3ÏÿóäÄÿ{ä:Aà ês}¿¬9˜(bðÉÀ` ™†‚Fh`pYƒÀé&

´:j’	ŽÉF¢DÀ haÑÈáPÙ«†f=	D‡Ûþá†ÿÿÿßõH¹*ë^—o±fõ]¾ò=‘XtŒ3ÁhN2àLÇ"³R!Œ€$*žG1€ˆÊ‚#1‰Ì:1¨LÀáó’ÿ÷ÜÿšßŸ†óÃZÃ?•¦˜³×ºøW–ZB–$[¼š€ "K¥Ú)ªvž³'áÀqLÂÀc	ÀÊ0`ÄÍ#S‹Í@^ˆÌ^10ðÆAc‹Ìø:3À28\À"µäaòÙ•HåeÚLAME3.100ªªªªªªªªªªªªªªªªªªªªªªªªªªªªª‰[Ž7t ×¡çú]*dŒK]˜võîs1™l¶–÷ö¼·—«J©§á«2	ŒÐýZ™Óv¶èyËš§Æ¯);$¤Ë*ÚÊv il;´˜¥›e±–Zš(¢©TÄ»­ëÂµ¡É–‘J‘Ùº–¨F%É\–ft°åºdÁ¡!F@Æ“X»¡—ƒž‚GÅ˜†bLLd“l€œ@+zBÌNY£,ÅÔü›¡æ$Ê‰@§DÂw”D¦!dŠÿóäÄ¼cÜ:iÙÐ ˜%Œ1çCˆÉ+òÌG)TÃ†Ç!*8fÅD„@(4ðhùp‚ÂÁHÇ¶„w2ÅO˜rÆ$*V P 0PÂ`¦x`9š¥LÄmDÌ”x!ƒ ´Ä…¹m‚F$FTD	aF¶â2ƒ@Rþ""â¾(äŒ¬!P¢Zˆ+¶J,¼Ot+lÐ1QUUõö,e@‹ÂH†õ¤•,@„DÁÀÓ5‰®Ÿ]%µK$.jÔi»1·•£rŒ­œ_HÚ•êújõLAME3.100UUUUUUUU! á&eà¹¼;å*	Q(¨>NF…‡/?´Uœy'›L[]˜	µ´º‰•\È²ÂÃ:«T+ŽJËD>Í3Z¶ÈC#D‰Ä!Ék+díí#ÒØÙ’-#Ã-@Q‚£`\   Ð¤P9TÃ˜cÂ„A!ƒÂ Ô0„# 3bCD…™‚Ð8Íü|æÀETÂÌz0ÊÉHÑ‹Àª&f¬h‹Æð|h!fffJ@‘ñUóV23B41À3k4rA@4üÎ ÁbBæL:b,Ã #£† da£ C)1âÿóäÄîp„:]@~ñ°àÅ5 $L‰†€$$ÈÄZ	“‚™`¸¨ÙÁ††€‚„ÔÉÃÀ!D“0q£'-£a‡‡†˜ˆ`Tx¿æ6F‚‚¦f2L110òá`ƒó		
H×PÀZa`'t *Ù Xg™ˆ ¨Ñ0ç¤Àà@l—y¢ÅYE[Ì+8bÛ«"&6f¶œ†Pšˆ‘ÂEaqME7PÐ¡Ñ$r†ŽRæ0"Bò<„P‘ZÈ9$JQfpËŽ ˜¾åÁceFÇrºtÉ5¶EÉ;f¬©…(t¥d¢ËÖ`:#>j5KœRWj2×ßø]#îëÐ#bx®Å8/Š­Æú8“j‚®ñ¶î
ïg’Æ¿J÷Ë!Q÷f$¥-9KÓîLÇš|Ö¢,¦Jý³Vu°&G©nA“
(JP,­‹,ÈŸ1‚–a˜áf0YwAF¦B``ÀÆRx	˜"¡‰;˜ˆ‡$3Ù¦Ýê…:˜
Á…ù¹Í^š²àb1±5›a¹ÚÁq)“¤Ñ¥,q©®ÃG6ópY8‰ÐŠàs5¸ 3é…–J!œyÜñ¥L!ÿóäÄÿw|:T ÖõÄRt«™q&É9ž*DoÕ6FÄðÑcèÍDŽæ0YŒ2kšæ'J‰“$gÈ4Á©Zr©JLË#0, Ï_;M´€¬XÒ4³±±Ñ	^»øÈaÐæ˜F*|Ý0!Õs—¤½©Êb¹"€LPp XÅ¢ „S&„ª¦yŽ`€“ d e+
ê»BQ»…îbÙŒ–öZä£²—)´¿ÅÂ,Ò%ô-ÚÊ	NÄN‚î2òÒª¤L
À”}Ä}Øh:ãc	ÔÌ›d%éCÐJ€.	A@0#³Qƒ3(ƒQT0ˆ%ÃYbj35Ã11ç2S¦01j3S1 ‡36ËC[4¬ôÉŒL|Ì@PúkiæŠ.+0jÃ¾Þ;ã×—>nC…=2÷c8%c 
2TÀs-™H¹1¢Ø„\‰}T‹°2ƒ	’L–8âˆÊÔLh°<ØD®V]#ÉàX<uW©XTXqgØc#È€ T˜XQC h@XÎ1àÌ±ðqa¦¦£\0ƒ@ÄÔ¤(Ë’*Hï˜F¦8Q»ÿóäÄôtt:8 öô¸h¡›aŒnÚR¦°Ø])Ñ†> ×®!`-ÈÝE0É˜# ].àˆáÁàêy@–3‡[¤²éGZìª~3F^v†‰ÃŒ:„;4’(f[A¨+vcü;)nNºõP&b¶X#œ×a¨Ì·¸c*Î	”F©+ÐGŸWê¼…ækªMv?prÆàfaá„3ö¾ºØšè zaÓx“âe‘–_¨$†&ÈÖ<Ž‘Gƒ“P6&ÊH
dëz]7Yýfðcõ)Ý§Ö<îC2Å)+GŸÚGêŽLAM040Yƒ¥€0Úóàp0ªr£0ÀÙ1]ƒcÆ7Œj3=ÁÍ0þÃÒ4Â s9M;-¨ÐÄ³+$ÁN79èÇ¤£8:äåh0Jgxù†¦° *qi—çk¢sZG&`…à2“a"0Â»QžškÉ‹ JHÄCŒ­lÒ
ÌDDIÓÐH8tdfqk6££‡„
ˆè‘‹V¡ˆƒ‰€ËF
Tb &2*ÍV1tÔ°,F‹†2J~âi'FD"c%&heÂ!áa	@°X‘$ÿóäÄòq„:, ÷6ŒF (Ù”†X2G˜Pj/²öL]Øa°ý¨„¾žöÙûôôZ™£¢™žŒKâq)TµØÍásè¡ª>)RÓgMÝï<Êå\óß0þþ÷z“tòžg'âðº±ˆûO5Æ“Hø¶Vì¡ÌI¯¶­qîƒC~»•¹Ž „º³ë­H½KÆ.ËAeààÌ¬D ³ÙJl²Àpe/Â×@ÀPg¥aÌTx¹ xŒˆd H
@„”ù ×á…2'õÉpeOÔ­à]1ÝR:X²ºC‡âÑ'RLAME3.100ªªªªªªªªªªªªª0) u0»(£Ø6ý1Mc`]5;.3Q€¤1÷jš4m0 0³(ƒŠ&¹1æS4AcW%sBÃ³	Bž£A‹óÃAT`q£hÀãÀËßŒÎÐäÅ`ÝØ¸Äñ\À@hÂÐ$DÃ`¤
<Kj˜64–€ƒãÀÃG±!@Á0TÁ XÉÐ@ÃÄ X3Ü‚&†€„‹AÀ‚# 
x è…q»(Lp ë]aÉÒ6P¦A¡¸Å@Jä	“@ÒäIMQE,B€.hŠ:‚NÿóäÄéoD:  ÷t˜5LrµÅf¯%EŽ2CAÅ@ Q1šÈŒ p,Ú)míª·)k_ÞRŸ˜‘ÓWŠQê	¥Š?ÔÔo(.z5C_ã˜vý>õVåív®_V¥ªÖmØ™»bÎ9µñ~;.iT«µtÆ°¶ó9,ÇW³-kmž/vã²FTø½ÉÖ˜Œ™sµt°b.ú18sŒ	SÎÑ[DÆH–‚‚ÎÕ§ÝLXí
<²Gu§Jâž]?}<úhju/tÐVfB¹VÊfÏ£t¦m]x&Ó¸Îå®âaßLAME3.100ªªªªªªª0|3Ëá³°]ô2µó'ø=ˆá³Z¡51á £Í6G?ÃRW®#{t$2¿£‹ƒ#únÃaÌÓLƒÄÜãfDók_sa8#òÞƒ>Gó©«£ìåc3”'•C&E€(ÔbÈúb™4t³†N6g†¦$($`"¢ìl,Âs#1ò³,*“ÎVhè¦ÎÀãÝŒŽ4Í‰@¦
<8€œ0,ÄDT( Œa ‚ %r ìa…=ÉØ` if.¦c¦F


$0² …eH#
¥Ó@£šoÔXºNÄ5ÿóäÄïp¼: ÷vŒhÐÓŒÔ—÷‰;i†×äIÈ­“‰Î_5`T’×ÓwärGóQF‘&Ž»mm™²—YwÃî³ø¸"Š^îäV/ŠÁö¥qHTaœ0ÇcqyN‡%ñyø*[w'êÚÊ‚šÊ7D b%ÃÔtMšó‚à/&– NÔ™s ´©<XS6R`µÊþ‚¢­xºøDæ\š«VK%½YU_×}¬´ØË³ ¼îl²^ªm%Áv!ÅÔ±+cRµ3ˆ+_`-•	¬5×FÒÒ»ŒésMFÚLÒ7Gê3AƒP	˜ „ñƒõGœ1™ˆÐ&˜•®Á³H5w‚à n	@œÂ@€’cÄæ Ü`F~¸e f(¶u-†R
bg1NlÂæ$|Ú&Œg$†0¢iƒÀ3, 0ÒÒÌh–ØF‘e´7—\°9¾òÁµ6ÂCÎe©Œ%Kªh0LZ0ÊÁ‚ÏÂÂˆ  LKð×1¸±ŸI™b2Êb	P™ªnº\.)ª¹iÔ	tÈ3„-z±©¼òúƒ)Ò¡v§@\2ß…A€Á©” *	ÌC1GÛŒK1! Ü ÈPÊÎ€Ã‘i3BS¡&òC!ÿóäÄÿu\:öòŒ—Ì½ï‚ÁÄ0ˆ…ƒˆ CœÂ,)¡Œ 9ÀD˜Ñ*ÆÐÒý$•ãR.Ú¼|ö¥…ÏV6¶ÿJWÃ9]Œ±Ôã’7Mç†ŸjŠPÉ¢Òí9Ó »A±™`¢xðÈ:…Å$‚ø1ÊìâD%_! @CÒõLabH@R$'¸45CàQ‹˜¡ @`©Ó¤¾aAÄ N¤Œƒ€MÂü«r”§š˜#Ê^A€@N­Ö †ª,¬
å8mÈµe¼LJ9¾è4*Ü¡*LAME3.100ªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªª 1DâßÆÙ’=çÉú«Q„—úh³Zä4BÀ`8ÐX\,ÃÁXròLu^×uz¼n{Œ¾Ùy øC:Â("ÛIåcaèÎí"Ü¶žïÌ¶F©äj/«¸Ï×+Sw–8¨T!{P\OâŽÅLÛŠÐiò¹´ËLš‘å‡b,-ùy¡‡\©‹ô„”Âˆª«”.MBÁ×i ƒ> ³  £ ædÿóäÄª_l:V>ÞŸ<˜@&TáTPÃpâÆ(¨sƒÞŸ4€p“ŽˆÄ–6‡MyE0Ñå\D!j=Â†¨J~-.q,…kaÃ«ÓVu*ó_AP°‚ÑÔ—x 
Ä\Ë¾-òr@¨4·¡	—gSëµ*™›[øs“©0y¤™•Gr¹K0kQrv*#ãvÎº]J†ç£B Îà–Y7[®N‰ì‹éÒr\^¬æUi¢x§^½\5·Z‡u:UÊr2É3	¼^¤©eêóLAME3.100UUUUUUUUUUÃ°Œ1¾#î#ö1#qÎ6¬c£7ðÂ0¤3C¶8 /cI0’=3ó&0Â‰<¬N…Bf#™@xâK¦bH
L4 „Œ&/Uo¡V…„fÈù‹…¦Û)˜ qáé„Dæ4œ­˜˜a‡5“^ÃP²) ”•XhèÆÄÃÀ¦P6aÄffeãF.ö['lˆŒ÷m,ÄÛM\ü.:,7 ˜ˆ4@ˆéŠ9˜TF4B@4(c¡!c4'3‘@°¨!1Â‚€‚€¢…À®÷ÿóäÄìp: ÷6@q‹Ì•U%Pl4„h´”‘”Å`¦.ã+ƒ0°W|$-8ÐSV4¦qÐ]I#²
17•×uØ³ZlPæ}å|µ,ŒK°“Jie?JÿÄc´Ð¸¬=µ.håµi»E Æ¼.r®ÓrLþ_Ôä®TðT‡žy#•<³PãLn+glHj „CÎ¼ôŠ!4Ì$œkR˜}î}!ÆQ?1ÞOE`GÙï‘µç	äšLŸ°@å)“TËæ]²W	­Æa†¶ã<u^hýø> LAa€8m…ù†Ã»]°	‹{Š™ËI® …ˆ‰E˜<,I¥!	˜†!„â™²‰‡ð ›‘Ëµ¨AT4ÑÍ¸œp8Ä”M™<˜”ÄµpÅÌd¸(:n®f>Æóc³f z! &>LYã	fJH4U2R€Âç¤T8ÈEŒ<(XÃƒÑ 1 PqzŒ±\×Ç–LôÛ†GŒEÃˆL,€µàKj§–ã ˆÃ”öÜ™c"wVJ\³¨$„#e£L`´¦ó$ÖŒ”€6B€¢ËÙv¿²‹PÒ)²î™‹=Okñ×Ål–ä
®KÓ”,TLÍ
ZJÿóäÄýt4:öòž6Ë„cƒ3 H1žb‚†qÅ…Ià(QsA‚„šÂ2Jƒå ” öéÅXaáHHeŒdt¢‚ˆBQwí”–}-ÂÌ"Hª¨D¡©L èÂ2‘ @êlÌ"2ö'°hê™D&AaCAOD'ÐÓ@cÊ\ (ÒÄDÄÔV®Õó4hÎ‚—½S;ÜÎ©#ù@"Q*S8¶Z‘·ª0ÏZM¹Q†ÊÚÊ€Ãð‘É]±~FëÜm,>ËLñ²ù#Üø@0ˆì}L0}£€Ÿ2¡c«°'1Ã¥3Ï9£ð1dsWQY1åÓ	¡\1D)£àÑ0³³aB Äà21xÊ¥0ˆdÁ¡“„LˆŽ6‚ ÊÀ’hcÀä3»n6!Ðêú:ìÌˆ# ÄŠ0àBA¦|™1qB´ ÎÜôgZO«]pæ«‹ø,!A…œQæ(0T8)ˆ aÜœ·cÊŒÑ…š °õ|ÙBÄ”«ˆë†Šëù(]’ý¤AÅß€‘æ½Ø<rOj³öàQ?
–5DhB$ÇO`à e`Pæ(hó³ e²]S*ìjº ‚E†ÿóäÄþtt: ÷4Œ[ÈÜ Ž¬m\#ZH3–¤—ÊÈ éZ˜(<ÝRÕ>Ó !œ—ˆ´,'Â»B2ƒ` ‰à\1” —è,%’é…
D…Y‚,, 8àZi¥¸B
XbÇ›q¥L˜>Ñ†EX™„Î e˜ À`ÉÐbÀ©k|©Á&¢¨ÞvÙÜ¼‚Ð+¬¼[ÕAeÐ`Ë¾xÚê«F•zfÞ6°È!ïp!ç–	Œ2æ±6˜­1Ð/ë/Xt
ab•®GÕw®ys Î!È0-Ã@Y0Í+CÁñé0™ ³h:Š“€t05ók¥)1;C ~3§“2°j0¬CB€  4¶àÖ ó ŒNÇ4 pÄ`ÓI¼O2ØÀ‰cÔEL‡.ñžnjá)—ÂFuw‰`€`Tü§I&)Âã£ J (XÄ@q€qL.G‘ „  Z®0°rLR0`1À¸90˜`ÇŠc‡Ì„0±\Ë¡À LÁ 4â0À 4)£@O7=ÔiEý5eKÀš°–l†qdÏ5Á¬J¾ˆ¡M%{—\F·~‚EjÍ)},ÿóäÄÿxŒ: ÷2¼£0„ MP)féÖKy#¦ØfJÀb€‡ˆ×2O9!$ËÙœD0 ` ƒ-X@` Ûà,¤&¢6m°ºsC$ £ä’‰ÿ-˜ÀXq ‚•¾Dõó0uhd,‘$‘¨·e­‡çEŒ^"é7…ýp¥ÌEïušr¹ªÅWëÜ‹/š<%Ò OxqN^DÍæŸ—É¦ÊVhæ²g=ûX">,‡nX]M~VÇ`FwÙXGùÚJ¶cU¥¶6~ï)ƒÜ×S¤Kri‰Äñ²´hU,Qf'Ó\/Yo!²î*LAME3.100ªªªªªªª –æ@\bÞyçM£Èa>fH¸c®g& 8a4)çà¤aZ)f&cÛE `lgäš0 dÐqØÝà¨ÉšÎ¦=­‰M\Þ6Õ¨'1`Ûsƒ@B“2ÆŽ&j–ûS ((8‘Ô12…‹[&@œÃ–UõA‚Œ³’â£Ö"¢B]V1á“©°˜à¨vj¦ \ bÓ;Fd1™|g§™Â`Pq`Ï"38­¹vzÔ
ô_Ê\„@¢¥¹4i€N ®††›–á“B
¦ND~^íÁÚÐ9öÿóäÄßlœ: ÷4ŒaµF¶).<èdäoPAŒH	©*0¤Ò`„°	R•C¨â*Ü[V²ù®e_³2åvrDÔ¶:û3(ðfHlOúj¶°B3F~£}fµ©çbP5«p+) 5Ðø+§’u iSUhs0<8®žÙUœô¸Ž”ã·m§³‡yÆx_É·b3,x”%îŽ·ÎYùqd²¥=Ì¹¸¿E;LýIª;±ˆúÃ^u¡™!ö~—t&Û½J+Y¡fM«qhÌ™ÂnìÖi•LAME3.100UUUUUK˜ éØ˜L\9ñè‡C™’ôñ+±…ø6™-¦QÍ¸äc1†Œd&Ù0dW
ù”èŽ™ ËÈ`¡¡é§ù_±¤~z1Ðœf@ˆTÆÔD˜¨@dÐÀ4xcñ!ˆHaÁ„Cæ/	l4Œæ	…#ÁÒ (…©KÙKNUPVº’{˜’[•mÊl-vl‰¤,-I‚‚ aIƒÂÆ-(„
Œj:1P8ªÃ°ëÊÄQ™K˜<ªCM!³+Ö3­>)k4ÇÖ2¬Ô%!ÉBiHÿóäÄñq:4÷2¼ê Ó_F(;¦Ò^8q=‘:}UEJdªðBÂ©šKüœK(’A-êX€bˆ/–®	zi‡ºîõ”/*g
.îÂæÐ›*«8Í…Éˆå1¦vYmíiÚoœ•òÎœf¸ÌU+9ê•O=pÃ”Üø›ÍÝHfÎÄRõ(2æ¦UeÜË vêì´ìIš´v"Ë—’k4V"À^ç%µSX“ò ÊÀñ_¸’51~ÛÕ“]m§ßŠ‚y£ïJÒ`Ð3úÄ^™3é¯·/]|¦Î´ ª	ÌÁ6LÁð9|Ü«ÄÀþ ÁAb8Öc\ÁtÁ©,”×Ÿ„ÁùhÄð!,y8Ã”“”6ƒ“ü“,"“4	ãpÃÔƒ4ÿÙLž*?¢ØÍçs	¶Oh¬1HüÀESÈÆPU‘ƒ™1QÁ '‚âÀ1 -/_ó
ˆ¬@t'
€˜ %¦â†²O5„¥qWêú§tÁ  ƒF„"2qÉ”…OØˆ$Â  €Ð°¹Ž„“,”{D²Ú˜ð“
šb¹¡‰=š)Ïš„¦*††:¹F„ØB¤nˆ ÿóäÄÿ{49ø*ÿ6Ä‚[ Øo—>,_·$˜=
F‚y€ˆ$H@@èôƒ¦3“ : (2XÈÓù“‡˜Ip“á‰ˆ‚I‹Í„`B€B4‚aÆDHaáeèdôî¶»ÈøÐf¾ä<®Þ3´’¥9z!K¦Xÿ»®ÛÆê¾ýv¶Çulnk}=–E,Áò`ò
š‚à9LJ¢¢‘¸QåÇ•±w¯8ù[Ô\‡…µp\7±|%cÊÑÑü»ê`5”ËfìÝm+• Î¡ù…0÷«Ê®*7°ÀÔçN·‚WKšÜ4òKV!H0˜w±‰ò˜kƒ ÃvçÃˆ&jèu2Ó†_cÒe¼ÐÇ	H¦e^BX3A`z0©“³†¤-6Tð2XasÁœ ÆÊÍ‘uL–é5Ü•£%¤N Ð1q¸ËÁó|ÎOG7‹LèŽƒ\(|-3úd›1)ˆc³)“Äf˜HL<0h|ÆA&è`ÀÂ`˜T"¾Ì:-1lÃâ0Pü4c ñNf@™äBp«Æ²UQ:lZ¬T}d`ÂH`_	„÷,»'-úM„$ørâÊgQÿóäÄåz$: ÷4¸ß(a•˜ø™ÁÖ°c6¦9pXX0s
"
…nÚ³²õÂÌÌû0FíN†<[†¸Ç‡ß…À©rí, "h:\Â$ VaãNêhB€HKH q!Ñ HF¾Â&^2ó¦#q~Ù£+’¸PË„íÈ"¤^®SzÊW©~äô®ì73"‘ÉnÉpÊn9ßŒ|Š-”³¸iÄgé×ânó,x‹¨_Lw^‚ç«¥OuÃI4‹„ !`C‚…º¨ÞL-@‘Aˆ† ¥Pæ4˜$ BˆqúAÂÜ „  m9ÒÐQ
Æ„²ä 9ƒèÏ]˜8¤3eîYjÞ|^Š@	Á„Ã ªNPÁÀ 5€Ô¼3„A a˜ÆŠá’(Éê2K ðš1A³À!XÈÉ€ƒc €£Å`ÂB!@aX˜LkŒ€@`È²ˆT*1ZZÌLX*L²ULLjLCLôT¿KL81N+mÍ	LrKŒÿ%L_L"L_	Ë.bP[ó#Ã@ò°(ÁàÔ0gT
‡ £	cŠ£Á³‡ãZŠC	‘ÆfØ¼Œ%ÐÿóäÄÏ}¤:$ ÷t¼€”Ð!€ààzÈB"cH¬ˆÖ>$½‘lÃ1â„Õ@AG!(è± Ñ†lˆ1Œ„ö³*ªe¬ëKŸfõé‚àÙ)C6….…šŠèšºÆD„ À¡¡«áÎB`X( :x¦ò-"³„Ô˜Œ6Óãl^*€)%rZi<ý%\(¤U_˜ÜNU'ŠÒá/¤ ˜ƒ(*LË«>•r¡&¡‹­Í‡Ãí%óWÝ’¡’˜ª‚ÇLðàI¢Ê’üh3-Q‚Žà`J: a>9bÀRþ«jª"2+?iJ!€"`A4q	¢ f XÄ

ÎÃ€7"«æ²X¦@€ËM°ÁF©tâ‘ /CZ	ìè7
AlLÀÁÐ=@À(ØÐÑ€Á€HÃvî0Åxà^(åÂ8Ã°$Ä„D,6¿ Æ¢È ÂÚ‘wÌ(…&åÆ *î…Øëž`ÁðDˆrâ1ƒ± Q ³6	DÍæèÏ	C“ÌSxä
ŽÖÔçHLøÙ‰HÁÅŒ”tÓÃL4°Ó¢›©€‡›L˜añŽ§ ƒ€Ï†6a¤jMš¥[’ÓZ{cÿóäÄ«bL:<÷v(gÍ‚c|`-™ßEQÀˆŠ:G„EcAÁ‚À •âœ…ƒ¨;äµ"³ùCùË)° »=nŸ8³ù¦g#ˆ1FÖ+ïUåe¯ý¸þoã5w&àª:HI,©§¦½ÍKkÌÒwÿVùV­Û—®[³ÛôÝÕÝòÞtÚJû¾òJãW Zò1å:Ü¤Ñ¦Fþ×o\§ÑÆ×ô:“ÍâŽªúéÝs’¸Žºý€a¤õ~`§ðOfü°$/UHò ‰,—ñÀ‰ØcJ¦ÿ³gu*]2k·Ù=XºÞAµ·}¨ÍÕšd˜<!ÁºØa‚kziÑ‚P<¤‘é¤èCÙ†Â•š5™è˜Ù¬Á%Ô0J(=vŒ ]Û‘€CC&X"%zÆ
‚oà„@ë,!ˆAKy¡€B ñh”4a ‰˜aÅ‰ŽÛ¦.#ŽŒÐ8ZÄ¦cÎŸÄ%Ì7(3@ÀÀ%C—œLŠ-48ìü“-ŒŒz6‚œÅ@£Mƒ#0!ÈbH 2þ€D„…>IŽjq2æ¸‘J…íù„ 8`Õ–G°)30„P¸SXx@ 0@¦Í77Y_¶g)öÉãÿóäÄôqÜ:, ÷4œº‡j.†nË [i£Ä@SõTÒÅ¯%{ W0ZQ¬çÉ0£SÜ	mfégjC²Š²›¶&.ÐaKoVw•‰LÄ/	¦–Ãñ‰[q‘ÓÉékãmâ«aÝ6Ï«ÆŒŠÜÚ©²<²Bÿ·Vºé±Ëê:°ªL„(2ßHÒû*rÌ#’Õ
€
‹	
ÁÑ^L¦È¸[rëÂŒH@bÚŠ€S± „ „#‹3Bþ—Œx"—Ž†Ú?°ÚÌjÖË TqÌg€ p„$6—å¸Orù&œ}-Ô¹JLAME3.100ªªªªªª€  ¨ ` *0œVãsp)0	Ç’2¶£  [2•q37PÈ0rÓã1ìp02é«Á¨\µ%^Âh(Ý‚aÑÐP@9ü‰ƒR‚A#ŠØEC$Ã%ˆ(0ñ P\Ä#s$L*-0ÊDÓ”@^~³!†‹&¸ŒœœHe Œƒf¶-˜¬"bey“ÆmÀg¡±ŠA!1 œ@`J
šµÂBÊK—iJ^.Ë½lwŸU-‘@,òøÈE–Éç2Â`((¸I ž@É¤Á&Qí>Ì˜’™.š'A‡9L©©.ÿóäÄðq:,6÷2œØË¤ß¯$CÈ½™À¢“-h8P­Îsn½›ÜU2q±¦2—ÝuçZ[o^Æ†ÏÕ3RC°ôÔe¸G]Ø­Wmf¥QªÖ¥“u_·¶I"u ©öåYßqÖ
dlÝ=âíãv”‚­Cº!"‡£dÊi9
µ0£‚Æ˜¢‹Y‡ÃåýN× ðåñ .B’
%¸9–W,­âÐ¹ ¼ÈŒ™/ ŒuA3ðï£ºÛ!!± é|©Ð°	$1y!ýô aaÄa°©bé‰.äê,³€C	`Ð1^$C+éh8S ²‹5_#=€Ô0ä#g‡1O£ ÀZ1”s€0³P²0Y ¤ÊM5†Hp:ª!)c+€Ë^‹Æ ŸhJ/(€ FbAîÛl‰¦2:c¡`¤Du›ÃI…†8ŽáÓi‰šrH,Bš§˜Ú`A°‘	}•ŠEp *zÔ>ÖeKi@„>ÐbPÃl¸¤ÁjÆ  [Ú‘.¨Ð°@9Ð¥™,¦°ÉIÚ,—!lÐ}"Ô»oÜr)9ÖÆZJÄÜphH,ñ‚AÌÿóäÄÿv4:$Q^Ø Tï… Ì
b$&>6baæ&aàe¯· !¦*"`á)ÖZsƒ’ý-ÀÈ9‰Š˜hZ–|~^µ‡€äQÙt#æcpL¶FÝ]õpÉ'¦^ÄàgÌ»â©ZP @dP\tN(I€Á@E¥+

+
,$Œ µmSfÜ*D‚¯Ê„ªv¨Ú«]EEzD µÅ1ZEòuÒ` ÃŠ,¶P¬D
¹šÒt 9f£ÓÚù%£WK™Å¼—MÔ*YV€î±å¿¬GV wø‚@ Á-xÍx,Å›hÕ¡œÆÚ8„ŽDÌ2ÈˆB…„0ð0/é€€X/²Õ¿_s5ì?³ðõ=$Õ62+´ôÌÕÇÕ	0K5—
ƒƒGLX&þ@ÈBàX-kJ¥ÆÌ ÜšR¦bZhvkêž’]^3Ei²‰o!¶€ÿ*¼:Ö%eFÁ qÐ¹N2ÕVCÀ¸"
€„ÌH	XÌ 0PUØ	}#„"ÃÄr!`±ÙPd.4`bFF@^PXð*™1…)NA Új„ ¦(: cBËÝ3èXôÕEÍ4hØ$†lQƒT`¥•P0ÿóäÄù|:E‘Ø  " áŒ‘¬€…$ÖèÎüžÎŒ åbBÀ !‚åßLv:` ¥ö@ÑÀDÃ Kà¸9¹!ÄÈÚHÖG…Lµ4ÕÁÄˆœ€fØB4^
4H ÑòP™J	†B¿ÆJ kY`†At3.781s\N1!3„'1bS00Ò –…ÉyOÈ08P	ž€‚IB›'‚ïVÖ@Ð&Ÿ0y¢•˜h0:P8 2ÀÔ9Š†˜0I‰‚‡Ð4ÀŠ Hµmnˆò
51‚ƒ] ™ áˆài…º0óD'2`fcàƒ¢%¶!|êLAME3.100ªªªªªªªªªªªªªªªªª )©LLËG85q!c¬ÂÜÛMbAbrÔ1±5„nyœ9Ymˆ
¼;1óËã^¬—Ž»¨òµ'Rjž]-§—ÓFoêb1„!¥Æâ˜Ðüæ7kGi©¡©ìíÇã—àI÷-‡ ‘¼kÌ™“æÒ™tÒÇN˜0#í:f	ªŒVTõ]
"0&`
³Œ(°0†‹& %1âÂ0Â
JlK„L1$ A€Ìè`ÿóäÄÁeD:Y©ÛÐ ƒ¡P`#&„+³!N‚¦É1£¼×Â[ÓjÇ#p(}Þ2 Ñ¤¢ñ™`2fÉF0&ÑÓvÓ*6¡ÌJÃ¡`&ˆ€è¢ ’çÉ|(, ¨ÂŽ„*\Ç3[Ã2 K†@XDF6›†i0ÐÂDL93'LÀ˜ùBöP äÄ DßŽJTªItõi/ºå`HÆÐ·°Ô¾hÍÕ¹73—´subÝ´k4¬¦…÷ìbqÓdb1çIÊuÙ¤¢LAME3.100ªªªªªªªªªªªªª (a0( fÕüâÈ#"Ä 1"°Ýethê}Žm f`m
Å!q§"ÕMN^šÏ:{¹ÛÝ&tõ§Ÿ:KCQÂÔ,f$V\0(X08¢ˆ¤›¬Ÿi6ä ø’¥TLbô¬–‚ÿJÝ™ØÝ)èti»)’B—t¸©ÓU"‘	¸Ž.oÑñ	@àK}º)±s–`\ (´¦
ƒ¢0Œµ|2AÒ`ZaU•Å—!‹(gÇ ŒÉ%TF,Á‘0hLðF9)”"bšh¦Ày(°!ƒbxÆžŽb™Ã„*ÃÿóäÄéo:B æt\@œHÒ¦4b˜Hà£^°˜QgLC“‘È´q2œã¦&AÝhD‹B2AÂçz€ás<ŒÑ*Š0@HE Cšbf‘¿xrqœF´1Pa›Np˜ˆ[×ÂKŒ“DÄÑœ2¦˜AP&`Èë2	MôÝL@0§ž0¦ÎˆÈC&AbXÀ„Weµdª`À)&” E–YÉRaƒ€‚ ºÅšE(RÀ —F
tÓã|™Ô[:Y$À‘YÎrd’ø£~±ÓêîÆ]˜­çÕùšK¯Ùûõ00@Ñ0#ƒ2Ý1_0=C22‰0¼ ›0F	3E!01A¯0¦B¯0N€0+Àb06Ã€ÜLZ‹ €Á†m&Ü6õ6L$A YwAŠˆ ¥É—M§ Ë>`p(À|	ÌwZb„ÆY}R„æ`,I²áì¡œ1ˆ Ÿ´žeá•¨F˜‘X*f1ß®FÁ2˜`hÓøñ¤H2iŠÀÂ©q‡D.—&ª–»Œ¹1`¼‹L®ÌåÁL fjÆØ†*´w ÂF£àŒ`àpHÃ#—¤€"œ|’Ôˆa
½Rd
P
9ÿóäÄÿtŒ:  ÿ2œ‡0ÀQ±‘Ï(
Â³UÜ €Äkn$0¨à¡&rN:(0ãUC]Äën’°¸@ç€
›³€!m6xÂ#‡–º@\i4$JKC4#*£P«T0ÆRõˆáEáPT1UFN
Ã`… ÅÇCbæ‰
°JéÝ
ÉBK]`°cÏÍþà‰íHg)dUÅÆWÊßÉ;tu¥q¦_3w£ümùŽ~Oõ¦@ý¿ò¹\7+¦Æ%,ÆU*äª÷}_<–C;Yÿ}'f9zbAªLAME3.100ªªªªªªªªªª0 \0‘Áì5^_3FB‹0üJÕ7×€0¨0¶
49CF0g0u0(À30?0¸Ÿ0€0$ÀSà`#	Ãƒ @¢ uUWã HE0°QW  2#ÀL:©R5‚À3iœ€á|ÂX`PXhj0<1˜=1ì1,ï2aH0#2Ír6×b>å7tÞ6Pù4.$4ìy4`–9T7Ó0¤5ý¶6j3\#0 1 £2H0ÌË rc  Á	Õ.sŽ€’Ü'â4¼Óî¨AŠ‹˜d¸å˜¦ qÿóäÄìoÌ9ø ÿr¼8D5¦7’ 0qS‚âµ–]×J­¦¬Ìcðå5@²vã[ƒéâmfQf‘ÉêŒÕLdÍ=Êe¹ººRö¢ž¯+o5"¦¹}Fbó?NË#|¡¦¶ëFbÔeú„3I{r›£žúí
_€ø.+ph»7¤‚Üh)bðÔn3!‹¿ñ+Ô»{íC×ýü†œæ–óÇ¤Œ¶~´e‰2æµ”žEJõMGåTóëµ>®Û‰eä=îë½0ï¾0›]~šD5^,C±ÆÞÄ¢®Ô6ÐoÕLAME0Ä1´DC:¬ø€1kÒ2 ë5­ˆj1ù’2†N1­Áè0yÁš0¶D0q@\0o ý0GA0Às0§‚Ã0"€{0	À0O@
0 €‘@%Ë~`	 
Ei^  á›Bq‰†„» Ð±  p<ÄÂ Ãƒ&dZU'00”ƒ?4ŠR2<8ƒg1×ã3¤4×/ÃqN1vC™P6k“’30¢0¡à¾e‚&Z ã%'F–Ð¶)ôºZê/  Y$Ÿ¶¼	Fã\è,b¤Îz?™Ry“ ˜0qúÀ¬´m†*9m¢›@.êõÿóäÄûs”9à_Ø A”Õ{Ù"0)Š¦N&•EéNUJd®ÒÂ
ƒ–¶0‹° ‘cá•9Î³FH|ºÈdD€I`a)Õ •¸ €[´2ã­ÅIwÙi±¶èÆdOëX”æ­ÌdŒIÉ}W»Wz_ŽXÀ
·2nàc?.€àG¤e¥Á0$]Ò…¬ŠÞ,½¸rËK~-YP/fî¯a˜}±º9'µ—%æ_òubq£4tÑÊÄZä[':Ã‰'‘Bdï¬;^-EÑ¿”¯¶¼|z¿1wÕ@0 @ô®oÜ·&3ÑRaØ&/G^br =Þ“	 Z aŽ ˜
Pà€h`J0r71÷
×é¹8‚@,¹@ d˜A2Â€b(’øzIŠE˜d7f2¢ÞbF&A˜þÖŒÎêpÅ€õ˜ˆ	ˆFü©Œø§˜]ýAP;UšøGG±.gÌDCÁüÌ@ÄÇÐ_Œ<‚¨Âh+µØìû¸÷æY½\wXqt€bž#æ(¢þbÖæ<CXc80F €ŒdªjÝœ§Æ7ª
 a 'IáÕÎç¼ænˆ f¤2ÆâzdöYæE¡Îd40ÿóäÄÿ{ì:1žð FA˜aˆF$¡ã«˜[§š¥ùŒ¥ºØÃyEî»sÏåß0Ó“PW10#0àÐU*„°,_ƒéƒˆF˜Eù„(NËªÄ«\Ã<wM©˜ý˜¤ºžW…ÜíMY©úíÓ0ã0ÑÒÀ˜;ƒ¹‚H˜.‚É˜ ‘€ðP 8`!,ÀpŠ 2õÉMj.v›ùvöZ±R¥Z~w.Ûüã÷=>·ÍÎ|¿Wìãµc0 ³ ÐsÀÀ‡@0 A€ˆ˜€*”  0 w.4`"¦ 
¯Ì@À Ôš0€!14Lf@Æ)ýJ1‰áÉˆ%!„ƒA…yÃ2YÑ’ù–B(„D0ÄD, Gƒž&<Fæ åÄ0 H¥¢`È(`ø a0R­æ‡ÆÂQƒ 9€ à00d08]0œ 0ˆ0 _0,0ˆ12¼
0Ìf1än00L4p2à+0d03‚1ˆ	ŒXÁ!áŠA˜K0àƒ1d0(0ä41 0l™0ì!0”0Àfà øÇ@œÌÒ|(@`@@)˜D(…Ã#Ess"„Dgdñ!„ÿóäÄâ|KÚ<è ˆ&L-Gƒµ¢ÎD`0¨V` L<#4™úS˜;˜£˜æÈ˜@¥aJ€Á…`H`„`(¦€êÊ0n.#ÌªQ*9&%Ý0p+€AÉ‚ÂH ”`Ø\bØL.Ì´D 4dK˜²N<R¢ç|C)45­^½.ÌL6D ±q‚À‰ƒ €T-0T  b |˜
 w%ªöXbë4ôÚfML·4ÑÔ©€^X
–jwµuAûçrÏõÎm%aQ`°Íe(ˆPãK‡d1¶í+yéÑ‡j8ku²¦ÜFv´Ôj·)©nSPâ5n¬Ú´ULAMEUUU*‡qŒ¨ÑêÕYŒ˜ 9­¨5‚ù„n˜³‹Aˆ g˜Íñ’©'±–áÆ!ñ9áñƒ8”˜hØ`li á€€˜8a ;•AàÂˆŒÀLÈì³6m4œÈ‡³mÝÎ¢0útâ<³°ÍÌÁ5“øÍ` ç©µ	ær¨ T„
„
C‹F?hf`R¨ˆ&,Z1Q4 ì !–L$KÜÎ``ù‡Æ˜èÿóäÄ¼cÌ: Þà VL$H:HsrG@Ly¯¤ó†½Õ¼8F(„@)$¢1ˆtHr l$ÊL‡©U"ù@Ì¾D tÒ_ê]û‘F»O•ŒècòükMJ†±Ê†Ž’þqh~S?{t²)úÔÔøLrÕ5õ=ü÷•ë¶{bÏÛÃêeI¼÷ÚßzÝ»ý×rú}ã[ÜÖû—?óË:L0”W©fµì&ò±OzžÕ[ì^¹N}=‹ºÂÞ÷jõmk8¥É‹ö§êîU–ù?wùo•d””°½„CvlªLAME3.100ªªªªªª0y q9T®£(P%0Ø,ÓH‘003òŠ0Eó,r2ÞÓB3ö%Ó
!4_H3aƒŸ2Ä=Ãu^4ÍÑ:U°4T|62ä1Hm2UŸ7¬ä24N5!’3Ø<8#0= 3:sÒ=!å0í·5¾i2	˜54¸4|(3¨o2Ð1”C0È›1œl101H\2LX0(L1ÈU00|%2[0Ø1P¹2xc0S2tÄ1„>1l¢3,22¬1,è0áVÇ£#†AâÀÍ@ôÀ ¤Ãrß1…"S4¤ÒJ6bŒxã€À82ä€ÊÈËÿóäÄðpä: ÷t¸ÂÀ‰áV¦^Y–08hÔDp6þ
P¶mm:! •*ÂÚuŠ­h½ŠgšfŽ°VÂ°0š´q©SôË¦#’ÚX'^ {(aûôÐ|û­1Ú¸SÐãI–W¦ªT‹UÖ4òØÅŽ_™¤¥¦ ©=O7M† ÇÒz]ú'÷¸ÄÌ?Ñ9‘wRÿ³¸ÔaÌÛÇðKõDÖ$pLŠž/C1*}aªEpqrß˜•\/Å©é'á˜j¼b/MÝ€é (v…Û¦ãZ–µýV?37µfýÙªLAME3.100ªªªªªªªªªªªªªªª!L€À$’¯ÛüÁIŒb‘@Ä¬(ŒFÜÈðLÀ<Ý	€ŠcR¤F`<5&ŒBîa2;fiï®f`%FiêzcÞDàb,.f€øct$ÆáD`œ5FRâf`ÈIFH'¢c€+†Z¥À`L F3bîe•aˆÈFqU˜tneÑ±fE˜¤	™†a 4*c9€Aà‘ŽÀ¦/˜è&™4(`ÁˆAÂ£“AÅƒLê54P°ÍDÃªª„sƒ¤´¶3Á-1Œ(HÌR!0@ˆÂ‚Ã 	†@ pˆ2TÿóäÄçnÄ:÷˜`dB¦k(b¡‚@À€²ø3ä(`êrù»-Ï°·b‰DŸùYMõŠH%8ÃÖýÃîü}çgåÃuâQ(CEŽÂÝ¦± 3‡¶û©NÄBòÙÍŽçÎ™¯C\tYD”úÇ±ÌPX1?Å«ýµ>º°Ñ²gØ\¼’P'lCÁ ©A/‘¼S%¬<ZNtºJ—ƒTcÈ‚¸J-šš“ƒ¤‰®žBJBr¡äI8Ä²±ùÊÕ‡Ç.—ªÄvvjt®sÆ3å¼LAME3.100ªªªªªªªªªªªªªªªªªªªªªªI€M–9åºâò…©¢‰&˜RÙ€±P™ a„	M˜=Š¸PŒË´ÄSL2QŒ!uL1PÔá]ÁÒrÙÆãFfÆ$àb‚KfG€þ`ÊÆ“c„aºÆYRŽ#%‘ß3jÑC0cŠN-58¼Á„³]Ìn© >˜,î:.•¡ó LT0P<Ê„!`!“ˆ@ä±ƒÆA•hÇ©3N=3¨Øes²Œ³9Ž®p6Q”Ö%s"ÌJ0ðÜÅå° <ÇÀc
„—Á ÃÿóäÄàlì:÷@b°à 
R£3QÐÈá q][Ë>“¬-€H×‹\¶Ø§áˆûEÊ} øD¿;±˜u1m-UnkáPBªªþ]¢tŒ" NR °	ö-r6ÍÔ€˜.ÊiGåXÖò²ðüºñ¯K°ÈâEC KV7ª‚Á)Å¾å·”ý·‘>_0/ái[+[²ëFñª®»(%U‡$B-Ü9^R; ™Ÿ¬©!„zÔ'Þ1]Ue—IâZR|.Q¯#ºG8'¸\h©V]2:$6³–R<õLAME3.100UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUy‚(Li¸ñX;ù˜ &ÁŒ€W˜g!‚Ñ˜¹‡iŒø4­ˆˆ­˜Õ	ÙˆØ™1–86w!—p­¸‰¸w˜V‚á“ ˜˜¹Øªgi‹è–1˜‰€X—ØØpï˜†	ƒ`Uš9IØ€‰‚#ŒD¨”d'ÁQÐÑ‹‡°8´,:"0 `H©† àT ~bªNh¨XL 5°ƒJÔ3Ã^¥3õsZ'3’s%0b´¶#øÿóäÄÔiä:ößqñ‘‰„%AŠÍ,8Ü‰t^5¥LT6i±Vo3A~¶ºzÈñšëMLÆR™'j¢ðLÉÃ€¡A79 …b¸Ÿ&Ó4~)q0T9q²ñ`"…8À›ŸìMï[ Câ5¿p´ì­³*™ŽiÕkK{tÕ[ºaX7‡E+[æµ[Äƒ¨Z€¦p„æÖÛ•Þ™ã­8æ+ÔJéˆìî—²ØŠV«£ÝRä­ˆ‹9[ÇîÐ¤º¹½±:¹ŠÔ¼Ož0(šTÍ*Õ—L,S©ä:ãôƒ‚**qëÅLAME3.100UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUq°h'0)Á€y˜|©‘/˜q‰ "°‰˜Ÿ	‚X`˜¡Š‘ƒ˜t„…à•™—1…!+›O•qÃ!è‹Áœ`Ã É‰KQ°Ã‚‘–g©¡‘q£¹¤Ø¹ýsaÄ`qÀ"‘•å©¢cQ Y„bñA!ƒ‹‚*„é`@¹é‚	fÂ3&JT$ T À4e¦dé¼:,ØÚO1Ä4³¨Æí3óLÍÃÚ4ÁÊtë›P†	B`p 0Ô>f`CE’°Æ‚}ÀÂA ÿóäÄÖjd:÷t¬‘Ä’R$!œõïFèoÉaP¥®¿­y—FÜ)Kp§ydnÖþ;°EW’I¾ðuÈ
gLI‡5çuÕy$êVÔBE#ŒÈÞV@Ò&Äû¬W±|²—MœFÜGñ]Ðµ8rFÏâÎVéîm\·EÇ©ªLÎÆê?ðŽQÃ—#¬!‡pDNžGIÊ5×ç“=¼üÚŠç.ä5+—BîÐKdµå1×n«ÆØB  Ö°–OÏÓÞŸ™v¬J,ÊZÜ6ã¸ínVïÔ|¡é$¦=V–)”šš€¤!…LAME3.100UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUL€$Ê‘Mý¤ÇØLAüÃü·LAÇìpL
@pÌ>Œ.ÂÄÊ  Œ&¤ÈL”4.æpÉ¢ch¦’¥îa¼å`Àæ¢Þ`2"1!Ö*/F:à^`¢;¦Á4`4Š&L£ðaŒ.f=!¦†€t	FR>oá¦.l!†6m£ÀQ³K"IóJ1 ƒ*	1AR4ö00 !“ƒˆÈÇ¬ÔàÅÔÏ‡AäÔŽãdP@ßFŒœ€ÙLÑC›¡™„ ‡—¬ÿóäÄ×j´:öß *Ž¥¦@±`¨1‰ ˜		U4L0¶vr€Áü^µåª¥JíDý‚!äÖŸCZŽg$ôx‰âvôÊ7LcÔ/ŒÑâ_×ÇA.§Ô‹+”é£P‰fÊ¥Xn®Ï×ÌÑÈ‡+Œv© éê™òAD)G’¹a9•ˆ$I¤¡nGÇn‚¡nÓ{¶y“›mïZœa¹ÄÜ;±·³'\["°5î‡Q|Æ1‰ÏÈi˜Nhä©.ÅúxÈbD ¥9$œê<î§ÂœÿSŸÈaØÜ~8$âLËß·±ÝLAME3.100UUUUUUUUUUUUUUUUUUUUUUŒ$ŒÆï’ÍU‚À‰4Á€È8L…ÁÆÑŒ-„ ÍHwŒ< Ä¢L5Á@Äd{ÌH”|Îì@‡ÖØÒ,)N&L`>:Yq6Ì'H‡'Ì«lŒ×#o[Œw`Í>LµNvaJ*‡ŒëYL­Œt'œ;(
@ÙA„ÖE éóK1¢Ã:?1ÁP() ˜¹–,ãWW Š™ª²ñ»»™¡‘¤ ˜(pÂÃEB:´Z¤Ñ ·Rê—$·²¥Â@u	@À0\Y BÿóäÄàlü:
÷v¬v# 2‘à)r#µP9¨%ûe/;Ýbsî×Äà,äÐDZSj§‰¼ŽêF …ßjXÕ›¶9·®™iÕXIlÄºRíJ-ÌM»òYLj’ÔFô¿åÙÃcŠ07íÝràI¸ü]÷áønUCñû’ùØý-bK+ ‚è&wCo¯L’;'‡e3É£íWúp^»ŠPé²M¿Œ5»0Â‡§!îry©L¦Q5Œ?ò‡Ö0ëP¶ÔÑ¸!÷|&f©¨¥ò¨þOMªÌOsqHŒº"LAME3.100ªª ¥ 8³¡Óˆ	³
TI£
 CX£ |ì9Óô%3¤ƒ¤@ÓÄRƒ Ã$B#+3È+S–ŠsXTc18‡S:‹p` aÈØaˆb8àeLbÞaX„f¹°giàg*ˆqü(a:Zt%ºe@Äa1œ¬†sfˆ$DÉ‰)™°Š"ƒ@Œ$(
a mév–ÐÇÍ  FNXaFæ|Š5a¦ÆÂ”o¶6|`„æ `!}!*Ú™G¡ÆfÍŸ
)–%IB—ÕŒ¡À~“ b€fÌ€Ã‡Bá@ tÍ0±a —ÀGÿóäÄôqÔ: ÿv‡KÞ­Ê.ÜŸØeR¼ú™,ðp$ëýWŒä«¨[½+.¤Ë&£u’æ\ÑÆ³4çCðÔÜt\ftÖTÜÚTZ4º' zöoD\gê<ÔË)‹,¨’=ð-Ž?L‘ÖdÕ² ©×#wR†ÝÒ€Zs½	…»+¿Üœ:‘êgÒ‰ô{$.„¹Ð}\ØË³Vë{-–qÙˆEß×á¹»Ôî;nªÃ²F)ì².úP»Ð#õÌÃì9ëiQØ\aà‹Î5™‡fe¤qˆÃì±é‰EmOGªLAME3.100	`“‡üeJ>bkõ\a§$g“Nd’‡dÿ–Æa£Rc,aŠÐaË‚n`[¾`¼a_„(`FÚpð&=€b¯&Jâ‚h¥„)æ€&03
‘™*q’‚‘¸ù³:™ÎÑí¢vy· À „T8¤óeêL$µ¸ÈÚŠò–ý€°€¹ž1Åš®®@ WqÌ¡`®üaýGP ËÀ64àX!`±%Âó†R á	·¸;jùOKÁOB  ŒíÒ·šliVBWÃUE\»ZÚ˜#Âv¬c9Ö(‹ecåËØ&Ä”€ŠH(}|ÿóäÄörl9à*þð)^1$5Tël	ª^uf_‰j¶¥àÊTÄ¦ª´Ý ó0òâ¢ÛwVÖ° 
ô,Ú¤KÐHDÑøˆ	˜
GÌŸ)¬ñ†4À5 £-( €<ŒÍ¯$d3,z°yhÀ‘EÜF5u½BÌPÔCLÒÚ¥‹LZ+…‘¬å(J¡Ð/WàîÚÆ˜Ý€×]½Aß%à[ž©¢êW§B"&»ø”ƒHXfeHù9h–‚Ž“iX†ì±yÆZÃqPÂ÷ ÒòXD¦éñ¿îõ| “Ì)ãL³˜è˜“däc<$bƒ%HÃt²ƒ¬<Tó”B£4ã„óPS¸Ó`P¨FHæ(
,ÑjÌ àÌ°ÐÕXÂ   n¦,ØÚ†¢  MV\œ€3ÀG'¹ÈM0Sº¡¸iyÖa*ÁN¡¤PqìpŠˆ¬
`hR„ÈÉTšû
–º– 0AÄËÒY@iâ€ÂŽ²-–Y€¸ª¦¦ƒ¢iš‚?	iAë%!Ø]¶"/Ù€ ”“˜‚´Ä
Lô¨ ‘ i†­8ÐŒWq™AÿóäÄÿu\9Ø3_È As“ËÂ.òZ¶Eï#T
ÀÝP=:Anmi*Æ‚DP0fx©"†é~Ú'šG)ƒPUl†À…©€é‡UT@ÜH‹´•ˆ™€ -jÃÏ4Å#ÃÄµWÕ­2AX‚±«(ÑŒ¥¼cLž0ÞÄf…<L]–­‡	*•¹aåèqi¯›§‹sDáQç×t8µÝÇM´bë%‰—&8ÜS•™? ·eTF Ä˜‚"‘}ÙT©ÿ+j½gHkåPfŠ%–/’ò‚‡gkI*œ~M7E•>ª0ˆü3èS2|!0„“1é2Äg0ˆ&H…`€HÏ‚ˆÔAød MCIC¥é³‚Ù4Cf)&`ø‚0 S( 50HC€n[
pöÂÌ¨z3%p71L£H2Ó-·ªi¦N` &
 j`’F€(`F¦væZaR9†weÂhg¦a¨†L®´Ísp/-±€°(dq”
I„èH\ !‡ BH8'%qyÎêr\·½ù}HC°`ÖãÀ6`J` @i¨˜teøÆŸ’Ñ=04ÏP7ž94Ö-2S
 Œ&“  ÿóäÄü|,:ð y`C„™„ˆH˜E‚™ƒÀG¯ÐÑQÕ·¸Ì3Œ<ÍÔídpü7…>n$û5á€ ˜! 1` Qƒ('˜!‚(`/˜€  A@
Yjö7/µ,¥ûïs’Ep¦èNjhxGø~Ï0Á`u9‚`#É¸‹ @°-˜&q€8˜ €Ùƒ0 h
€"Nå,Ëw-c/½y÷™~\þF%ñ˜Û·/˜³çâýKôVr¹zÆ¬„
˜) úI5Ñ`1G¤¬° 0Pp¤;CcKíÐQLåˆ,ÎÃ†ÐNÆ™IŒM8äÆ™M¸üÂ‡NCüõ7N™èÁM5èÜÔ4Ï
L×Í™dŠ jQáà ùŠIÆ[,ŒÀe1ƒÁÌ0Ð”Âã’0P`Ä¤#E¥
À7*˜êåãWDLhg4Ð Ïfƒ;¤Œ¢’ƒV*
M7 ¤Ïc†Œ$2€üÊ†3ÀÁ!À@ÆUSFÕ†Ó¼ÒUÒ›Åš-±€@  Š©z\Òä–U3W \£H
$*0lÂÂ3ÿóäÄÞoÄ2(ÛàL„PC†:0H!£QA…‘0  ¬5n)KL`EÆKRÈ€€¨¢üÃªvƒ¥É›
á,2'‰«»**}˜’_+¦œÜ’)LZì4­¥Ý-ªšºˆd€W19“	È,á«k4/j|§²?:eÝH–J¼”ø\Ì°®–"ÜKª Î™uKj¬5aTˆÐ¹2Ò¦tï>«
Îèi5æ½œFŠÍ7ÕÂ´iÚŸW&[g+]æ2˜eÉÆj]œEÚœ§)ú•Z«;f$å;P÷~·nÒÒÒØµºÑ'eý‡owêÂnAo„y¶V§òA™-Vnñ¡á˜0Æaó±Â&51Ÿžde£æp™ *F&‹—›lh¡é€3¦$ËDÓ@€AÀ$å†‚	ŽP.¡’f(*b†„Ì¦@Œ¤cÿá˜çÆ¸[™?Pi á”PÆYF ”¦‹$p¦fÙ…Ìæ£(˜œxqæÙÍjfgAˆE€öeaÀŒ <|,X ƒã%à/ëQ/òÖ"¹zƒƒU‘PŠ™)‰XÃšÌß<ÃÅÍhXœ1`	26 ™­ ÓŒÎY+ÿóäÄòtÄ9üFæñ„7PtÂTë`Ó‚S¤Ò4ªPŠŸ^ÕØHðRP±–ƒ‚€g”Ý•˜§šé`¡ÁYŽKxÇÐyœ@RE¤PˆÑ%8Yíi[¶¦¸b(„¼Ó]©®FÊÎ)šÛ±2B«bM½ÅJVZ¼Ö­¥ÔÁ©a²Ù¬²¶bÞ2ðÅHøÀe¬æ>î§jÙWMÁ2æ Œ!¥E¹d¢~-UK[‹_dN3îŸŠ¦½–&"àƒŸd;2¦¶’í=5žöÝ%Ûƒ/pÕ™#×<MS*þ$µç#)Bz·´fTÒ;J‡¡ë­ÍwÛ0˜Ÿ8m-9œ‡;˜³6Dð5A¬4Z1œm1À)2\t2À½58%/„d˜#ÉŠ…±	Fapxaº®gY˜bxX`*>cÂ~b þcá
`èn`XBŠÀBcÀ`lH@ ¨,˜BNÒœI˜ft™2³™âšº“œŒ1‰¤‡^ 'FÆ#†·Fæ4–¦\	†‹fæZf ¦@§ÂŽ¦t¨F&.³¦Ù8€˜Á1ÃahÇ€ÀÈa ÍÃM!ÄåRMI(˜ähìÅÈ”ö/±¨QŒ ª¨B|ÑQŽ8ÕUêÏÿóäÄòzô9ì îó„]PÙLŒ€¬ÇÌéÀ,L@Yóh²î‰â"‡—.Q§ Š€‡*‰@<!¬Á‡›@QÄF Œ„r(T¢ìá¥)~€’Î$ãp’<‰ìû ™75Ü]+G¤ÊyXÚ·BK¶·Ô¬¿,ð*ö^­1ò&aÚ!‰ÖžnzÜ`Í“ÃEõUD›ní³‡í¸¬á¼A§ÂôÆ\ËËnp	S¥-¥3†(^èE–ºÎÛt­«…}¥R6dügu©À¹JáIö²â¾ìãŽÓTYœ²È¤½Ñ^´Ü¹³3µÖÖžŠHŽ¥1ØfûõQ­»ÓOìY4…•…hLv%M-êcŒ“MŒrL¨†Š&_/™0˜dÑ‡˜AÑo¡Œ&®5œâêtLÉÌ$æHsE4lv©®Ð’` °0øÁ †DaQ1§Œ‚Ì.M4C8ÛIþ×L˜Ú3ÔQ“ö\N@08üøêB¦„&Š<F:2ÔcI4,›L¬Ê¾¡Ú™ #•lÝàKfXäp%&¤ölŠ&X qñ†š¤bà€ÀrÝ‘$J¶˜ (`è0ÃB \ÐÌP¼Ê—LP0ÄAÿóäÄÙu9ä ï6\i†5ó&/0A³!<¨`8YÛWO›ypÖƒŒÝ&Zº¢°ð{`(´×Ó=D&ÐD< *Ë‰ ù‰Ãª‘[S½¨vÐY;•M°¬‘,th	¢]Ô@R%€6>šJM¦EBZ¤XgñXidÒás´ÅV~ÑÃ@:|·$îSÍ%àbÍ…|¤ãb.Óu¥± ²tÆd2úò«—¢4ë	2&¼ý06b°ð3= n®KiÎ´¥’;ÊóÄå.²äS7>ÔMnŒÁ¹4+ïl±ù[´Ø'ÜÈƒ™h*ÒþµGqã[ËÜ±ªÐ¸Mô6á°XÛý}”EkÃjLAME3.100ªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªª =.ÒmÆ¤Lj$àS½>gGæ”²x/H4 D—¡!¡Á:¨"¦rK:cH&~" L‘ƒêFßv—Í4äf5È#ABºlŠ¥s+XÛ36šK!ÊCx²ÊDG¡†µ 	Žçj)œôÈ6îÀg¢1–Í5Z$½dlC¸ù›åøXÿóäÄY:>ÞøË•ƒÄ†Ëín³ˆ)‹;ñÙ%Œ[Q¥Àßt£.ä¹F˜äøªI.Žõð‡Œ¸¬ñ×B’Úe/ÓÉ,uFá	=Î„ò§<”Â8ÊL¸Ÿ0ùÚLÆ)YL—®¨•8T„úÂ=hLìeJ$é†¢4Ôâ…É±œþ*´OHQž•xXK›†ia@—Ô1
4´]¡G‰¶|)f'§ü(jeÓ;RÊ>bF’s?œJæ™D$&ò’7Kº˜°äé [Jó…µ8­2ÎÑÒHŽfqhnfLAME3.100ªªªªªªªªªª
uA#cþ3t3a:1n“/Á½1ˆD#r€2¶ Ç5á£Qš0¦³˜q-áÕHœQ‰†	'Q‰™°¢ºfXV`EfOÔWªl%fv
d¨ Ê	€“þ”‹ ¼)uE>!8Å8?`3áï 8èPXœ¤h”:'ÑfY´¸Ò ±T,Ñd9 €ú¨œy$$þš ˜r÷¯Ded™2CÍLãA(/"ÁˆT1Äo¨‹l€•ò¸ŒrQá98)ž
¢LÒÒ#ùwÑma"ìeÐP+Ef¨ÈÑÜµÜã¥ŽÿóäÄìp9ÔôöòT<i¾	^%|€ábßw—tG@àžÀ‰$–)Â“TÁ0±DÆ0„Š@"”R(âÍ+:?!ÁKØ
e†«“D*” ë=.#:XeÖ‘)ð•ê49šÅÝåþš®jþ-“ WË±ÊTéô•éP¬ÉòêÆ™Ä½)Iå>¬ËœÙ{rY3âÓâÈÚÃà&ÌœsŒ®še^˜$¬%³±Õ(Ó‹b,¦‘IépÈI®QàÑxPÁ,X%eAß·€,*t…C"•ÀÌ¡Æ1]Cbü0º0ó)RÙ1‚+Sãì3!ó00L 3  ±b"0#0	dö0%É@™À€Ó†(á’gÆ$fÆ1Åˆi)v'¢xj ˜óG naãäŒPÄc’dÖXŒ1¤‚¦,±‚ˆ’_¦åþTpÓH4Pa4)aJÚb,4ˆ êÅ¤LÁÊˆA2E å,y$P1S/ú‹‚¢aÁÕ¦nK4X@)š‘( KDñ<)eœ!ÅŸ!ä—‰†sn›äÅ5¤ÜHàHe%J(æŒ°P RH„@Ó^‡aÔ–@•@ÀÊÿóäÄÿuœ9À ö²Œ¦8±*RíÈÇ8xa…ÉDfæ2 p² „I‚	4¾]âaƒ
ZâÙ€#ÁË¼+ŒÁ
ZÔˆ0)Ú	!Œ±4JJ‹@YM	w¢IXq/ù¼p˜HFœ¥%$‚4 +Á—tF-—Iß]‰Ø %þ›D¡ç—9B(¼Æ¦9ÒFB±Qy5!—¡1KÐß¢íGD9{ÐJ!X›LAiÕ€A`•	
`¥,–èv¦â(T¥ˆuÜÕø¥Jv,` ¥P”~4< 5LAME3.100UUUUU1J	³n2ƒ:ô¸Y1iÛ`sñ.L˜'
¢ŒÂN0ø¾fÍæ±`ÂÃŒj3cIcÁà€Ä«4°°_©¤2
“J<¡Øy†eƒ<ã!	›,=!/¡‰ ‰3±ðÄˆÌ ¬¤7	!Ð FM¹òBˆ1a¦i¥ !5/ƒ,´}dD
.Ÿ ÑÍ ÈGñ\¢ $#–ÅU *×2Ee¨þn…Q]ƒ¤µ¤Š†×émÒGŒKÐáP)XÁ¿ /A
"Ê0!Ú©úB:q¤%W ÎÿóäÄíp,9À ÷2=ÍAÕTš!AABðB#Ú™qâKµì–’'“©Ã
$ªE0†âÀ]@qâC¦³>"ž…ÃVØp¡âÐ DkH%-@öSd&4ERUÁDRÌ±$ê}˜b¤_(ƒ
WŠ`©R	J¢&C*bMy¬(0\ !ÓÄ°0Ip_rA“”¼Œ6LxZS%|
$T²”#.X8¦*àé"#Øô[œ²Þq©y<À˜pÔ{|STxá í-LÒf\	14Ö¡{‹ÖÐ	ACº0¢OÓGã>1F,£ÁC2Úcð\0ê
S`®04 ãY Éä;MÌ™DÄCÐç°4Dp!@xÁ J¨!°É`A!R‚8A&‘X0+Ù’ÈJ+DÐaayUŒÉYv’j"$à:Ài@b@à¾„i*RòE—äØ Xs¤Au‚"@ˆU8[³= £f A"S/	[&D‚(:[	~d.€’ÀÀÒU˜J8Á
ŒhS8àcðrI˜4q7Íd¼@CŠÃŒ´dJ )KŽðˆÎA6#Ãp B Ñ‹°=°hm­!º ’CÒç#ãÿóäÄÿwÜ9¼ ö²T:2(:åÑ,è9‘ç\äA$T'sb8+âÁ³_|Ð@` T=R±v¡ÀÆ¡ef ÃÂB¢ç4d¦@ˆ0	CgG H!À!( A€Ö†mq…Ç0Á Æ,Ù@·å­1U@1gÃ%d0O3 Ã DL/@ 1$ÈV1 ¬Xr-E¬Dó’þAE0’„¿«’âŸIC RÕ.±¥'„°"íƒ%õ*&0Ý&\¥J[BMR @"1ÒÊar½ÀPÛ ‘ ˜#  ˜ÓuLAME3.100UUUUUUUUUUUUUUUUUUUUUUUUUUUoþêS9Ž“u;C€-…ÓƒÃÄ@˜ˆ 08!+Xó € ¡,¡ƒ€*c€f!¡Á¥âZ9ˆ†^D	¦IC’Ï&! 1ñ&€Ô¨ ¦ -X rmx
‡$°“Ä˜° A-)õË±° >€¦Š[BˆÂ8Òþ,ÉƒšžúR>«YéÖšIVžÀÁ-ÓU²š¼Àëƒ3+	$HõDª‡ Š àÛËðwRuk+áÔ”Â ¾áÁLU")ÿóäÄÎh„9Øôîp\mÈ,¢0”ì©ÉXÐ)t
€)¾D¾Ô~0ºZˆ UKWlQ ­q2‡ÊïCEÊT­ÞPÞ)“Œ @2Xq5k3–VX{ÖŠ¯TìBÒ«YlßAâªš°6s4AvÕ‰£(h
nü2Çuo¦rÙvZ„<×™*FCR§qR-„‚Yku_/{œï§2gL…aÖ3“	kìC¢ý*»c©¾‘QŒ#üôÀ‘ÍvØ“C\‰|Ãb-Í¢#þ¾PÍ
R`'«`~›3?¤JïLAME3.100UUUUUUUUUUUUU,£$Š3!I“‘½(Sðp³ °\C€tÀ  Ã€ÐFÉ& "B8p‘ŠaÉBb¥°˜h„i—ˆª`eÅA€Ì‡>BÁIG-R!j^!!× ¤9wÁ¡—ÙE“JìÂ›3ÀAD`ˆDƒFªQS>ÉŠ¦"Ý¸&i‘kDd8…†Ô³Ñr@‰OZK`Hªr÷—<»*kË›Õê‚ä%R–ž›)ä^T´/ó|YpW’_E•´
U(+C§Bh
%	‡p
Mâ~¨‰¤ 'CÿóäÄéo9È2ö°|] ‚ÆÄ9…2*´…× 5ãa+”½@áˆˆ™ë¬jÆ´‘‘ Š $ Í„	 ÔXU!J39U31eXP(y‹Á‹¬rö—‘éÔíšCsî"Ì‰,³Ó4%þ”(Á…”³AH„ƒL0pGCäÐm¢ÉÆ¡DY"„,–žž³ËåÀ.ŠBR•Ú`hÂA!k	p±ûœ†ËÁþu!@ Ú±"ðX¾¬J¦eì4åaìÝb(¹¼ARá£"qz•LAME3.1003a;CÃÈ4¸#ú¢£’DóKsDp@Ì O7Áª˜'™O¤c˜¡F¸DÓµg‚´*‚XFÁ‡q‘¹k y„ï2Ï-ÀéEÇ@`Ž" ²¥ë˜ž	¾e„ThP ÃÌ!IÜ“Aà -­Zá ˆä\ 0€ftLØÐ¥³@˜ÈÄÃ/¡(\q ž$AM4@0Á4Æ$íÌ"…•(ÄH¤©RÔ5žÊ[ÉBË*ÖˆŠaA‰´`2Å” ³KüXS(ðÄŠ(dd€”ÕZVÄB¦Š“’ŽŒ‡é—X.Ò %MQ#È–ÿóäÄör\9À ÷r	>žËDÑ(X6bŠ,=.úe¶JçÅ†¸¨Ì£«ð@ ð(t`{9ƒŒÄ 8¸«¨‚ƒ©$DYz‡#	jE0H4ƒ`â2¶ 2Õtµš6HJ›25¦é—%O—(
2j¡!¤€—)KK€4!d‹„PZŠ8†hÁ
2áÁ@Ì¨Bî‡€ À5N™ú>•PÖŽT "HV`€‘† &y,‰9§È¦ –0 †Lk“J6~k! ¤H`ð3fJLAME3.100ªªªªªªª	nÕìåRdÃZb«4d¸¤h±ve±beA
aèX`¨Æ^#¡!™ LÄ@€Àƒ8\20a@Ã|ÁU
 ¬HRE@ƒÏ;a7O, Cu’Ø@A4ÂÒªxO8G úuœ4;IA ðàØ„d—¸Ô<i÷¨Ë4 ´ÞFPÂ]€…˜I»¢Jl¬l¤UT*9(BNjÐñŠLÁ¨êü–`Ð,Ëàm‚>®Âs¶šÁh¥Y˜Hâ]!c´$)z¡  (:èú¦hr##ˆ‰ép­b£N²›LF(ÒˆÿóäÄïp¬9Ä*îp¼5:9£ €i0a
 ;Å£”˜\pºi ‘	9–¹tÕAHTŒŒéU—37kÌæV–ÈZm2Õ\-ãDY¸qøä4
òÖò@S1"’
¢/ó*OVxÑH¡Mh(v$M j6H®…Ì¥>Í_ÊÐÍÐœ@°…~É@SÑC!´ŽQd¥¸€ÈÓˆˆ:!–X1Ea$(±Kš„åmàª‡„1”†E$uÁhë Y‡S ¢x™X›¥Ê„§ÐŒˆNYá¡:µLAMEp}>lãän,þqªjfŠždAa9XjidcðxzzB3áD¦”šR,À	:¢D¨1 	#2ÌÎ‚4ÒáIºH* Ñ%;0W8(ˆ\E¶^01‡ë HDkÉ™BåëY¦IÂ· y€ ¡qŒñ¬14Ç2‹3	<|™®Ò!@¾˜²—á²ÀW1·8.‰@	P¸á›!™àŒ"bÔ2H‚Ñ¡äÆS`ŒYÉvb†Yo%0	UH!`#@šÃ=„‹Á7Dy}L0$e£Ž
›Æ±c*™ &\‰B“TƒÿóäÄûsÄ9ÀHî²T p¢¥Ïªö*™I²DSOHR#Ä‰¤¯€hia¢´†…`‚H˜¥KÔ<¨°ÆN‘h`ôgQ-)…¡
À©j¢!rK–]LH“JÅî]ô4DáaÄ­Q4Ä„R–p‰Eè\„´ñ Ç“’#èÀƒ',Û4–«°±€CYfàlÀÌK…ƒ(	4L ‹ÌèÆ¤ŠÈ,i¥b/øò¥¤]#)# (i¤(=v°&À4ÁÄ‰]z˜"¢"(¡l‘Y­a D(JÐàââ1†‚1ªa#&B3*9<°0£ 
ž1få©ƒ f©“ àRt d’ÆŒ¿ ¨.Í@t& ¦S©>mž¬è˜ñ¥³;M¶la ˜Dƒ†"D…æD„K˜/ðŽ4ª˜’ðÈ4á*yÕ1¹02#›”Ÿ Ð„¥E$Æ8‹teäe€ ÍVÌ´XÐQ3HctRÁ¡œD¸.ã<ã_²,	¸m²¡é”	”À ED=Zh,˜€e+"ù5ÐF‘íy Fp Œ(€T Q)Ì…“œÏ$,ZZ€L	XHÒÿóäÄÿxœ9¼ ÷2(é~“å*ÑÜd.3xJ(@B¥©Š¶+b2@I ŠëMÜ`¨FÑÁ!XˆRá‚@x@Î¨)²¨f ¡Ë¡ `D 1Á„h2È±…×°Š¬ ¢fM"†Æ	±ÉF-Ð9È€Ö0i4D DÃEC‘0$\©KÐ0HH
ž2QtMPÁH‡$ì/nÒøÆÔÔ%5E®´ód(Y¢Â‘"„ ñ†	1—Ð,WÑÎð1ÌÅšz°¾ácX9PQPÛp±ö*»LÐw  Œ•Ä›6v
L¼h©Ê16cSX‡2Ò3_¾P44– Ò'3‚Œš:Oë˜ã ™žqˆ"}£ðèâHoH´fŒ'Dç1—B€NÛE0117™€11tõÁÁä¦ú=ê†ˆ1€-q Áœà‡ à,P„\À 	j]’IAB0¸awƒ%Ð†Êä”33<3 B¢GÀ
0b¸yœ-À²¦&3AÅ 2ˆLP)¤ÃRèÊ½€Ð ³ÈO0ÁH3k1‚p€¸ (Pi’/· êTƒƒ	@¡«µÐÿóäÄïvd9¼ ÷2c `®`  ˜à¤ÒT²”®Ig]Þ<¤©º
ÚàFBÀL‚zgìTS ¸¨þ‚Tßp,  Iä–iåC†ÁSö“N§’¹‘)[ð(Å)LP˜„  CÖ¡ÍŒ N¤#ˆ+VvXhg áÁÂˆPBh)2ú$#-ß-HG€ ð%Ø É)E0\ZPRÄ e†l*
éDjn¢ÃËL‹&¡Àè€Ç˜ #œ`° ›‚Ys˜ÁEÆ2‡-p‰F¼”i‚r–ž£X„:ýNh"^*¼È ÃD¥M*DŒÄBÌ‡(ÆÐ¬À#Œ p„ T`æåXŒà!g–ŽŒ6ƒ`ÀrÈºÎL¬38Åº   "š,Zq´±dRÆèHÌ@…¹ P”aƒ5é¸˜ñÆyÙ28ràJ†BaÎD£XE e ‚ÆBùf€EÊ€.dÎ‚S!°4†ðÀ¦N!GÅTÀ ˆDˆ_F:Æ{É„FÙþ
 YR@h²¢[®Öž” AŽ…Ap”„ÀQFÈ¡)IšóEÖ1ÿóäÄèxä9¸(ö²| ¢h€fŠ^R¨aÀ"ˆÈv2…Ü-Yx†KI°±¢‚\ÅÖ¢åŸ ‘ÁÆ¯æpˆ'ªÌaš	“J1wKB
R‚yÈ‘VÓæbd€ÜP€$Å  ¡&X%ç.XT1	 ¦ 4i1]}ZùwŒÌ\Ç	ãløn	–%˜Bp$D„5 ÓÞH
| !3Ä'I0·"`.šÜiÈØ‹(à]Ñ§E£^‘k,øái&‡ÍQ Ç‘/ë”ÕÊŽ
4
Œ­q/ Î¨°Âbë»"Ý
&ëX­ `Lè»Â Øêô8²Š‚X8j; ƒ¤!3¯Oî0GAŠ0ó$TÊ$b#V¦"A
)TjF™Ãàfƒ@! ˆU”I3"ÕJaŒÑÁŒj³v³VPFhÅ`@·>™ ¯’€B”&R¤ä–ç³`A#f‡ˆ|Î”’Ò™±„ÙDáÐ‘	ÎË9x°°ÄF‡m g>$9eÆ‰15 (©q@Ç•X%1™Q„2-"ÁÈ@
LÈ:LH‰T$¨b3ƒ—ìei*“1–ÿóäÄ×sì9À2ö²8–hÀEÌ‘©™jÂ»*Â£ÂC-Ð ¼¦1Nêx¤¨3Ôã1ˆ”0åi@ …–Ö’ »Èû@B¨`%Bä:ÂØ–Ü¼ÈÆ,P³gÖ2¡â©¨B	Xá!jnƒL‘µ†L`Û:À).K 2ÅÔ IëT}\§€Ö –,ÉJäÅ	g²"‹è™f0Cª^¾ŽH,±FÎÞtÙ, ¿€¥‘HIRý40°%ìLS0€Ç‹ä™%.¦&Ž
tZ²L©|Ý‡ÍÎUF^§AƒƒŠ/®ÙÊ‡…BkGd2¤µ`¥ûKæDØC.8‡6˜|3€M1H‚2(	^æh2,ˆ  °Žƒp 	ÌÌ ÁA`-Àˆ@€@ð&J…AÐ4F .BÂ@3:ŒÀÂð@À†}©\f
bÈÌÀ	q§&D*5E *…ÈR€dˆr„e‹ XgÀfD¸Pp P€@¨@(6²‰¥d”ÌÁ‘D´c
0ELù0åB¤ˆ'!ÍŒIs
Ë
`È—!#Ã‹˜ 1€`L™˜bÆŒPa S0QœÿóäÄÚ}„9È]Ð $d¸@1€¦Tébà†=h´s<˜Yá¦ˆkœ  Æ‰1‚cË¦à@t£B¤Ø"Lp²€…®&©ÄC®² †lù`5Ài‘ei·_Ð°'èˆÍ ÅÄo ‰N@”8`tÔXeA†1‰…KŽ0‡áƒ‰ I~ˆh@0BÃ…CƒK@È-šsƒCBÖÂs‚€#ˆ4©‹˜ ¢ËQZÌU²Ã
µÕ*P(/7<¢‹_ö|’;¦"í‡£Z;5”(«JB5žH¬3ƒ  D	IµvHÔŒ(0¤ÏpÔjHT±JõDÈÝÅð§Ðu¨@eái pƒƒ>Ã@ƒ	ó0@\4˜l ¨tƒí 00Œ0„).rçH*Ë 3I'’%j¨˜r áf($:qób1ˆt56s¶œhÍ_…ÀÊÉ‰¬) ƒˆÀ¢.LÉB-ÌÀUZÌŠÀÊÀ…ŒÁÃVÇ@7nœîþT¦²Y¨8‚Îªª`g“°:5Ç‚ÃÌ¸óX@¶@bÚ³³•ÉÿóäÄ·z¤9Ü	Ð 63TY<”AënH^†" ÓPÃ›3àÌI“7LÑ9Š ¯p &-1¦f%DÏÄ3Í‚U7"\ DÀ°¾*RÓ)Pñ/×ã+EQÖ\‡4ÅÑE˜!Ÿ " `‘ƒžÈ$@„ prÑÈ0e‹A8ê$jË6VA¦c/cðæ$)#”"@ÂmÁ@À
`€>ª™ƒ§‘±PcLš–U‚ÄÌ!æ0ûÎa‰9d…•a°!…×EEPD‰¨\Ê”¸i9›r/ì4žpB¦}“-A }ƒ¬1ˆÝ›@@„]!Á@šÉ‘bB¯#"4—™1 `j^^h$¬³,Í	qª¤a‡bÂ!8Áš*^‘‚£ ™¥^ÃLÌx,ÆÐÈÀMd°ÇÁC"dJgæ
@
„¦dBÉL$H¨ @zš,9 aa	šC¢†hÃÔç;5Ì³0ŠÇ#I°bÁ‚3FDÀpUQ¸jŽâ!F|1‚*8XÈ‡7Â¢LÑ44`šb©Ð]äS2jysŒä²‚`ä	ŒQâ©êaŒLÿóäÄŸ{ô9¸#ÛÐ e…„0l
ÀD°sDÒ75_ñA¾°‚n
…†›a@…ê0¥@Ìpr,6j‡
2AL+B-F„‘ˆZÕÇ  3¥’¸Â˜,žb0B¢EŽ˜0C‚Cƒ4ƒ18’8ÀŽ3"ÂÂ@ËŠA
øTÀ¡@B˜2R˜ !qE§’,ƒÉ’@Î”/:$‰™‚¢1nSåh®(d£j
\Î„ Â ®Ôü1!	A‡ 2$*K’Y(0`’éÙ^(¬­È.ªØVuliä"ƒ ‹5Ñ “0* dx(Ð0”!Ì0l>§’<ÊkÅ¦t@¢’½˜ Z¡Še‡/0R:’a­Ù‡)öuËjŒË½;d¼ÉÎ„Â€j ŒIð9 @À¬R:è ëDTÏ|]®iÙ€Cd>l		‡!ÆÖ3PÌ«4Ž0I@EîA]À±™ÂÚ+h\Ba~Ã[”ÜWmGVÔ'
ˆT((‰hBZà@ÅH*4ÇO|ÁX’b–è(‘`!:-wqë_I’BP&šèbð-–‘©L²{‰„Å¥¯óR•:vé)]äU˜	P³I„ÿóäÄ‚aü9\¬Öpõ0nkH(0l2IPA‹¶¥ŒÄvÝWmÍV$}-° Ûl’¡Dýaú‡¨APÍ^6Ó3ÓYnÎÜž[zU†ä‰/p„P¤b§ 8äÀ@äÁS”¾ÚÃ¶ð7vàé½.“‚é:,©4Ph€dOF·XrT Ñ ÉžŒ® ú¬2Df IP¨LXîä••#hèB¥kQ©<¯3%@!tÔ2Rþ'ZÔmÞH~!$ÆFò°d‰-Ð€åT	ÕãŸÀ9R¥J³-6¸ëÀ’ù§Õ¸½Ü²Ž–uw#ÉyQÙYÙã=R °D,™#Â‚E6ÿ½Kå7’}EØcÿ(¡A°þLAME3.100ªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªPK     S%W]uHù+  +  J  client/src/Testing/Responses/Fixtures/Audio/TranslationResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Audio;

final class TranslationResponseFixture
{
    public const ATTRIBUTES = [
        'task'     => 'translate',
        'language' => 'english',
        'duration' => 2.95,
        'segments' => [
            [
                'id'     => 0,
                'seek'   => 0,
                'start'  => 0.0,
                'end'    => 4.0,
                'text'   => ' Hello, this is a fake translation response.',
                'tokens' => [
                    50364,
                    2425,
                    11,
                    577,
                    366,
                    291,
                    30,
                    50564,
                ],
                'temperature'       => 0.0,
                'avg_logprob'       => -0.45045216878255206,
                'compression_ratio' => 0.7037037037037037,
                'no_speech_prob'    => 0.1076972484588623,
                'transient'         => false,
            ],
        ],
        'text' => 'Hello, how are you?',
    ];
}
PK     S%W]×*¥·0  0  L  client/src/Testing/Responses/Fixtures/Audio/TranscriptionResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Audio;

final class TranscriptionResponseFixture
{
    public const ATTRIBUTES = [
        'task'     => 'transcribe',
        'language' => 'english',
        'duration' => 2.95,
        'segments' => [
            [
                'id'     => 0,
                'seek'   => 0,
                'start'  => 0.0,
                'end'    => 4.0,
                'text'   => ' Hello, this is a fake transcription response.',
                'tokens' => [
                    50364,
                    2425,
                    11,
                    577,
                    366,
                    291,
                    30,
                    50564,
                ],
                'temperature'       => 0.0,
                'avg_logprob'       => -0.45045216878255206,
                'compression_ratio' => 0.7037037037037037,
                'no_speech_prob'    => 0.1076972484588623,
                'transient'         => false,
            ],
        ],
        'text' => 'Hello, how are you?',
    ];
}
PK     S%W]ºÚ¬
  
  M  client/src/Testing/Responses/Fixtures/Threads/ThreadDeleteResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Threads;

final class ThreadDeleteResponseFixture
{
    public const ATTRIBUTES = [
        'id'      => 'thread_agvtHUGezjTCt4SKgQg0NJ2Y',
        'object'  => 'thread.deleted',
        'deleted' => true,
    ];
}
PK     S%W]ðÀ*  *  G  client/src/Testing/Responses/Fixtures/Threads/ThreadResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Threads;

final class ThreadResponseFixture
{
    public const ATTRIBUTES = [
        'id'         => 'thread_agvtHUGezjTCt4SKgQg0NJ2Y',
        'object'     => 'thread',
        'created_at' => 1_699_621_778,
        'metadata'   => [],
    ];
}
PK     S%W]’vµE  E  Y  client/src/Testing/Responses/Fixtures/Threads/Runs/Steps/ThreadRunStepResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Threads\Runs\Steps;

final class ThreadRunStepResponseFixture
{
    public const ATTRIBUTES = [
        'id'           => 'step_1spQXgbAabXFm1YXrwiGIMUz',
        'object'       => 'thread.run.step',
        'created_at'   => 1_699_564_106,
        'run_id'       => 'run_fYijubpOJsKDnvtACWBS8C8r',
        'assistant_id' => 'asst_EopvUEMh90bxkNRYEYM81Orc',
        'thread_id'    => 'thread_3WdOgtVuhD8aUIEx774Whkvo',
        'type'         => 'message_creation',
        'status'       => 'completed',
        'cancelled_at' => null,
        'completed_at' => 1_699_564_119,
        'expires_at'   => null,
        'failed_at'    => null,
        'last_error'   => null,
        'step_details' => [
            'type'             => 'message_creation',
            'message_creation' => [
                'message_id' => 'msg_i404PxKbB92d0JAmdOIcX7vA',
            ],
        ],
        'usage' => [
            'prompt_tokens'     => 123,
            'completion_tokens' => 456,
            'total_tokens'      => 579,
        ],
    ];
}
PK     S%W]‹ßî  î  ]  client/src/Testing/Responses/Fixtures/Threads/Runs/Steps/ThreadRunStepListResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Threads\Runs\Steps;

final class ThreadRunStepListResponseFixture
{
    public const ATTRIBUTES = [
        'object' => 'list',
        'data'   => [
            [
                'id'           => 'step_1spQXgbAabXFm1YXrwiGIMUz',
                'object'       => 'thread.run.step',
                'created_at'   => 1_699_564_106,
                'run_id'       => 'run_fYijubpOJsKDnvtACWBS8C8r',
                'assistant_id' => 'asst_EopvUEMh90bxkNRYEYM81Orc',
                'thread_id'    => 'thread_3WdOgtVuhD8aUIEx774Whkvo',
                'type'         => 'message_creation',
                'status'       => 'completed',
                'cancelled_at' => null,
                'completed_at' => 1_699_564_119,
                'expires_at'   => null,
                'failed_at'    => null,
                'last_error'   => null,
                'step_details' => [
                    'type'             => 'message_creation',
                    'message_creation' => [
                        'message_id' => 'msg_i404PxKbB92d0JAmdOIcX7vA',
                    ],
                ],
                'usage' => [
                    'prompt_tokens'     => 123,
                    'completion_tokens' => 456,
                    'total_tokens'      => 579,
                ],
            ],
        ],
        'first_id' => 'step_1spQXgbAabXFm1YXrwiGIMUz',
        'last_id'  => 'step_1spQXgbAabXFm1YXrwiGIMUz',
        'has_more' => false,
    ];
}
PK     S%W]K>óçl%  l%  U  client/src/Testing/Responses/Fixtures/Threads/Runs/ThreadRunStreamResponseFixture.txtnu „[µü¤        event: thread.created
data: {"id":"thread_sSbvUX4J1FqlUZBv6BaBbOj4","object":"thread","created_at":1720104398,"metadata":{"user":"John Doe"},"tool_resources":{"code_interpreter":{"file_ids":[]}}}
event: thread.run.created
data: {"id":"run_s1X8yAjuUBlwhGrqiahzfnH7","object":"thread.run","created_at":1720104398,"assistant_id":"asst_JA9Pc6eQ744nbec10slSz5BU","thread_id":"thread_sSbvUX4J1FqlUZBv6BaBbOj4","status":"queued","started_at ":null,"expires_at ":1720104998,"cancelled_at ":null,"failed_at ":null,"completed_at ":null,"required_action ":null,"last_error ":null,"model":"gpt-4 o","instructions":"You are a very useful assistant","tools":[{"type":"code_interpreter"},{"type":"file_search","file_search":{"max_num_results":50}},{"type":"function","function":{"name":"get_weather","description":"Determine weather in my location","parameters":{"type":"object","properties":{"location":{"type":"string","description":"The city and state e.g. San Francisco, CA"},"unit":{"type":"string","enum":["c","f"]}},"required":["location"]}}}],"tool_resources":{"code_interpreter":{"file_ids":[]}},"metadata":{"user":"John Doe"},"temperature":0.7,"top_p":1.0,"max_completion_tokens":null,"max_prompt_tokens":null,"truncation_strategy":{"type":"auto","last_messages":null},"incomplete_details":null,"usage":null,"response_format":"auto","tool_choice":"auto","parallel_tool_calls":true}
event: thread.run.queued
data: {"id":"run_s1X8yAjuUBlwhGrqiahzfnH7","object":"thread.run","created_at":1720104398,"assistant_id":"asst_JA9Pc6eQ744nbec10slSz5BU","thread_id":"thread_sSbvUX4J1FqlUZBv6BaBbOj4","status":"queued","started_at":null,"expires_at":1720104998,"cancelled_at":null,"failed_at":null,"completed_at":null,"required_action":null,"last_error":null,"model":"gpt-4o","instructions":"You are a very useful assistant.","tools":[{"type":"code_interpreter"},{"type":"file_search","file_search":{"max_num_results":50}},{"type":"function","function":{"name":"get_weather","description":"Determine weather in my location","parameters":{"type":"object","properties":{"location":{"type":"string","description":"The city and state e.g. San Francisco, CA"},"unit":{"type":"string","enum":["c","f"]}},"required":["location"]}}}],"tool_resources":{"code_interpreter":{"file_ids":[]}},"metadata":{"user":"John Doe"},"temperature":0.7,"top_p":1.0,"max_completion_tokens":null,"max_prompt_tokens":null,"truncation_strategy":{"type":"auto","last_messages":null},"incomplete_details":null,"usage":null,"response_format":"auto","tool_choice":"auto","parallel_tool_calls":true}
event: thread.run.in_progress
data: {"id":"run_s1X8yAjuUBlwhGrqiahzfnH7","object":"thread.run","created_at":1720104398,"assistant_id":"asst_JA9Pc6eQ744nbec10slSz5BU","thread_id":"thread_sSbvUX4J1FqlUZBv6BaBbOj4","status":"in_progress","started_at":1720104398,"expires_at":1720104998,"cancelled_at":null,"failed_at":null,"completed_at":null,"required_action":null,"last_error":null,"model":"gpt-4o","instructions":"You are a very useful assistant.","tools":[{"type":"code_interpreter"},{"type":"file_search","file_search":{"max_num_results":50}},{"type":"function","function":{"name":"get_weather","description":"Determine weather in my location","parameters":{"type":"object","properties":{"location":{"type":"string","description":"The city and state e.g. San Francisco, CA"},"unit":{"type":"string","enum":["c","f"]}},"required":["location"]}}}],"tool_resources":{"code_interpreter":{"file_ids":[]}},"metadata":{"user":"John Doe"},"temperature":0.7,"top_p":1.0,"max_completion_tokens":null,"max_prompt_tokens":null,"truncation_strategy":{"type":"auto","last_messages":null},"incomplete_details":null,"usage":null,"response_format":"auto","tool_choice":"auto","parallel_tool_calls":true}
event: thread.run.step.created
data: {"id":"step_3P1u5J5Rs95lypEfvQ3rMdPL","object":"thread.run.step","created_at":1720104399,"run_id":"run_s1X8yAjuUBlwhGrqiahzfnH7","assistant_id":"asst_JA9Pc6eQ744nbec10slSz5BU","thread_id":"thread_sSbvUX4J1FqlUZBv6BaBbOj4","type":"message_creation","status":"in_progress","cancelled_at":null,"completed_at":null,"expires_at":1720104998,"failed_at":null,"last_error":null,"step_details":{"type":"message_creation","message_creation":{"message_id":"msg_zKgPBqNcqb7qYP2bBA3tVyTd"}},"usage":null}
event: thread.run.step.in_progress
data: {"id":"step_3P1u5J5Rs95lypEfvQ3rMdPL","object":"thread.run.step","created_at":1720104399,"run_id":"run_s1X8yAjuUBlwhGrqiahzfnH7","assistant_id":"asst_JA9Pc6eQ744nbec10slSz5BU","thread_id":"thread_sSbvUX4J1FqlUZBv6BaBbOj4","type":"message_creation","status":"in_progress","cancelled_at":null,"completed_at":null,"expires_at":1720104998,"failed_at":null,"last_error":null,"step_details":{"type":"message_creation","message_creation":{"message_id":"msg_zKgPBqNcqb7qYP2bBA3tVyTd"}},"usage":null}
event: thread.message.created
data: {"id":"msg_zKgPBqNcqb7qYP2bBA3tVyTd","object":"thread.message","created_at":1720104399,"assistant_id":"asst_JA9Pc6eQ744nbec10slSz5BU","thread_id":"thread_sSbvUX4J1FqlUZBv6BaBbOj4","run_id":"run_s1X8yAjuUBlwhGrqiahzfnH7","status":"in_progress","incomplete_details":null,"incomplete_at":null,"completed_at":null,"role":"assistant","content":[],"attachments":[],"metadata":{}}
event: thread.message.in_progress
data: {"id":"msg_zKgPBqNcqb7qYP2bBA3tVyTd","object":"thread.message","created_at":1720104399,"assistant_id":"asst_JA9Pc6eQ744nbec10slSz5BU","thread_id":"thread_sSbvUX4J1FqlUZBv6BaBbOj4","run_id":"run_s1X8yAjuUBlwhGrqiahzfnH7","status":"in_progress","incomplete_details":null,"incomplete_at":null,"completed_at":null,"role":"assistant","content":[],"attachments":[],"metadata":{}}
event: thread.message.delta
data: {"id":"msg_zKgPBqNcqb7qYP2bBA3tVyTd","object":"thread.message.delta","delta":{"content":[{"index":0,"type":"text","text":{"value":"Hello","annotations":[]}}]}}
event: thread.message.delta
data: {"id":"msg_zKgPBqNcqb7qYP2bBA3tVyTd","object":"thread.message.delta","delta":{"content":[{"index":0,"type":"text","text":{"value":"!"}}]}}
event: thread.message.delta
data: {"id":"msg_zKgPBqNcqb7qYP2bBA3tVyTd","object":"thread.message.delta","delta":{"content":[{"index":0,"type":"text","text":{"value":" How"}}]}}
event: thread.message.delta
data: {"id":"msg_zKgPBqNcqb7qYP2bBA3tVyTd","object":"thread.message.delta","delta":{"content":[{"index":0,"type":"text","text":{"value":" can"}}]}}
event: thread.message.delta
data: {"id":"msg_zKgPBqNcqb7qYP2bBA3tVyTd","object":"thread.message.delta","delta":{"content":[{"index":0,"type":"text","text":{"value":" I"}}]}}
event: thread.message.delta
data: {"id":"msg_zKgPBqNcqb7qYP2bBA3tVyTd","object":"thread.message.delta","delta":{"content":[{"index":0,"type":"text","text":{"value":" assist"}}]}}
event: thread.message.delta
data: {"id":"msg_zKgPBqNcqb7qYP2bBA3tVyTd","object":"thread.message.delta","delta":{"content":[{"index":0,"type":"text","text":{"value":" you"}}]}}
event: thread.message.delta
data: {"id":"msg_zKgPBqNcqb7qYP2bBA3tVyTd","object":"thread.message.delta","delta":{"content":[{"index":0,"type":"text","text":{"value":" today"}}]}}
event: thread.message.delta
data: {"id":"msg_zKgPBqNcqb7qYP2bBA3tVyTd","object":"thread.message.delta","delta":{"content":[{"index":0,"type":"text","text":{"value":"?"}}]}}
event: thread.message.completed
data: {"id":"msg_zKgPBqNcqb7qYP2bBA3tVyTd","object":"thread.message","created_at":1720104399,"assistant_id":"asst_JA9Pc6eQ744nbec10slSz5BU","thread_id":"thread_sSbvUX4J1FqlUZBv6BaBbOj4","run_id":"run_s1X8yAjuUBlwhGrqiahzfnH7","status":"completed","incomplete_details":null,"incomplete_at":null,"completed_at":1720104399,"role":"assistant","content":[{"type":"text","text":{"value":"Hello! How can I assist you today?","annotations":[]}}],"attachments":[],"metadata":{}}
event: thread.run.step.completed
data: {"id":"step_3P1u5J5Rs95lypEfvQ3rMdPL","object":"thread.run.step","created_at":1720104399,"run_id":"run_s1X8yAjuUBlwhGrqiahzfnH7","assistant_id":"asst_JA9Pc6eQ744nbec10slSz5BU","thread_id":"thread_sSbvUX4J1FqlUZBv6BaBbOj4","type":"message_creation","status":"completed","cancelled_at":null,"completed_at":1720104399,"expires_at":1720104998,"failed_at":null,"last_error":null,"step_details":{"type":"message_creation","message_creation":{"message_id":"msg_zKgPBqNcqb7qYP2bBA3tVyTd"}},"usage":{"prompt_tokens":1138,"completion_tokens":11,"total_tokens":1149}}
event: thread.run.completed
data: {"id":"run_s1X8yAjuUBlwhGrqiahzfnH7","object":"thread.run","created_at":1720104398,"assistant_id":"asst_JA9Pc6eQ744nbec10slSz5BU","thread_id":"thread_sSbvUX4J1FqlUZBv6BaBbOj4","status":"completed","started_at":1720104398,"expires_at":null,"cancelled_at":null,"failed_at":null,"completed_at":1720104399,"required_action":null,"last_error":null,"model":"gpt-4o","instructions":"You are a very useful assistant.","tools":[{"type":"code_interpreter"},{"type":"file_search","file_search":{"max_num_results":50}},{"type":"function","function":{"name":"get_weather","description":"Determine weather in my location","parameters":{"type":"object","properties":{"location":{"type":"string","description":"The city and state e.g. San Francisco, CA"},"unit":{"type":"string","enum":["c","f"]}},"required":["location"]}}}],"tool_resources":{"code_interpreter":{"file_ids":[]}},"metadata":{"user":"John Doe"},"temperature":0.7,"top_p":1.0,"max_completion_tokens":null,"max_prompt_tokens":null,"truncation_strategy":{"type":"auto","last_messages":null},"incomplete_details":null,"usage":{"prompt_tokens":1138,"completion_tokens":11,"total_tokens":1149},"response_format":"auto","tool_choice":"auto","parallel_tool_calls":true}
event: done
PK     S%W]x”¬×  ×  O  client/src/Testing/Responses/Fixtures/Threads/Runs/ThreadRunResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Threads\Runs;

final class ThreadRunResponseFixture
{
    public const ATTRIBUTES = [
        'id'           => 'run_4RCYyYzX9m41WQicoJtUQAb8',
        'object'       => 'thread.run',
        'created_at'   => 1_699_621_735,
        'assistant_id' => 'asst_EopvUEMh90bxkNRYEYM81Orc',
        'thread_id'    => 'thread_EKt7MjGOC6bwKWmenQv5VD6r',
        'status'       => 'queued',
        'started_at'   => null,
        'expires_at'   => 1_699_622_335,
        'cancelled_at' => null,
        'failed_at'    => null,
        'completed_at' => null,
        'last_error'   => null,
        'model'        => 'gpt-4',
        'instructions' => 'You are a personal math tutor. When asked a question, write and run Python code to answer the question.',
        'tools'        => [
            [
                'type' => 'code_interpreter',
            ],
        ],
        'metadata' => [],
        'usage'    => [
            'prompt_tokens'     => 5,
            'completion_tokens' => 7,
            'total_tokens'      => 12,
        ],
        'incomplete_details'    => null,
        'temperature'           => 1,
        'top_p'                 => 1,
        'max_prompt_tokens'     => 600,
        'max_completion_tokens' => 500,
        'truncation_strategy'   => [
            'type'          => 'auto',
            'last_messages' => null,
        ],
        'tool_choice'     => 'none',
        'response_format' => 'auto',
    ];
}
PK     S%W]·ÛÎî-  -  S  client/src/Testing/Responses/Fixtures/Threads/Runs/ThreadRunListResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Threads\Runs;

final class ThreadRunListResponseFixture
{
    public const ATTRIBUTES = [
        'object' => 'list',
        'data'   => [
            [
                'id'           => 'run_4RCYyYzX9m41WQicoJtUQAb8',
                'object'       => 'thread.run',
                'created_at'   => 1_699_621_735,
                'assistant_id' => 'asst_EopvUEMh90bxkNRYEYM81Orc',
                'thread_id'    => 'thread_EKt7MjGOC6bwKWmenQv5VD6r',
                'status'       => 'queued',
                'started_at'   => null,
                'expires_at'   => 1_699_622_335,
                'cancelled_at' => null,
                'failed_at'    => null,
                'completed_at' => null,
                'last_error'   => null,
                'model'        => 'gpt-4',
                'instructions' => 'You are a personal math tutor. When asked a question, write and run Python code to answer the question.',
                'tools'        => [
                    [
                        'type' => 'code_interpreter',
                    ],
                ],
                'metadata'              => [],
                'incomplete_details'    => null,
                'temperature'           => 1,
                'top_p'                 => 1,
                'max_prompt_tokens'     => 600,
                'max_completion_tokens' => 500,
                'truncation_strategy'   => [
                    'type'          => 'auto',
                    'last_messages' => null,
                ],
                'tool_choice'     => 'none',
                'response_format' => 'auto',
            ],
        ],
        'first_id' => 'run_4RCYyYzX9m41WQicoJtUQAb8',
        'last_id'  => 'run_4RCYyYzX9m41WQicoJtUQAb8',
        'has_more' => false,
    ];
}
PK     S%W]VOg(V  V  [  client/src/Testing/Responses/Fixtures/Threads/Messages/ThreadMessageListResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Threads\Messages;

final class ThreadMessageListResponseFixture
{
    public const ATTRIBUTES = [
        'object' => 'list',
        'data'   => [
            [
                'id'                 => 'msg_KNsDDwE41BUAHhcPNpDkdHWZ',
                'object'             => 'thread.message',
                'created_at'         => 1_699_623_839,
                'thread_id'          => 'thread_agvtHUGezjTCt4SKgQg0NJ2Y',
                'status'             => 'in_progress',
                'incomplete_details' => null,
                'completed_at'       => null,
                'incomplete_at'      => null,
                'role'               => 'user',
                'content'            => [
                    [
                        'type' => 'text',
                        'text' => [
                            'value'       => 'How does AI work? Explain it in simple terms.',
                            'annotations' => [
                            ],
                        ],
                    ],
                ],
                'attachments' => [
                    [
                        'file_id' => 'file-DhxjnFCaSHc4ZELRGKwTMFtI',
                        'tools'   => [['type' => 'file_search']],
                    ],
                ],
                'assistant_id' => null,
                'run_id'       => null,
                'metadata'     => [],
            ],
        ],
        'first_id' => 'msg_KNsDDwE41BUAHhcPNpDkdHWZ',
        'last_id'  => 'msg_KNsDDwE41BUAHhcPNpDkdHWZ',
        'has_more' => false,
    ];
}
PK     S%W] ahY    ]  client/src/Testing/Responses/Fixtures/Threads/Messages/ThreadMessageDeleteResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Threads\Messages;

final class ThreadMessageDeleteResponseFixture
{
    public const ATTRIBUTES = [
        'id'      => 'msg_KNsDDwE41BUAHhcPNpDkdHWZ',
        'object'  => 'thread.message.deleted',
        'deleted' => true,
    ];
}
PK     S%W]ÈÞ<ä    W  client/src/Testing/Responses/Fixtures/Threads/Messages/ThreadMessageResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Threads\Messages;

final class ThreadMessageResponseFixture
{
    public const ATTRIBUTES = [
        'id'                 => 'msg_KNsDDwE41BUAHhcPNpDkdHWZ',
        'object'             => 'thread.message',
        'created_at'         => 1_699_623_839,
        'thread_id'          => 'thread_agvtHUGezjTCt4SKgQg0NJ2Y',
        'status'             => 'in_progress',
        'incomplete_details' => null,
        'completed_at'       => null,
        'incomplete_at'      => null,
        'role'               => 'user',
        'content'            => [
            [
                'type' => 'text',
                'text' => [
                    'value'       => 'How does AI work? Explain it in simple terms.',
                    'annotations' => [
                    ],
                ],
            ],
        ],
        'attachments' => [
            [
                'file_id' => 'file-DhxjnFCaSHc4ZELRGKwTMFtI',
                'tools'   => [['type' => 'file_search']],
            ],
        ],
        'assistant_id' => null,
        'run_id'       => null,
        'metadata'     => [],
    ];
}
PK     S%W]Ò8éÉC  C  J  client/src/Testing/Responses/Fixtures/Batches/BatchListResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Batches;

final class BatchListResponseFixture
{
    public const ATTRIBUTES = [
        'object' => 'list',
        'data'   => [
            [
                'id'                => 'batch_abc123',
                'object'            => 'batch',
                'endpoint'          => '/v1/chat/completions',
                'errors'            => null,
                'input_file_id'     => 'file-abc123',
                'completion_window' => '24h',
                'status'            => 'completed',
                'output_file_id'    => 'file-cvaTdG',
                'error_file_id'     => 'file-HOWS94',
                'created_at'        => 1_711_471_533,
                'in_progress_at'    => 1_711_471_538,
                'expires_at'        => 1_711_557_933,
                'finalizing_at'     => 1_711_493_133,
                'completed_at'      => 1_711_493_163,
                'failed_at'         => null,
                'expired_at'        => null,
                'cancelling_at'     => null,
                'cancelled_at'      => null,
                'request_counts'    => [
                    'total'     => 100,
                    'completed' => 95,
                    'failed'    => 5,
                ],
                'metadata' => [
                    'customer_id'       => 'user_123456789',
                    'batch_description' => 'Nightly job',
                ],
            ],
        ],
        'first_id' => 'batch_abc123',
        'last_id'  => 'batch_abc456',
        'has_more' => true,
    ];
}
PK     S%W]Þk†r  r  F  client/src/Testing/Responses/Fixtures/Batches/BatchResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Batches;

final class BatchResponseFixture
{
    public const ATTRIBUTES = [
        'id'                => 'batch_abc123',
        'object'            => 'batch',
        'endpoint'          => '/v1/chat/completions',
        'errors'            => null,
        'input_file_id'     => 'file-abc123',
        'completion_window' => '24h',
        'status'            => 'validating',
        'output_file_id'    => null,
        'error_file_id'     => null,
        'created_at'        => 1_711_471_533,
        'in_progress_at'    => null,
        'expires_at'        => null,
        'finalizing_at'     => null,
        'completed_at'      => null,
        'failed_at'         => null,
        'expired_at'        => null,
        'cancelling_at'     => null,
        'cancelled_at'      => null,
        'request_counts'    => [
            'total'     => 0,
            'completed' => 0,
            'failed'    => 0,
        ],
        'metadata' => [
            'customer_id'       => 'user_123456789',
            'batch_description' => 'Nightly eval job',
        ],
    ];
}
PK     S%W]Õÿ§Æ    H  client/src/Testing/Responses/Fixtures/Models/RetrieveResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Models;

final class RetrieveResponseFixture
{
    public const ATTRIBUTES = [
        'id'       => 'text-babbage:001',
        'object'   => 'model',
        'created'  => 1_642_018_370,
        'owned_by' => 'openai',
    ];
}
PK     S%W]§åýþ   þ   F  client/src/Testing/Responses/Fixtures/Models/DeleteResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Models;

final class DeleteResponseFixture
{
    public const ATTRIBUTES = [
        'id'      => 'curie:ft-acmeco-2021-03-03-21-44-20',
        'object'  => 'model',
        'deleted' => true,
    ];
}
PK     S%W]¶?Ëõ   õ   D  client/src/Testing/Responses/Fixtures/Models/ListResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Models;

final class ListResponseFixture
{
    public const ATTRIBUTES = [
        'object' => 'list',
        'data'   => [
            RetrieveResponseFixture::ATTRIBUTES,
        ],
    ];
}
PK     S%W]äŸ£Ö  Ö  E  client/src/Testing/Responses/Fixtures/Edits/CreateResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Edits;

final class CreateResponseFixture
{
    public const ATTRIBUTES = [
        'object'  => 'edit',
        'created' => 1_664_135_921,
        'choices' => [[
            'text'  => "This is a fake edit response.\n",
            'index' => 0,
        ]],
        'usage' => [
            'prompt_tokens'     => 25,
            'completion_tokens' => 30,
            'total_tokens'      => 55,
        ],
    ];
}
PK     S%W]ºš‘Û  Û  K  client/src/Testing/Responses/Fixtures/Completions/CreateResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Completions;

final class CreateResponseFixture
{
    public const ATTRIBUTES = [
        'id'      => 'cmpl-uqkvlQyYK7bGYrRHQ0eXlWi7',
        'object'  => 'text_completion',
        'created' => 1_589_478_378,
        'model'   => 'gpt-3.5-turbo-instruct',
        'choices' => [
            [
                'text'          => "\n\nThis is a fake completion response.",
                'index'         => 0,
                'logprobs'      => null,
                'finish_reason' => 'length',
            ],
        ],
        'usage' => [
            'prompt_tokens'     => 5,
            'completion_tokens' => 7,
            'total_tokens'      => 12,
        ],
    ];
}
PK     S%W]!Z–<Æ  Æ  S  client/src/Testing/Responses/Fixtures/Completions/CreateStreamedResponseFixture.txtnu „[µü¤        data: {"id": "cmpl-6ynJi2uZZnKntnEZreDcjGyoPbVAn", "object": "text_completion", "created": 1679430847, "choices": [{"text": " everyone", "index": 0, "logprobs": null, "finish_reason": null}], "model": "gpt-3.5-turbo-instruct"}
data: {"id": "cmpl-6ynJi2uZZnKntnEZreDcjGyoPbVAn", "object": "text_completion", "created": 1679430847, "choices": [{"text": "!", "index": 0, "logprobs": null, "finish_reason": null}], "model": "gpt-3.5-turbo-instruct"}
data: {"id": "cmpl-6ynJi2uZZnKntnEZreDcjGyoPbVAn", "object": "text_completion", "created": 1679430847, "choices": [{"text": "\n", "index": 0, "logprobs": null, "finish_reason": null}], "model": "gpt-3.5-turbo-instruct"}
data: {"id": "cmpl-6ynJi2uZZnKntnEZreDcjGyoPbVAn", "object": "text_completion", "created": 1679430847, "choices": [{"text": "\n", "index": 0, "logprobs": null, "finish_reason": null}], "model": "gpt-3.5-turbo-instruct"}
data: {"id": "cmpl-6ynJi2uZZnKntnEZreDcjGyoPbVAn", "object": "text_completion", "created": 1679430847, "choices": [{"text": "This", "index": 0, "logprobs": null, "finish_reason": null}], "model": "gpt-3.5-turbo-instruct"}
data: {"id": "cmpl-6ynJi2uZZnKntnEZreDcjGyoPbVAn", "object": "text_completion", "created": 1679430847, "choices": [{"text": " is", "index": 0, "logprobs": null, "finish_reason": null}], "model": "gpt-3.5-turbo-instruct"}
data: {"id": "cmpl-6ynJi2uZZnKntnEZreDcjGyoPbVAn", "object": "text_completion", "created": 1679430847, "choices": [{"text": " a", "index": 0, "logprobs": null, "finish_reason": null}], "model": "gpt-3.5-turbo-instruct"}
data: {"id": "cmpl-6ynJi2uZZnKntnEZreDcjGyoPbVAn", "object": "text_completion", "created": 1679430847, "choices": [{"text": " fake", "index": 0, "logprobs": null, "finish_reason": null}], "model": "gpt-3.5-turbo-instruct"}
data: {"id": "cmpl-6ynJi2uZZnKntnEZreDcjGyoPbVAn", "object": "text_completion", "created": 1679430847, "choices": [{"text": " completion", "index": 0, "logprobs": null, "finish_reason": null}], "model": "gpt-3.5-turbo-instruct"}
data: {"id": "cmpl-6ynJi2uZZnKntnEZreDcjGyoPbVAn", "object": "text_completion", "created": 1679430847, "choices": [{"text": " response.", "index": 0, "logprobs": null, "finish_reason": "length"}], "model": "gpt-3.5-turbo-instruct"}
data: [DONE]
PK     S%W]´»Y+Ù  Ù  D  client/src/Testing/Responses/Fixtures/Chat/CreateResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Chat;

final class CreateResponseFixture
{
    public const ATTRIBUTES = [
        'id'                 => 'chatcmpl-123',
        'object'             => 'chat.completion',
        'created'            => 1_677_652_288,
        'model'              => 'gpt-3.5-turbo',
        'system_fingerprint' => null,
        'choices'            => [
            [
                'index'   => 0,
                'message' => [
                    'role'          => 'assistant',
                    'content'       => "\n\nHello there, this is a fake chat response.",
                    'function_call' => null,
                    'tool_calls'    => [],
                ],
                'logprobs'      => null,
                'finish_reason' => 'stop',
            ],
        ],
        'usage' => [
            'prompt_tokens'     => 9,
            'completion_tokens' => 12,
            'total_tokens'      => 21,
        ],
    ];
}
PK     S%W]®œ-¤  ¤  L  client/src/Testing/Responses/Fixtures/Chat/CreateStreamedResponseFixture.txtnu „[µü¤        data: {"id":"chatcmpl-6yo21W6LVo8Tw2yBf7aGf2g17IeIl","object":"chat.completion.chunk","created":1679432086,"model":"gpt-4-0314","choices":[{"delta":{"role":"assistant"},"index":0,"finish_reason":null}]}
data: {"id":"chatcmpl-6yo21W6LVo8Tw2yBf7aGf2g17IeIl","object":"chat.completion.chunk","created":1679432086,"model":"gpt-4-0314","choices":[{"delta":{"content":"Hello"},"index":0,"finish_reason":null}]}
data: {"id":"chatcmpl-6yo21W6LVo8Tw2yBf7aGf2g17IeIl","object":"chat.completion.chunk","created":1679432086,"model":"gpt-4-0314","choices":[{"delta":{"content":"!"},"index":0,"finish_reason":null}]}
data: {"id":"chatcmpl-6yo21W6LVo8Tw2yBf7aGf2g17IeIl","object":"chat.completion.chunk","created":1679432086,"model":"gpt-4-0314","choices":[{"delta":{"content":" This"},"index":0,"finish_reason":null}]}
data: {"id":"chatcmpl-6yo21W6LVo8Tw2yBf7aGf2g17IeIl","object":"chat.completion.chunk","created":1679432086,"model":"gpt-4-0314","choices":[{"delta":{"content":" is"},"index":0,"finish_reason":null}]}
data: {"id":"chatcmpl-6yo21W6LVo8Tw2yBf7aGf2g17IeIl","object":"chat.completion.chunk","created":1679432086,"model":"gpt-4-0314","choices":[{"delta":{"content":" a"},"index":0,"finish_reason":null}]}
data: {"id":"chatcmpl-6yo21W6LVo8Tw2yBf7aGf2g17IeIl","object":"chat.completion.chunk","created":1679432086,"model":"gpt-4-0314","choices":[{"delta":{"content":" fake"},"index":0,"finish_reason":null}]}
data: {"id":"chatcmpl-6yo21W6LVo8Tw2yBf7aGf2g17IeIl","object":"chat.completion.chunk","created":1679432086,"model":"gpt-4-0314","choices":[{"delta":{"content":" chat"},"index":0,"finish_reason":null}]}
data: {"id":"chatcmpl-6yo21W6LVo8Tw2yBf7aGf2g17IeIl","object":"chat.completion.chunk","created":1679432086,"model":"gpt-4-0314","choices":[{"delta":{"content":" response"},"index":0,"finish_reason":null}]}
data: {"id":"chatcmpl-6yo21W6LVo8Tw2yBf7aGf2g17IeIl","object":"chat.completion.chunk","created":1679432086,"model":"gpt-4-0314","choices":[{"delta":{"content":"."},"index":0,"finish_reason":null}]}
data: {"id":"chatcmpl-6yo21W6LVo8Tw2yBf7aGf2g17IeIl","object":"chat.completion.chunk","created":1679432086,"model":"gpt-4-0314","choices":[{"delta":{},"index":0,"finish_reason":"stop"}]}
data: [DONE]
PK     S%W]ÕgÓ(  (  D  client/src/Testing/Responses/Fixtures/Images/EditResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Images;

final class EditResponseFixture
{
    public const ATTRIBUTES = [
        'created' => 1_664_136_088,
        'data'    => [
            [
                'url' => 'https://openai.com/fake-image.png',
            ],
        ],
    ];
}
PK     S%W]ÐÇR-  -  I  client/src/Testing/Responses/Fixtures/Images/VariationResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Images;

final class VariationResponseFixture
{
    public const ATTRIBUTES = [
        'created' => 1_664_136_088,
        'data'    => [
            [
                'url' => 'https://openai.com/fake-image.png',
            ],
        ],
    ];
}
PK     S%W]/:z*  *  F  client/src/Testing/Responses/Fixtures/Images/CreateResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Images;

final class CreateResponseFixture
{
    public const ATTRIBUTES = [
        'created' => 1_664_136_088,
        'data'    => [
            [
                'url' => 'https://openai.com/fake-image.png',
            ],
        ],
    ];
}
PK     S%W]ÿÏV>…  …  V  client/src/Testing/Responses/Fixtures/Realtime/TranscriptionSessionResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Realtime;

final class TranscriptionSessionResponseFixture
{
    public const ATTRIBUTES = [
        'client_secret' => [
            'expires_at' => 1735680000,
            'value'      => 'ek_secret_123',
        ],
        'input_audio_format'        => 'pcm16',
        'input_audio_transcription' => null,
        'modalities'                => null,
        'turn_detection'            => [
            'prefix_padding_ms'   => 300,
            'silence_duration_ms' => 200,
            'threshold'           => 0.5,
            'type'                => 'server_vad',
        ],
    ];
}
PK     S%W]™ýÂ¸ø  ø  I  client/src/Testing/Responses/Fixtures/Realtime/SessionResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Realtime;

final class SessionResponseFixture
{
    public const ATTRIBUTES = [
        'client_secret' => [
            'expires_at' => 1735680000,
            'value'      => 'ek_secret_123',
        ],
        'input_audio_format'         => 'pcm16',
        'input_audio_transcription'  => null,
        'instructions'               => 'Your knowledge cutoff is 2023-10. You are a helpful assistant.',
        'max_response_output_tokens' => 'inf',
        'modalities'                 => [
            'audio',
            'text',
        ],
        'output_audio_format' => 'pcm16',
        'temperature'         => 0.7,
        'tool_choice'         => 'auto',
        'tools'               => [],
        'turn_detection'      => [
            'prefix_padding_ms'   => 100,
            'silence_duration_ms' => 500,
            'threshold'           => 0.5,
            'type'                => 'server_vad',
        ],
        'voice' => 'alloy',
    ];
}
PK     S%W][f<Ýä  ä  b  client/src/Testing/Responses/Fixtures/VectorStores/Search/VectorStoreSearchResponseFileFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\VectorStores\Search;

final class VectorStoreSearchResponseFileFixture
{
    public const ATTRIBUTES = [
        'file_id'    => 'file_abc123',
        'filename'   => 'document.pdf',
        'score'      => 0.95,
        'attributes' => [
            'author' => 'John Doe',
            'date'   => '2023-01-01',
        ],
        'content' => [
            VectorStoreSearchResponseContentFixture::ATTRIBUTES,
        ],
    ];
}
PK     S%W]Èÿ|À  À  ^  client/src/Testing/Responses/Fixtures/VectorStores/Search/VectorStoreSearchResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\VectorStores\Search;

final class VectorStoreSearchResponseFixture
{
    public const ATTRIBUTES = [
        'object'       => 'vector_store.search_results.page',
        'search_query' => 'What is the return policy?',
        'data'         => [
            VectorStoreSearchResponseFileFixture::ATTRIBUTES,
            [
                'file_id'    => 'file_xyz789',
                'filename'   => 'notes.txt',
                'score'      => 0.89,
                'attributes' => [
                    'author' => 'Jane Smith',
                    'date'   => '2023-01-02',
                ],
                'content' => [
                    [
                        'type' => 'text',
                        'text' => 'Sample text content from the vector store.',
                    ],
                ],
            ],
        ],
        'has_more'  => false,
        'next_page' => null,
    ];
}
PK     S%W]û¯®ù    e  client/src/Testing/Responses/Fixtures/VectorStores/Search/VectorStoreSearchResponseContentFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\VectorStores\Search;

final class VectorStoreSearchResponseContentFixture
{
    public const ATTRIBUTES = [
        'type' => 'text',
        'text' => 'Sample text content from the vector store.',
    ];
}
PK     S%W]Í÷W…  …  U  client/src/Testing/Responses/Fixtures/VectorStores/VectorStoreListResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\VectorStores;

final class VectorStoreListResponseFixture
{
    public const ATTRIBUTES = [
        'object' => 'list',
        'data'   => [
            [
                'id'          => 'vs_8VE2cQq1jTFlH7FizhYCzUz0',
                'object'      => 'vector_store',
                'name'        => 'Product Knowledge Base',
                'status'      => 'completed',
                'attributes'  => [],
                'usage_bytes' => 29882,
                'created_at'  => 1_715_953_317,
                'file_counts' => [
                    'in_progress' => 0,
                    'completed'   => 1,
                    'failed'      => 0,
                    'cancelled'   => 0,
                    'total'       => 1,
                ],
                'metadata'       => [],
                'expires_after'  => null,
                'expires_at'     => null,
                'last_active_at' => 1_715_953_317,
            ],
            [
                'id'          => 'vs_xzlnkCbIQE50B9A8RzmcFmtP',
                'object'      => 'vector_store',
                'name'        => null,
                'status'      => 'completed',
                'attributes'  => [],
                'usage_bytes' => 0,
                'created_at'  => 1_710_869_420,
                'file_counts' => [
                    'in_progress' => 0,
                    'completed'   => 1,
                    'failed'      => 0,
                    'cancelled'   => 0,
                    'total'       => 1,
                ],
                'metadata'       => [],
                'expires_after'  => null,
                'expires_at'     => null,
                'last_active_at' => 1_710_869_420,
            ],
        ],
        'first_id' => 'vs_8VE2cQq1jTFlH7FizhYCzUz0',
        'last_id'  => 'vs_xzlnkCbIQE50B9A8RzmcFmtP',
        'has_more' => true,
    ];
}
PK     S%W]<®pfé  é  Q  client/src/Testing/Responses/Fixtures/VectorStores/VectorStoreResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\VectorStores;

final class VectorStoreResponseFixture
{
    public const ATTRIBUTES = [
        'id'          => 'vs_8VE2cQq1jTFlH7FizhYCzUz0',
        'object'      => 'vector_store',
        'name'        => 'Product Knowledge Base',
        'status'      => 'in_progress',
        'usage_bytes' => 0,
        'created_at'  => 1_715_953_317,
        'file_counts' => [
            'in_progress' => 1,
            'completed'   => 0,
            'failed'      => 0,
            'cancelled'   => 0,
            'total'       => 1,
        ],
        'metadata'       => [],
        'expires_after'  => null,
        'expires_at'     => null,
        'last_active_at' => 1_715_953_317,
    ];
}
PK     S%W] îîÕ1  1  _  client/src/Testing/Responses/Fixtures/VectorStores/Files/VectorStoreFileListResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\VectorStores\Files;

final class VectorStoreFileListResponseFixture
{
    public const ATTRIBUTES = [
        'object' => 'list',
        'data'   => [
            [
                'id'              => 'file-HuwUghQzWasTZeX3uRRawY5R',
                'object'          => 'vector_store.file',
                'usage_bytes'     => 29882,
                'created_at'      => 1_715_956_697,
                'vector_store_id' => 'vs_xds05V7ep0QMGI5JmYnWsJwb',
                'status'          => 'completed',
                'attributes'      => [],
                'last_error'      => null,
            ],
        ],
        'first_id' => 'file-HuwUghQzWasTZeX3uRRawY5R',
        'last_id'  => 'file-HuwUghQzWasTZeX3uRRawY5R',
        'has_more' => false,
    ];
}
PK     S%W]HŒ,ð    [  client/src/Testing/Responses/Fixtures/VectorStores/Files/VectorStoreFileResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\VectorStores\Files;

final class VectorStoreFileResponseFixture
{
    public const ATTRIBUTES = [
        'id'              => 'file-HuwUghQzWasTZeX3uRRawY5R',
        'object'          => 'vector_store.file',
        'usage_bytes'     => 29882,
        'created_at'      => 1_715_956_697,
        'vector_store_id' => 'vs_xds05V7ep0QMGI5JmYnWsJwb',
        'status'          => 'completed',
        'attributes'      => [],
        'last_error'      => null,
    ];
}
PK     S%W]ß,„&'  '  a  client/src/Testing/Responses/Fixtures/VectorStores/Files/VectorStoreFileDeleteResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\VectorStores\Files;

final class VectorStoreFileDeleteResponseFixture
{
    public const ATTRIBUTES = [
        'id'      => 'file-HuwUghQzWasTZeX3uRRawY5R',
        'object'  => 'vector_store.file.deleted',
        'deleted' => true,
    ];
}
PK     S%W]%_†    W  client/src/Testing/Responses/Fixtures/VectorStores/VectorStoreDeleteResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\VectorStores;

final class VectorStoreDeleteResponseFixture
{
    public const ATTRIBUTES = [
        'id'      => 'vs_xzlnkCbIQE50B9A8RzmcFmtP',
        'object'  => 'vector_store.deleted',
        'deleted' => true,
    ];
}
PK     S%W]¢rÀ½    L  client/src/Testing/Responses/Fixtures/FineTuning/ListJobsResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\FineTuning;

final class ListJobsResponseFixture
{
    public const ATTRIBUTES = [
        'object' => 'list',
        'data'   => [
            RetrieveJobResponseFixture::ATTRIBUTES,
        ],
        'has_more' => false,
    ];
}
PK     S%W]ËÏÖ	×  ×  O  client/src/Testing/Responses/Fixtures/FineTuning/RetrieveJobResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\FineTuning;

final class RetrieveJobResponseFixture
{
    public const ATTRIBUTES = [
        'id'               => 'ftjob-AF1WoRqd3aJAHsqc9NY7iL8F',
        'object'           => 'fine_tuning.job',
        'model'            => 'gpt-3.5-turbo-0613',
        'created_at'       => 1_614_807_352,
        'finished_at'      => 1_692_819_450,
        'fine_tuned_model' => 'ft:gpt-3.5-turbo-0613:gehri-dev::7qnxQ0sQ',
        'hyperparameters'  => [
            'n_epochs'                 => 9,
            'batch_size'               => 1,
            'learning_rate_multiplier' => 2,
        ],
        'organization_id' => 'org-jwe45798ASN82s',
        'result_files'    => [
            'file-1bl05WrhsKDDEdg8XSP617QF',
        ],
        'status'          => 'succeeded',
        'validation_file' => null,
        'training_file'   => 'file-abc123',
        'trained_tokens'  => 5049,
        'error'           => null,
    ];
}
PK     S%W]Ï¥·{  {  Q  client/src/Testing/Responses/Fixtures/FineTuning/ListJobEventsResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\FineTuning;

final class ListJobEventsResponseFixture
{
    public const ATTRIBUTES = [
        'object' => 'list',
        'data'   => [
            [
                'object'     => 'fine_tuning.job.event',
                'id'         => 'ft-event-ddTJfwuMVpfLXseO0Am0Gqjm',
                'created_at' => 1_692_407_401,
                'level'      => 'info',
                'message'    => 'Fine tuning job successfully completed',
                'data'       => null,
                'type'       => 'message',
            ],
        ],
        'has_more' => false,
    ];
}
PK     S%W]ZÞ°Û?  ?  J  client/src/Testing/Responses/Fixtures/Embeddings/CreateResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Embeddings;

final class CreateResponseFixture
{
    public const ATTRIBUTES = [
        'object' => 'list',
        'model'  => 'text-embedding-3-small',
        'data'   => [
            [
                'object'    => 'embedding',
                'index'     => 0,
                'embedding' => [
                    -0.008906792,
                    -0.013743395,
                ],
            ],
        ],
        'usage' => [
            'prompt_tokens' => 8,
            'total_tokens'  => 8,
        ],
    ];
}
PK     S%W];k‡\  \  K  client/src/Testing/Responses/Fixtures/Responses/RetrieveResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Responses;

final class RetrieveResponseFixture
{
    public const ATTRIBUTES = [
        'id'                 => 'resp_67ccf18ef5fc8190b16dbee19bc54e5f087bb177ab789d5c',
        'object'             => 'response',
        'created_at'         => 1741484430,
        'status'             => 'completed',
        'error'              => null,
        'incomplete_details' => null,
        'instructions'       => null,
        'max_output_tokens'  => null,
        'model'              => 'gpt-4o-2024-08-06',
        'output'             => [
            [
                'type'   => 'web_search_call',
                'id'     => 'ws_67ccf18f64008190a39b619f4c8455ef087bb177ab789d5c',
                'status' => 'completed',
            ],
            [
                'type'    => 'message',
                'id'      => 'msg_67ccf190ca3881909d433c50b1f6357e087bb177ab789d5c',
                'status'  => 'completed',
                'role'    => 'assistant',
                'content' => [
                    [
                        'type'        => 'output_text',
                        'text'        => 'As of today, March 9, 2025, one notable positive news story...',
                        'annotations' => [
                            [
                                'type'        => 'url_citation',
                                'start_index' => 442,
                                'end_index'   => 557,
                                'url'         => 'https://.../?utm_source=chatgpt.com',
                                'title'       => '...',
                            ],
                            [
                                'type'        => 'url_citation',
                                'start_index' => 962,
                                'end_index'   => 1077,
                                'url'         => 'https://.../?utm_source=chatgpt.com',
                                'title'       => '...',
                            ],
                            [
                                'type'        => 'url_citation',
                                'start_index' => 1336,
                                'end_index'   => 1451,
                                'url'         => 'https://.../?utm_source=chatgpt.com',
                                'title'       => '...',
                            ],
                        ],
                    ],
                ],
            ],
        ],
        'parallel_tool_calls'  => true,
        'previous_response_id' => null,
        'reasoning'            => [
            'effort'           => null,
            'generate_summary' => null,
        ],
        'store'       => true,
        'temperature' => 1.0,
        'text'        => [
            'format' => [
                'type' => 'text',
            ],
        ],
        'tool_choice' => 'auto',
        'tools'       => [
            [
                'type'                => 'web_search_preview',
                'domains'             => [],
                'search_context_size' => 'medium',
                'user_location'       => [
                    'type'     => 'approximate',
                    'city'     => 'San Francisco',
                    'country'  => 'US',
                    'region'   => 'California',
                    'timezone' => 'America/Los_Angeles',
                ],
            ],
        ],
        'top_p'      => 1.0,
        'truncation' => 'disabled',
        'usage'      => [
            'input_tokens'         => 328,
            'input_tokens_details' => [
                'cached_tokens' => 0,
            ],
            'output_tokens'         => 356,
            'output_tokens_details' => [
                'reasoning_tokens' => 0,
            ],
            'total_tokens' => 684,
        ],
        'user'     => null,
        'metadata' => [],
    ];
}
PK     S%W]j>bF    I  client/src/Testing/Responses/Fixtures/Responses/ListInputItemsFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Responses;

final class ListInputItemsFixture
{
    public const ATTRIBUTES = [
        'object' => 'list',
        'data'   => [
            [
                'content' => [
                    [
                        'text'        => 'What was a positive news story from today?',
                        'type'        => 'input_text',
                        'annotations' => [],
                    ],
                ],
                'id'     => 'msg_67ccf190ca3881909d433c50b1f6357e087bb177ab789d5c',
                'role'   => 'user',
                'status' => 'completed',
                'type'   => 'message',
            ],
        ],
        'first_id' => 'msg_67ccf190ca3881909d433c50b1f6357e087bb177ab789d5c',
        'last_id'  => 'msg_67ccf190ca3881909d433c50b1f6357e087bb177ab789d5c',
        'has_more' => false,
    ];
}
PK     S%W]pÁ‹EZ  Z  I  client/src/Testing/Responses/Fixtures/Responses/CancelResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Responses;

final class CancelResponseFixture
{
    public const ATTRIBUTES = [
        'id'                 => 'resp_67ccf18ef5fc8190b16dbee19bc54e5f087bb177ab789d5c',
        'object'             => 'response',
        'created_at'         => 1741484430,
        'status'             => 'completed',
        'error'              => null,
        'incomplete_details' => null,
        'instructions'       => null,
        'max_output_tokens'  => null,
        'model'              => 'gpt-4o-2024-08-06',
        'output'             => [
            [
                'type'   => 'web_search_call',
                'id'     => 'ws_67ccf18f64008190a39b619f4c8455ef087bb177ab789d5c',
                'status' => 'completed',
            ],
            [
                'type'    => 'message',
                'id'      => 'msg_67ccf190ca3881909d433c50b1f6357e087bb177ab789d5c',
                'status'  => 'completed',
                'role'    => 'assistant',
                'content' => [
                    [
                        'type'        => 'output_text',
                        'text'        => 'As of today, March 9, 2025, one notable positive news story...',
                        'annotations' => [
                            [
                                'type'        => 'url_citation',
                                'start_index' => 442,
                                'end_index'   => 557,
                                'url'         => 'https://.../?utm_source=chatgpt.com',
                                'title'       => '...',
                            ],
                            [
                                'type'        => 'url_citation',
                                'start_index' => 962,
                                'end_index'   => 1077,
                                'url'         => 'https://.../?utm_source=chatgpt.com',
                                'title'       => '...',
                            ],
                            [
                                'type'        => 'url_citation',
                                'start_index' => 1336,
                                'end_index'   => 1451,
                                'url'         => 'https://.../?utm_source=chatgpt.com',
                                'title'       => '...',
                            ],
                        ],
                    ],
                ],
            ],
        ],
        'parallel_tool_calls'  => true,
        'previous_response_id' => null,
        'reasoning'            => [
            'effort'           => null,
            'generate_summary' => null,
        ],
        'store'       => true,
        'temperature' => 1.0,
        'text'        => [
            'format' => [
                'type' => 'text',
            ],
        ],
        'tool_choice' => 'auto',
        'tools'       => [
            [
                'type'                => 'web_search_preview',
                'domains'             => [],
                'search_context_size' => 'medium',
                'user_location'       => [
                    'type'     => 'approximate',
                    'city'     => 'San Francisco',
                    'country'  => 'US',
                    'region'   => 'California',
                    'timezone' => 'America/Los_Angeles',
                ],
            ],
        ],
        'top_p'      => 1.0,
        'truncation' => 'disabled',
        'usage'      => [
            'input_tokens'         => 328,
            'input_tokens_details' => [
                'cached_tokens' => 0,
            ],
            'output_tokens'         => 356,
            'output_tokens_details' => [
                'reasoning_tokens' => 0,
            ],
            'total_tokens' => 684,
        ],
        'user'     => null,
        'metadata' => [],
    ];
}
PK     S%W]ßÕÌ    I  client/src/Testing/Responses/Fixtures/Responses/DeleteResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Responses;

final class DeleteResponseFixture
{
    public const ATTRIBUTES = [
        'id'      => 'resp_67ccf18ef5fc8190b16dbee19bc54e5f087bb177ab789d5c',
        'object'  => 'response',
        'deleted' => true,
    ];
}
PK     S%W]$® Z  Z  I  client/src/Testing/Responses/Fixtures/Responses/ResponseObjectFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Responses;

final class ResponseObjectFixture
{
    public const ATTRIBUTES = [
        'id'                 => 'resp_67ccf18ef5fc8190b16dbee19bc54e5f087bb177ab789d5c',
        'object'             => 'response',
        'created_at'         => 1741484430,
        'status'             => 'completed',
        'error'              => null,
        'incomplete_details' => null,
        'instructions'       => null,
        'max_output_tokens'  => null,
        'model'              => 'gpt-4o-2024-08-06',
        'output'             => [
            [
                'type'   => 'web_search_call',
                'id'     => 'ws_67ccf18f64008190a39b619f4c8455ef087bb177ab789d5c',
                'status' => 'completed',
            ],
            [
                'type'    => 'message',
                'id'      => 'msg_67ccf190ca3881909d433c50b1f6357e087bb177ab789d5c',
                'status'  => 'completed',
                'role'    => 'assistant',
                'content' => [
                    [
                        'type'        => 'output_text',
                        'text'        => 'As of today, March 9, 2025, one notable positive news story...',
                        'annotations' => [
                            [
                                'type'        => 'url_citation',
                                'start_index' => 442,
                                'end_index'   => 557,
                                'url'         => 'https://.../?utm_source=chatgpt.com',
                                'title'       => '...',
                            ],
                            [
                                'type'        => 'url_citation',
                                'start_index' => 962,
                                'end_index'   => 1077,
                                'url'         => 'https://.../?utm_source=chatgpt.com',
                                'title'       => '...',
                            ],
                            [
                                'type'        => 'url_citation',
                                'start_index' => 1336,
                                'end_index'   => 1451,
                                'url'         => 'https://.../?utm_source=chatgpt.com',
                                'title'       => '...',
                            ],
                        ],
                    ],
                ],
            ],
        ],
        'parallel_tool_calls'  => true,
        'previous_response_id' => null,
        'reasoning'            => [
            'effort'           => null,
            'generate_summary' => null,
        ],
        'store'       => true,
        'temperature' => 1.0,
        'text'        => [
            'format' => [
                'type' => 'text',
            ],
        ],
        'tool_choice' => 'auto',
        'tools'       => [
            [
                'type'                => 'web_search_preview',
                'domains'             => [],
                'search_context_size' => 'medium',
                'user_location'       => [
                    'type'     => 'approximate',
                    'city'     => 'San Francisco',
                    'country'  => 'US',
                    'region'   => 'California',
                    'timezone' => 'America/Los_Angeles',
                ],
            ],
        ],
        'top_p'      => 1.0,
        'truncation' => 'disabled',
        'usage'      => [
            'input_tokens'         => 328,
            'input_tokens_details' => [
                'cached_tokens' => 0,
            ],
            'output_tokens'         => 356,
            'output_tokens_details' => [
                'reasoning_tokens' => 0,
            ],
            'total_tokens' => 684,
        ],
        'user'     => null,
        'metadata' => [],
    ];
}
PK     S%W]-Å«Z  Z  I  client/src/Testing/Responses/Fixtures/Responses/CreateResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Responses;

final class CreateResponseFixture
{
    public const ATTRIBUTES = [
        'id'                 => 'resp_67ccf18ef5fc8190b16dbee19bc54e5f087bb177ab789d5c',
        'object'             => 'response',
        'created_at'         => 1741484430,
        'status'             => 'completed',
        'error'              => null,
        'incomplete_details' => null,
        'instructions'       => null,
        'max_output_tokens'  => null,
        'model'              => 'gpt-4o-2024-08-06',
        'output'             => [
            [
                'type'   => 'web_search_call',
                'id'     => 'ws_67ccf18f64008190a39b619f4c8455ef087bb177ab789d5c',
                'status' => 'completed',
            ],
            [
                'type'    => 'message',
                'id'      => 'msg_67ccf190ca3881909d433c50b1f6357e087bb177ab789d5c',
                'status'  => 'completed',
                'role'    => 'assistant',
                'content' => [
                    [
                        'type'        => 'output_text',
                        'text'        => 'As of today, March 9, 2025, one notable positive news story...',
                        'annotations' => [
                            [
                                'type'        => 'url_citation',
                                'start_index' => 442,
                                'end_index'   => 557,
                                'url'         => 'https://.../?utm_source=chatgpt.com',
                                'title'       => '...',
                            ],
                            [
                                'type'        => 'url_citation',
                                'start_index' => 962,
                                'end_index'   => 1077,
                                'url'         => 'https://.../?utm_source=chatgpt.com',
                                'title'       => '...',
                            ],
                            [
                                'type'        => 'url_citation',
                                'start_index' => 1336,
                                'end_index'   => 1451,
                                'url'         => 'https://.../?utm_source=chatgpt.com',
                                'title'       => '...',
                            ],
                        ],
                    ],
                ],
            ],
        ],
        'parallel_tool_calls'  => true,
        'previous_response_id' => null,
        'reasoning'            => [
            'effort'           => null,
            'generate_summary' => null,
        ],
        'store'       => true,
        'temperature' => 1.0,
        'text'        => [
            'format' => [
                'type' => 'text',
            ],
        ],
        'tool_choice' => 'auto',
        'tools'       => [
            [
                'type'                => 'web_search_preview',
                'domains'             => [],
                'search_context_size' => 'medium',
                'user_location'       => [
                    'type'     => 'approximate',
                    'city'     => 'San Francisco',
                    'country'  => 'US',
                    'region'   => 'California',
                    'timezone' => 'America/Los_Angeles',
                ],
            ],
        ],
        'top_p'      => 1.0,
        'truncation' => 'disabled',
        'usage'      => [
            'input_tokens'         => 328,
            'input_tokens_details' => [
                'cached_tokens' => 0,
            ],
            'output_tokens'         => 356,
            'output_tokens_details' => [
                'reasoning_tokens' => 0,
            ],
            'total_tokens' => 684,
        ],
        'user'     => null,
        'metadata' => [],
    ];
}
PK     S%W]ÝP›3  3  Q  client/src/Testing/Responses/Fixtures/Responses/CreateStreamedResponseFixture.txtnu „[µü¤        data: {"type":"response.created","response":{"id":"resp_67c9fdcecf488190bdd9a0409de3a1ec07b8b0ad4e5eb654","object":"response","created_at":1741290958,"status":"in_progress","error":null,"incomplete_details":null,"instructions":"You are a helpful assistant.","max_output_tokens":null,"model":"gpt-4o-2024-08-06","output":[],"parallel_tool_calls":true,"previous_response_id":null,"reasoning":{"effort":null,"summary":null},"store":true,"temperature":1.0,"text":{"format":{"type":"text"}},"tool_choice":"auto","tools":[],"top_p":1.0,"truncation":"disabled","usage":null,"user":null,"metadata":{}}}
data: {"type":"response.in_progress","response":{"id":"resp_67c9fdcecf488190bdd9a0409de3a1ec07b8b0ad4e5eb654","object":"response","created_at":1741290958,"status":"in_progress","error":null,"incomplete_details":null,"instructions":"You are a helpful assistant.","max_output_tokens":null,"model":"gpt-4o-2024-08-06","output":[],"parallel_tool_calls":true,"previous_response_id":null,"reasoning":{"effort":null,"summary":null},"store":true,"temperature":1.0,"text":{"format":{"type":"text"}},"tool_choice":"auto","tools":[],"top_p":1.0,"truncation":"disabled","usage":null,"user":null,"metadata":{}}}
data: {"type":"response.output_item.added","output_index":0,"item":{"id":"msg_67c9fdcf37fc8190ba82116e33fb28c507b8b0ad4e5eb654","type":"message","status":"in_progress","role":"assistant","content":[]}}
data: {"type":"response.content_part.added","item_id":"msg_67c9fdcf37fc8190ba82116e33fb28c507b8b0ad4e5eb654","output_index":0,"content_index":0,"part":{"type":"output_text","text":"","annotations":[]}}
data: {"type":"response.output_text.delta","item_id":"msg_67c9fdcf37fc8190ba82116e33fb28c507b8b0ad4e5eb654","output_index":0,"content_index":0,"delta":"Hi"}
data: {"type":"response.output_text.done","item_id":"msg_67c9fdcf37fc8190ba82116e33fb28c507b8b0ad4e5eb654","output_index":0,"content_index":0,"text":"Hi there! How can I assist you today?"}
data: {"type":"response.content_part.done","item_id":"msg_67c9fdcf37fc8190ba82116e33fb28c507b8b0ad4e5eb654","output_index":0,"content_index":0,"part":{"type":"output_text","text":"Hi there! How can I assist you today?","annotations":[]}}
data: {"type":"response.output_item.done","output_index":0,"item":{"id":"msg_67c9fdcf37fc8190ba82116e33fb28c507b8b0ad4e5eb654","type":"message","status":"completed","role":"assistant","content":[{"type":"output_text","text":"Hi there! How can I assist you today?","annotations":[]}]}}
data: {"type":"response.completed","response":{"id":"resp_67c9fdcecf488190bdd9a0409de3a1ec07b8b0ad4e5eb654","object":"response","created_at":1741290958,"status":"completed","error":null,"incomplete_details":null,"instructions":"You are a helpful assistant.","max_output_tokens":null,"model":"gpt-4o-2024-08-06","output":[{"id":"msg_67c9fdcf37fc8190ba82116e33fb28c507b8b0ad4e5eb654","type":"message","status":"completed","role":"assistant","content":[{"type":"output_text","text":"Hi there! How can I assist you today?","annotations":[]}]}],"parallel_tool_calls":true,"previous_response_id":null,"reasoning":{"effort":null,"summary":null},"store":true,"temperature":1.0,"text":{"format":{"type":"text"}},"tool_choice":"auto","tools":[],"top_p":1.0,"truncation":"disabled","usage":{"input_tokens":37,"output_tokens":11,"output_tokens_details":{"reasoning_tokens":0},"total_tokens":48},"user":null,"metadata":{}}}
PK     S%W]KißÃÚ  Ú  G  client/src/Testing/Responses/Fixtures/Files/RetrieveResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Files;

final class RetrieveResponseFixture
{
    public const ATTRIBUTES = [
        'id'             => 'file-XjGxS3KTG0uNmNOK362iJua3',
        'object'         => 'file',
        'bytes'          => 140,
        'created_at'     => 1_613_779_121,
        'filename'       => 'fake-file.jsonl',
        'purpose'        => 'fine-tune',
        'status'         => 'succeeded',
        'status_details' => null,
    ];
}
PK     S%W]J÷¹ö   ö   E  client/src/Testing/Responses/Fixtures/Files/DeleteResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Files;

final class DeleteResponseFixture
{
    public const ATTRIBUTES = [
        'id'      => 'file-XjGxS3KTG0uNmNOK362iJua3',
        'object'  => 'file',
        'deleted' => true,
    ];
}
PK     S%W]fMp  p  C  client/src/Testing/Responses/Fixtures/Files/ListResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Files;

final class ListResponseFixture
{
    public const ATTRIBUTES = [
        'object' => 'list',
        'data'   => [
            [
                'id'             => 'file-XjGxS3KTG0uNmNOK362iJua3',
                'object'         => 'file',
                'bytes'          => 140,
                'created_at'     => 1_613_779_121,
                'filename'       => 'fake-file.jsonl',
                'purpose'        => 'fine-tune',
                'status'         => 'succeeded',
                'status_details' => null,
            ],
        ],
    ];
}
PK     S%W]tFÐØ  Ø  E  client/src/Testing/Responses/Fixtures/Files/CreateResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\Files;

final class CreateResponseFixture
{
    public const ATTRIBUTES = [
        'id'             => 'file-XjGxS3KTG0uNmNOK362iJua3',
        'object'         => 'file',
        'bytes'          => 140,
        'created_at'     => 1_613_779_121,
        'filename'       => 'fake-file.jsonl',
        'purpose'        => 'fine-tune',
        'status'         => 'succeeded',
        'status_details' => null,
    ];
}
PK     S%W]â&™tf  f  K  client/src/Testing/Responses/Fixtures/FineTunes/RetrieveResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\FineTunes;

use OpenAI\Testing\Responses\Fixtures\Files\CreateResponseFixture;

final class RetrieveResponseFixture
{
    public const ATTRIBUTES = [
        'id'         => 'ft-AF1WoRqd3aJAHsqc9NY7iL8F',
        'object'     => 'fine-tune',
        'model'      => 'curie',
        'created_at' => 1_614_807_352,
        'events'     => [
            [
                'object'     => 'fine-tune-event',
                'created_at' => 1_614_807_352,
                'level'      => 'info',
                'message'    => 'Job enqueued. Waiting for jobs ahead to complete. Queue number =>  0.',
            ],
        ],
        'fine_tuned_model' => 'curie => ft-acmeco-2021-03-03-21-44-20',
        'hyperparams'      => [
            'batch_size'               => 4,
            'learning_rate_multiplier' => 0.1,
            'n_epochs'                 => 4,
            'prompt_loss_weight'       => 0.1,
        ],
        'organization_id' => 'org-jwe45798ASN82s',
        'result_files'    => [
            CreateResponseFixture::ATTRIBUTES,
        ],
        'status'           => 'succeeded',
        'validation_files' => [
            CreateResponseFixture::ATTRIBUTES,
        ],
        'training_files' => [
            CreateResponseFixture::ATTRIBUTES,
        ],
        'updated_at' => 1_614_807_865,
    ];
}
PK     S%W]Z­`ÝV  V  X  client/src/Testing/Responses/Fixtures/FineTunes/RetrieveStreamedResponseEventFixture.txtnu „[µü¤        data: {"object": "fine-tune-event", "level": "info", "message": "Created fine-tune: ft-y3OpNlc8B5qBVGCCVsLZsDST", "created_at": 1668021917}
data: {"object": "fine-tune-event", "level": "info", "message": "Fine-tune costs $0.00", "created_at": 1668021926}
data: {"object": "fine-tune-event", "level": "info", "message": "Fine-tune enqueued. Queue number: 0", "created_at": 1668021927}
data: {"object": "fine-tune-event", "level": "info", "message": "Fine-tune started", "created_at": 1668021929}
data: {"object": "fine-tune-event", "level": "info", "message": "Completed epoch 1/4", "created_at": 1668021976}
data: {"object": "fine-tune-event", "level": "info", "message": "Completed epoch 2/4", "created_at": 1668021977}
data: {"object": "fine-tune-event", "level": "info", "message": "Completed epoch 3/4", "created_at": 1668021978}
data: {"object": "fine-tune-event", "level": "info", "message": "Completed epoch 4/4", "created_at": 1668021978}
data: {"object": "fine-tune-event", "level": "info", "message": "Uploaded model: curie:ft-gehri-dev-2022-11-09-19-26-40", "created_at": 1668022001}
data: {"object": "fine-tune-event", "level": "info", "message": "Uploaded result file: file-ajLKUCMsFPrT633zqwr0eI4l", "created_at": 1668022002}
data: {"object": "fine-tune-event", "level": "info", "message": "Fine-tune succeeded", "created_at": 1668022002}
data: [DONE]
PK     S%W]n,éFø   ø   G  client/src/Testing/Responses/Fixtures/FineTunes/ListResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\FineTunes;

final class ListResponseFixture
{
    public const ATTRIBUTES = [
        'object' => 'list',
        'data'   => [
            RetrieveResponseFixture::ATTRIBUTES,
        ],
    ];
}
PK     S%W]ì½¸Ý  Ý  M  client/src/Testing/Responses/Fixtures/FineTunes/ListEventsResponseFixture.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Responses\Fixtures\FineTunes;

final class ListEventsResponseFixture
{
    public const ATTRIBUTES = [
        'object' => 'list',
        'data'   => [
            [
                'object'     => 'fine-tune-event',
                'created_at' => 1_614_807_352,
                'level'      => 'info',
                'message'    => 'Job enqueued. Waiting for jobs ahead to complete. Queue number =>  0.',
            ],
        ],
    ];
}
PK     S%W]WbÎÈ  È  9  client/src/Testing/Resources/VectorStoresTestResource.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Resources;

use OpenAI\Contracts\Resources\VectorStoresContract;
use OpenAI\Contracts\Resources\VectorStoresFileBatchesContract;
use OpenAI\Contracts\Resources\VectorStoresFilesContract;
use OpenAI\Resources\VectorStores;
use OpenAI\Responses\VectorStores\Search\VectorStoreSearchResponse;
use OpenAI\Responses\VectorStores\VectorStoreDeleteResponse;
use OpenAI\Responses\VectorStores\VectorStoreListResponse;
use OpenAI\Responses\VectorStores\VectorStoreResponse;
use OpenAI\Testing\Resources\Concerns\Testable;

final class VectorStoresTestResource implements VectorStoresContract
{
    use Testable;

    public function resource(): string
    {
        return VectorStores::class;
    }

    public function modify(string $vectorStoreId, array $parameters): VectorStoreResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function retrieve(string $vectorStoreId): VectorStoreResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function delete(string $vectorStoreId): VectorStoreDeleteResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function create(array $parameters): VectorStoreResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function list(array $parameters = []): VectorStoreListResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    /**
     * @param  array<string, mixed>  $parameters
     */
    public function search(string $vectorStoreId, array $parameters = []): VectorStoreSearchResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function files(): VectorStoresFilesContract
    {
        return new VectorStoresFilesTestResource($this->fake);
    }

    public function batches(): VectorStoresFileBatchesContract
    {
        return new VectorStoresFileBatchesTestResource($this->fake);
    }
}
PK     S%W]¶¨)@Â  Â  4  client/src/Testing/Resources/BatchesTestResource.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Resources;

use OpenAI\Contracts\Resources\BatchesContract;
use OpenAI\Resources\Batches;
use OpenAI\Responses\Batches\BatchListResponse;
use OpenAI\Responses\Batches\BatchResponse;
use OpenAI\Testing\Resources\Concerns\Testable;

final class BatchesTestResource implements BatchesContract
{
    use Testable;

    public function resource(): string
    {
        return Batches::class;
    }

    public function create(array $parameters): BatchResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function retrieve(string $id): BatchResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function cancel(string $id): BatchResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function list(array $parameters = []): BatchListResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }
}
PK     S%W]É»â#    D  client/src/Testing/Resources/VectorStoresFileBatchesTestResource.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Resources;

use OpenAI\Contracts\Resources\VectorStoresFileBatchesContract;
use OpenAI\Resources\VectorStoresFileBatches;
use OpenAI\Responses\VectorStores\FileBatches\VectorStoreFileBatchResponse;
use OpenAI\Responses\VectorStores\Files\VectorStoreFileListResponse;
use OpenAI\Testing\Resources\Concerns\Testable;

final class VectorStoresFileBatchesTestResource implements VectorStoresFileBatchesContract
{
    use Testable;

    public function resource(): string
    {
        return VectorStoresFileBatches::class;
    }

    public function retrieve(string $vectorStoreId, string $fileBatchId): VectorStoreFileBatchResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function cancel(string $vectorStoreId, string $fileBatchId): VectorStoreFileBatchResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function create(string $vectorStoreId, array $parameters): VectorStoreFileBatchResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function listFiles(string $vectorStoreId, string $fileBatchId, array $parameters = []): VectorStoreFileListResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }
}
PK     S%W]å 7?  ?  7  client/src/Testing/Resources/ContainersTestResource.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Resources;

use OpenAI\Contracts\Resources\ContainersContract;
use OpenAI\Resources\Containers;
use OpenAI\Responses\Containers\CreateContainer;
use OpenAI\Responses\Containers\DeleteContainer;
use OpenAI\Responses\Containers\ListContainers;
use OpenAI\Responses\Containers\RetrieveContainer;
use OpenAI\Testing\Resources\Concerns\Testable;

final class ContainersTestResource implements ContainersContract
{
    use Testable;

    public function resource(): string
    {
        return Containers::class;
    }

    public function create(array $parameters): CreateContainer
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function retrieve(string $id): RetrieveContainer
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function list(array $parameters = []): ListContainers
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function delete(string $id): DeleteContainer
    {
        return $this->record(__FUNCTION__, func_get_args());
    }
}
PK     S%W]¨T[<  <  6  client/src/Testing/Resources/FineTunesTestResource.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Resources;

use OpenAI\Contracts\Resources\FineTunesContract;
use OpenAI\Resources\FineTunes;
use OpenAI\Responses\FineTunes\ListEventsResponse;
use OpenAI\Responses\FineTunes\ListResponse;
use OpenAI\Responses\FineTunes\RetrieveResponse;
use OpenAI\Responses\StreamResponse;
use OpenAI\Testing\Resources\Concerns\Testable;

final class FineTunesTestResource implements FineTunesContract
{
    use Testable;

    protected function resource(): string
    {
        return FineTunes::class;
    }

    public function create(array $parameters): RetrieveResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function list(): ListResponse
    {
        return $this->record(__FUNCTION__);
    }

    public function retrieve(string $fineTuneId): RetrieveResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function cancel(string $fineTuneId): RetrieveResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function listEvents(string $fineTuneId): ListEventsResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function listEventsStreamed(string $fineTuneId): StreamResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }
}
PK     S%W]¿ÌŒ  Œ  2  client/src/Testing/Resources/FilesTestResource.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Resources;

use OpenAI\Contracts\Resources\FilesContract;
use OpenAI\Resources\Files;
use OpenAI\Responses\Files\CreateResponse;
use OpenAI\Responses\Files\DeleteResponse;
use OpenAI\Responses\Files\ListResponse;
use OpenAI\Responses\Files\RetrieveResponse;
use OpenAI\Testing\Resources\Concerns\Testable;

final class FilesTestResource implements FilesContract
{
    use Testable;

    protected function resource(): string
    {
        return Files::class;
    }

    public function list(array $parameters = []): ListResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function retrieve(string $file): RetrieveResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function download(string $file): string
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function upload(array $parameters): CreateResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function delete(string $file): DeleteResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }
}
PK     S%W]±ˆA—l  l  3  client/src/Testing/Resources/ImagesTestResource.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Resources;

use OpenAI\Contracts\Resources\ImagesContract;
use OpenAI\Resources\Images;
use OpenAI\Responses\Images\CreateResponse;
use OpenAI\Responses\Images\EditResponse;
use OpenAI\Responses\Images\VariationResponse;
use OpenAI\Testing\Resources\Concerns\Testable;

final class ImagesTestResource implements ImagesContract
{
    use Testable;

    protected function resource(): string
    {
        return Images::class;
    }

    public function create(array $parameters): CreateResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function edit(array $parameters): EditResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function variation(array $parameters): VariationResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }
}
PK     S%W]—¤ÇgÅ  Å  7  client/src/Testing/Resources/AssistantsTestResource.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Resources;

use OpenAI\Contracts\Resources\AssistantsContract;
use OpenAI\Resources\Assistants;
use OpenAI\Responses\Assistants\AssistantDeleteResponse;
use OpenAI\Responses\Assistants\AssistantListResponse;
use OpenAI\Responses\Assistants\AssistantResponse;
use OpenAI\Testing\Resources\Concerns\Testable;

final class AssistantsTestResource implements AssistantsContract
{
    use Testable;

    public function resource(): string
    {
        return Assistants::class;
    }

    public function create(array $parameters): AssistantResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function retrieve(string $id): AssistantResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function modify(string $id, array $parameters): AssistantResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function delete(string $id): AssistantDeleteResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function list(array $parameters = []): AssistantListResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }
}
PK     S%W]BÄ5ïð  ð  5  client/src/Testing/Resources/RealtimeTestResource.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Resources;

use OpenAI\Contracts\Resources\RealtimeContract;
use OpenAI\Resources\Realtime;
use OpenAI\Responses\Realtime\SessionResponse;
use OpenAI\Responses\Realtime\TranscriptionSessionResponse;
use OpenAI\Testing\Resources\Concerns\Testable;

final class RealtimeTestResource implements RealtimeContract
{
    use Testable;

    public function resource(): string
    {
        return Realtime::class;
    }

    public function token(array $parameters = []): SessionResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function transcribeToken(array $parameters = []): TranscriptionSessionResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }
}
PK     S%W]TÒßü÷  ÷  >  client/src/Testing/Resources/VectorStoresFilesTestResource.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Resources;

use OpenAI\Contracts\Resources\VectorStoresFilesContract;
use OpenAI\Resources\VectorStoresFiles;
use OpenAI\Responses\VectorStores\Files\VectorStoreFileDeleteResponse;
use OpenAI\Responses\VectorStores\Files\VectorStoreFileListResponse;
use OpenAI\Responses\VectorStores\Files\VectorStoreFileResponse;
use OpenAI\Testing\Resources\Concerns\Testable;

final class VectorStoresFilesTestResource implements VectorStoresFilesContract
{
    use Testable;

    public function resource(): string
    {
        return VectorStoresFiles::class;
    }

    public function retrieve(string $vectorStoreId, string $fileId): VectorStoreFileResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function delete(string $vectorStoreId, string $fileId): VectorStoreFileDeleteResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function create(string $vectorStoreId, array $parameters): VectorStoreFileResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function list(string $vectorStoreId, array $parameters = []): VectorStoreFileListResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }
}
PK     S%W]Æsn¿™  ™  2  client/src/Testing/Resources/Concerns/Testable.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Resources\Concerns;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseStreamContract;
use OpenAI\Testing\ClientFake;
use OpenAI\Testing\Requests\TestRequest;

trait Testable
{
    public function __construct(protected ClientFake $fake) {}

    abstract protected function resource(): string;

    /**
     * @param  array<string, mixed>  $args
     */
    protected function record(string $method, array $args = []): ResponseContract|ResponseStreamContract|string
    {
        return $this->fake->record(new TestRequest($this->resource(), $method, $args));
    }

    public function assertSent(callable|int|null $callback = null): void
    {
        $this->fake->assertSent($this->resource(), $callback);
    }

    public function assertNotSent(callable|int|null $callback = null): void
    {
        $this->fake->assertNotSent($this->resource(), $callback);
    }
}
PK     S%W]§b…ä  ä  7  client/src/Testing/Resources/FineTuningTestResource.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Resources;

use OpenAI\Contracts\Resources\FineTuningContract;
use OpenAI\Resources\FineTuning;
use OpenAI\Responses\FineTuning\ListJobEventsResponse;
use OpenAI\Responses\FineTuning\ListJobsResponse;
use OpenAI\Responses\FineTuning\RetrieveJobResponse;
use OpenAI\Testing\Resources\Concerns\Testable;

final class FineTuningTestResource implements FineTuningContract
{
    use Testable;

    protected function resource(): string
    {
        return FineTuning::class;
    }

    public function createJob(array $parameters): RetrieveJobResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function listJobs(array $parameters = []): ListJobsResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function retrieveJob(string $jobId): RetrieveJobResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function cancelJob(string $jobId): RetrieveJobResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function listJobEvents(string $jobId, array $parameters = []): ListJobEventsResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }
}
PK     S%W]ãž}t  t  6  client/src/Testing/Resources/ResponsesTestResource.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Resources;

use OpenAI\Contracts\Resources\ResponsesContract;
use OpenAI\Resources\Responses;
use OpenAI\Responses\Responses\CreateResponse;
use OpenAI\Responses\Responses\DeleteResponse;
use OpenAI\Responses\Responses\ListInputItems;
use OpenAI\Responses\Responses\RetrieveResponse;
use OpenAI\Responses\StreamResponse;
use OpenAI\Testing\Resources\Concerns\Testable;

final class ResponsesTestResource implements ResponsesContract
{
    use Testable;

    public function resource(): string
    {
        return Responses::class;
    }

    public function create(array $parameters): CreateResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function createStreamed(array $parameters): StreamResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function retrieve(string $id): RetrieveResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function list(string $id, array $parameters = []): ListInputItems
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function cancel(string $id): RetrieveResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function delete(string $id): DeleteResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }
}
PK     S%W]9©M¾Ô  Ô  8  client/src/Testing/Resources/CompletionsTestResource.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Resources;

use OpenAI\Contracts\Resources\CompletionsContract;
use OpenAI\Resources\Completions;
use OpenAI\Responses\Completions\CreateResponse;
use OpenAI\Responses\StreamResponse;
use OpenAI\Testing\Resources\Concerns\Testable;

final class CompletionsTestResource implements CompletionsContract
{
    use Testable;

    protected function resource(): string
    {
        return Completions::class;
    }

    public function create(array $parameters): CreateResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function createStreamed(array $parameters): StreamResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }
}
PK     S%W]ÚV  V  4  client/src/Testing/Resources/ThreadsTestResource.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Resources;

use OpenAI\Contracts\Resources\ThreadsContract;
use OpenAI\Resources\Threads;
use OpenAI\Responses\StreamResponse;
use OpenAI\Responses\Threads\Runs\ThreadRunResponse;
use OpenAI\Responses\Threads\ThreadDeleteResponse;
use OpenAI\Responses\Threads\ThreadResponse;
use OpenAI\Testing\Resources\Concerns\Testable;

final class ThreadsTestResource implements ThreadsContract
{
    use Testable;

    public function resource(): string
    {
        return Threads::class;
    }

    public function create(array $parameters): ThreadResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function createAndRun(array $parameters): ThreadRunResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function createAndRunStreamed(array $parameters): StreamResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function retrieve(string $id): ThreadResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function modify(string $id, array $parameters): ThreadResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function delete(string $id): ThreadDeleteResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function messages(): ThreadsMessagesTestResource
    {
        return new ThreadsMessagesTestResource($this->fake);
    }

    public function runs(): ThreadsRunsTestResource
    {
        return new ThreadsRunsTestResource($this->fake);
    }
}
PK     S%W] z¢±  ±  8  client/src/Testing/Resources/ThreadsRunsTestResource.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Resources;

use OpenAI\Contracts\Resources\ThreadsRunsContract;
use OpenAI\Resources\ThreadsRuns;
use OpenAI\Responses\StreamResponse;
use OpenAI\Responses\Threads\Runs\ThreadRunListResponse;
use OpenAI\Responses\Threads\Runs\ThreadRunResponse;
use OpenAI\Testing\Resources\Concerns\Testable;

final class ThreadsRunsTestResource implements ThreadsRunsContract
{
    use Testable;

    public function resource(): string
    {
        return ThreadsRuns::class;
    }

    public function create(string $threadId, array $parameters): ThreadRunResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function createStreamed(string $threadId, array $parameters): StreamResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function retrieve(string $threadId, string $runId): ThreadRunResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function modify(string $threadId, string $runId, array $parameters): ThreadRunResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function submitToolOutputs(string $threadId, string $runId, array $parameters): ThreadRunResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function submitToolOutputsStreamed(string $threadId, string $runId, array $parameters): StreamResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function cancel(string $threadId, string $runId): ThreadRunResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function list(string $threadId, array $parameters = []): ThreadRunListResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function steps(): ThreadsRunsStepsTestResource
    {
        return new ThreadsRunsStepsTestResource($this->fake);
    }
}
PK     S%W]x`,ö    <  client/src/Testing/Resources/ThreadsMessagesTestResource.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Resources;

use OpenAI\Contracts\Resources\ThreadsMessagesContract;
use OpenAI\Resources\ThreadsMessages;
use OpenAI\Responses\Threads\Messages\ThreadMessageDeleteResponse;
use OpenAI\Responses\Threads\Messages\ThreadMessageListResponse;
use OpenAI\Responses\Threads\Messages\ThreadMessageResponse;
use OpenAI\Testing\Resources\Concerns\Testable;

final class ThreadsMessagesTestResource implements ThreadsMessagesContract
{
    use Testable;

    public function resource(): string
    {
        return ThreadsMessages::class;
    }

    public function create(string $threadId, array $parameters): ThreadMessageResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function retrieve(string $threadId, string $messageId): ThreadMessageResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function modify(string $threadId, string $messageId, array $parameters): ThreadMessageResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function delete(string $threadId, string $messageId): ThreadMessageDeleteResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function list(string $threadId, array $parameters = []): ThreadMessageListResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }
}
PK     S%W]rv±õ    7  client/src/Testing/Resources/EmbeddingsTestResource.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Resources;

use OpenAI\Contracts\Resources\EmbeddingsContract;
use OpenAI\Resources\Embeddings;
use OpenAI\Responses\Embeddings\CreateResponse;
use OpenAI\Testing\Resources\Concerns\Testable;

final class EmbeddingsTestResource implements EmbeddingsContract
{
    use Testable;

    protected function resource(): string
    {
        return Embeddings::class;
    }

    public function create(array $parameters): CreateResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }
}
PK     S%W]ÅˆYÞ?  ?  3  client/src/Testing/Resources/ModelsTestResource.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Resources;

use OpenAI\Contracts\Resources\ModelsContract;
use OpenAI\Resources\Models;
use OpenAI\Responses\Models\DeleteResponse;
use OpenAI\Responses\Models\ListResponse;
use OpenAI\Responses\Models\RetrieveResponse;
use OpenAI\Testing\Resources\Concerns\Testable;

final class ModelsTestResource implements ModelsContract
{
    use Testable;

    protected function resource(): string
    {
        return Models::class;
    }

    public function list(): ListResponse
    {
        return $this->record(__FUNCTION__);
    }

    public function retrieve(string $model): RetrieveResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function delete(string $model): DeleteResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }
}
PK     S%W]•û  û  2  client/src/Testing/Resources/EditsTestResource.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Resources;

use OpenAI\Contracts\Resources\EditsContract;
use OpenAI\Resources\Edits;
use OpenAI\Responses\Edits\CreateResponse;
use OpenAI\Testing\Resources\Concerns\Testable;

final class EditsTestResource implements EditsContract
{
    use Testable;

    protected function resource(): string
    {
        return Edits::class;
    }

    public function create(array $parameters): CreateResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }
}
PK     S%W]îˆÐéÍ  Í  2  client/src/Testing/Resources/AudioTestResource.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Resources;

use OpenAI\Contracts\Resources\AudioContract;
use OpenAI\Resources\Audio;
use OpenAI\Responses\Audio\SpeechStreamResponse;
use OpenAI\Responses\Audio\TranscriptionResponse;
use OpenAI\Responses\Audio\TranslationResponse;
use OpenAI\Responses\StreamResponse;
use OpenAI\Testing\Resources\Concerns\Testable;

final class AudioTestResource implements AudioContract
{
    use Testable;

    protected function resource(): string
    {
        return Audio::class;
    }

    public function speech(array $parameters): string
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function speechStreamed(array $parameters): SpeechStreamResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function transcribe(array $parameters): TranscriptionResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function transcribeStreamed(array $parameters): StreamResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function translate(array $parameters): TranslationResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }
}
PK     S%W]Éb¤Ô    8  client/src/Testing/Resources/ModerationsTestResource.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Resources;

use OpenAI\Contracts\Resources\ModerationsContract;
use OpenAI\Resources\Moderations;
use OpenAI\Responses\Moderations\CreateResponse;
use OpenAI\Testing\Resources\Concerns\Testable;

final class ModerationsTestResource implements ModerationsContract
{
    use Testable;

    protected function resource(): string
    {
        return Moderations::class;
    }

    public function create(array $parameters): CreateResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }
}
PK     S%W]~dÏZ^  ^  =  client/src/Testing/Resources/ThreadsRunsStepsTestResource.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Resources;

use OpenAI\Contracts\Resources\ThreadsRunsStepsContract;
use OpenAI\Resources\ThreadsRunsSteps;
use OpenAI\Responses\Threads\Runs\Steps\ThreadRunStepListResponse;
use OpenAI\Responses\Threads\Runs\Steps\ThreadRunStepResponse;
use OpenAI\Testing\Resources\Concerns\Testable;

class ThreadsRunsStepsTestResource implements ThreadsRunsStepsContract
{
    use Testable;

    public function resource(): string
    {
        return ThreadsRunsSteps::class;
    }

    public function retrieve(string $threadId, string $runId, string $stepId): ThreadRunStepResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function list(string $threadId, string $runId, array $parameters = []): ThreadRunStepListResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }
}
PK     S%W]yypª  ª  1  client/src/Testing/Resources/ChatTestResource.phpnu „[µü¤        <?php

namespace OpenAI\Testing\Resources;

use OpenAI\Contracts\Resources\ChatContract;
use OpenAI\Resources\Chat;
use OpenAI\Responses\Chat\CreateResponse;
use OpenAI\Responses\StreamResponse;
use OpenAI\Testing\Resources\Concerns\Testable;

final class ChatTestResource implements ChatContract
{
    use Testable;

    protected function resource(): string
    {
        return Chat::class;
    }

    public function create(array $parameters): CreateResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }

    public function createStreamed(array $parameters): StreamResponse
    {
        return $this->record(__FUNCTION__, func_get_args());
    }
}
PK     S%W]f)Þ'†   †   /  client/src/Exceptions/UnknownEventException.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Exceptions;

use Exception;

final class UnknownEventException extends Exception {}
PK     S%W]^˜ä„  „  .  client/src/Exceptions/TransporterException.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Exceptions;

use Exception;
use Psr\Http\Client\ClientExceptionInterface;

final class TransporterException extends Exception
{
    /**
     * Creates a new Exception instance.
     */
    public function __construct(ClientExceptionInterface $exception)
    {
        parent::__construct($exception->getMessage(), 0, $exception);
    }
}
PK     S%W]€-¥x`  `  0  client/src/Exceptions/UnserializableResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Exceptions;

use Exception;
use JsonException;

final class UnserializableResponse extends Exception
{
    /**
     * Creates a new Exception instance.
     */
    public function __construct(JsonException $exception)
    {
        parent::__construct($exception->getMessage(), 0, $exception);
    }
}
PK     S%W]	¢"  "  (  client/src/Exceptions/ErrorException.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Exceptions;

use Exception;

final class ErrorException extends Exception
{
    /**
     * Creates a new Exception instance.
     *
     * @param  array{message: string|array<int, string>, type: ?string, code: string|int|null}  $contents
     */
    public function __construct(private readonly array $contents, private readonly int $statusCode)
    {
        $message = ($contents['message'] ?: (string) $this->contents['code']) ?: 'Unknown error';

        if (is_array($message)) {
            $message = implode(PHP_EOL, $message);
        }

        parent::__construct($message);
    }

    /**
     * Returns the HTTP status code.
     *
     * **Note: For streamed requests it might be 200 even in case of an error.**
     */
    public function getStatusCode(): int
    {
        return $this->statusCode;
    }

    /**
     * Returns the error message.
     */
    public function getErrorMessage(): string
    {
        return $this->getMessage();
    }

    /**
     * Returns the error type.
     */
    public function getErrorType(): ?string
    {
        return $this->contents['type'];
    }

    /**
     * Returns the error code.
     */
    public function getErrorCode(): string|int|null
    {
        return $this->contents['code'];
    }
}
PK     S%W]’é.‰   ‰   2  client/src/Exceptions/InvalidArgumentException.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Exceptions;

use Exception;

final class InvalidArgumentException extends Exception {}
PK     S%W]tè9Z¼   ¼   9  client/src/Enums/Moderations/CategoryAppliedInputType.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Enums\Moderations;

enum CategoryAppliedInputType: string
{
    case Text = 'text';
    case Image = 'image';
    case Audio = 'audio';
}
PK     S%W]TN+n  n  )  client/src/Enums/Moderations/Category.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Enums\Moderations;

enum Category: string
{
    case Hate = 'hate';
    case HateThreatening = 'hate/threatening';
    case Harassment = 'harassment';
    case HarassmentThreatening = 'harassment/threatening';
    case Illicit = 'illicit';
    case IllicitViolent = 'illicit/violent';
    case SelfHarm = 'self-harm';
    case SelfHarmIntent = 'self-harm/intent';
    case SelfHarmInstructions = 'self-harm/instructions';
    case Sexual = 'sexual';
    case SexualMinors = 'sexual/minors';
    case Violence = 'violence';
    case ViolenceGraphic = 'violence/graphic';
}
PK     S%W]cû'"ì   ì   ,  client/src/Enums/Transporter/ContentType.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Enums\Transporter;

/**
 * @internal
 */
enum ContentType: string
{
    case JSON = 'application/json';
    case MULTIPART = 'multipart/form-data';
    case TEXT_PLAIN = 'text/plain';
}
PK     S%W]©Ó   Ó   '  client/src/Enums/Transporter/Method.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Enums\Transporter;

/**
 * @internal
 */
enum Method: string
{
    case GET = 'GET';
    case POST = 'POST';
    case PUT = 'PUT';
    case DELETE = 'DELETE';
}
PK     S%W]™::ž   ž   4  client/src/Enums/FineTuning/FineTuningEventLevel.phpnu „[µü¤        <?php

namespace OpenAI\Enums\FineTuning;

enum FineTuningEventLevel: string
{
    case Info = 'info';
    case Warning = 'warn';
    case Error = 'error';
}
PK     S%W]Kô‰wM  M  +  client/src/Transporters/HttpTransporter.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Transporters;

use Closure;
use GuzzleHttp\Exception\ClientException;
use JsonException;
use OpenAI\Contracts\TransporterContract;
use OpenAI\Enums\Transporter\ContentType;
use OpenAI\Exceptions\ErrorException;
use OpenAI\Exceptions\TransporterException;
use OpenAI\Exceptions\UnserializableResponse;
use OpenAI\ValueObjects\Transporter\BaseUri;
use OpenAI\ValueObjects\Transporter\Headers;
use OpenAI\ValueObjects\Transporter\Payload;
use OpenAI\ValueObjects\Transporter\QueryParams;
use OpenAI\ValueObjects\Transporter\Response;
use Psr\Http\Client\ClientExceptionInterface;
use Psr\Http\Client\ClientInterface;
use Psr\Http\Message\ResponseInterface;

/**
 * @internal
 */
final class HttpTransporter implements TransporterContract
{
    /**
     * Creates a new Http Transporter instance.
     */
    public function __construct(
        private readonly ClientInterface $client,
        private readonly BaseUri $baseUri,
        private readonly Headers $headers,
        private readonly QueryParams $queryParams,
        private readonly Closure $streamHandler,
    ) {
        // ..
    }

    /**
     * {@inheritDoc}
     */
    public function requestObject(Payload $payload): Response
    {
        $request = $payload->toRequest($this->baseUri, $this->headers, $this->queryParams);

        $response = $this->sendRequest(fn (): \Psr\Http\Message\ResponseInterface => $this->client->sendRequest($request));

        $contents = (string) $response->getBody();

        if (str_contains($response->getHeaderLine('Content-Type'), ContentType::TEXT_PLAIN->value)) {
            return Response::from($contents, $response->getHeaders());
        }

        $this->throwIfJsonError($response, $contents);

        try {
            /** @var array{error?: array{message: string, type: string, code: string}} $data */
            $data = json_decode($contents, true, flags: JSON_THROW_ON_ERROR);
        } catch (JsonException $jsonException) {
            throw new UnserializableResponse($jsonException);
        }

        return Response::from($data, $response->getHeaders());
    }

    /**
     * {@inheritDoc}
     */
    public function requestContent(Payload $payload): string
    {
        $request = $payload->toRequest($this->baseUri, $this->headers, $this->queryParams);

        $response = $this->sendRequest(fn (): \Psr\Http\Message\ResponseInterface => $this->client->sendRequest($request));

        $contents = (string) $response->getBody();

        $this->throwIfJsonError($response, $contents);

        return $contents;
    }

    /**
     * {@inheritDoc}
     */
    public function requestStream(Payload $payload): ResponseInterface
    {
        $request = $payload->toRequest($this->baseUri, $this->headers, $this->queryParams);

        $response = $this->sendRequest(fn () => ($this->streamHandler)($request));

        $this->throwIfJsonError($response, $response);

        return $response;
    }

    private function sendRequest(Closure $callable): ResponseInterface
    {
        try {
            return $callable();
        } catch (ClientExceptionInterface $clientException) {
            if ($clientException instanceof ClientException) {
                $this->throwIfJsonError($clientException->getResponse(), (string) $clientException->getResponse()->getBody());
            }

            throw new TransporterException($clientException);
        }
    }

    private function throwIfJsonError(ResponseInterface $response, string|ResponseInterface $contents): void
    {
        if ($response->getStatusCode() < 400) {
            return;
        }

        if (! str_contains($response->getHeaderLine('Content-Type'), ContentType::JSON->value)) {
            return;
        }

        $statusCode = $response->getStatusCode();

        if ($contents instanceof ResponseInterface) {
            $contents = (string) $contents->getBody();
        }

        try {
            /** @var array{error?: array{message: string|array<int, string>, type: string, code: string}} $response */
            $response = json_decode($contents, true, flags: JSON_THROW_ON_ERROR);

            if (isset($response['error'])) {
                throw new ErrorException($response['error'], $statusCode);
            }
        } catch (JsonException $jsonException) {
            throw new UnserializableResponse($jsonException);
        }
    }
}
PK     S%W]Ö¡ØÛ  Û  ,  client/src/Contracts/TransporterContract.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Contracts;

use OpenAI\Exceptions\ErrorException;
use OpenAI\Exceptions\TransporterException;
use OpenAI\Exceptions\UnserializableResponse;
use OpenAI\ValueObjects\Transporter\Payload;
use OpenAI\ValueObjects\Transporter\Response;
use Psr\Http\Message\ResponseInterface;

/**
 * @internal
 */
interface TransporterContract
{
    /**
     * Sends a request to a server.
     *
     * @return Response<array<array-key, mixed>|string>
     *
     * @throws ErrorException|UnserializableResponse|TransporterException
     */
    public function requestObject(Payload $payload): Response;

    /**
     * Sends a content request to a server.
     *
     * @throws ErrorException|TransporterException
     */
    public function requestContent(Payload $payload): string;

    /**
     * Sends a stream request to a server.
     **
     * @throws ErrorException
     */
    public function requestStream(Payload $payload): ResponseInterface;
}
PK     S%W]1ˆÈ   È   ;  client/src/Contracts/ResponseHasMetaInformationContract.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Contracts;

use OpenAI\Responses\Meta\MetaInformation;

interface ResponseHasMetaInformationContract
{
    public function meta(): MetaInformation;
}
PK     S%W].
b(    )  client/src/Contracts/ResponseContract.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Contracts;

use ArrayAccess;

/**
 * @template TArray of array
 *
 * @extends ArrayAccess<key-of<TArray>, value-of<TArray>>
 *
 * @internal
 */
interface ResponseContract extends ArrayAccess
{
    /**
     * Returns the array representation of the Response.
     *
     * @return TArray
     */
    public function toArray(): array;

    /**
     * @param  key-of<TArray>  $offset
     */
    public function offsetExists(mixed $offset): bool;

    /**
     * @template TOffsetKey of key-of<TArray>
     * @param  TOffsetKey  $offset
     *
     * @return TArray[TOffsetKey]
     */
    public function offsetGet(mixed $offset): mixed;

    /**
     * @template TOffsetKey of key-of<TArray>
     * @param  TOffsetKey  $offset
     * @param  TArray[TOffsetKey] $value
     */
    public function offsetSet(mixed $offset, mixed $value): never;

    /**
     * @template TOffsetKey of key-of<TArray>
     * @param  TOffsetKey  $offset
     */
    public function offsetUnset(mixed $offset): never;
}
PK     S%W]&S®F&  &  0  client/src/Contracts/MetaInformationContract.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Contracts;

use ArrayAccess;

/**
 * @template TArray of array
 *
 * @extends ArrayAccess<key-of<TArray>, value-of<TArray>>
 *
 * @internal
 */
interface MetaInformationContract extends ArrayAccess
{
    /**
     * Returns the array representation of the meta information.
     *
     * @return TArray
     */
    public function toArray(): array;

    /**
     * @param  key-of<TArray>  $offset
     */
    public function offsetExists(mixed $offset): bool;

    /**
     * @template TOffsetKey of key-of<TArray>
     * @param  TOffsetKey  $offset
     *
     * @return TArray[TOffsetKey]
     */
    public function offsetGet(mixed $offset): mixed;

    /**
     * @template TOffsetKey of key-of<TArray>
     * @param  TOffsetKey  $offset
     * @param  TArray[TOffsetKey] $value
     */
    public function offsetSet(mixed $offset, mixed $value): never;

    /**
     * @template TOffsetKey of key-of<TArray>
     * @param  TOffsetKey  $offset
     */
    public function offsetUnset(mixed $offset): never;
}
PK     S%W]ž¸D  D  :  client/src/Contracts/Resources/ThreadsMessagesContract.phpnu „[µü¤        <?php

namespace OpenAI\Contracts\Resources;

use OpenAI\Responses\Threads\Messages\ThreadMessageDeleteResponse;
use OpenAI\Responses\Threads\Messages\ThreadMessageListResponse;
use OpenAI\Responses\Threads\Messages\ThreadMessageResponse;

interface ThreadsMessagesContract
{
    /**
     * Create a message.
     *
     * @see https://platform.openai.com/docs/api-reference/messages/createMessage
     *
     * @param  array<string, mixed>  $parameters
     */
    public function create(string $threadId, array $parameters): ThreadMessageResponse;

    /**
     * Retrieve a message.
     *
     * @see https://platform.openai.com/docs/api-reference/messages/getMessage
     */
    public function retrieve(string $threadId, string $messageId): ThreadMessageResponse;

    /**
     * Modifies a message.
     *
     * @see https://platform.openai.com/docs/api-reference/messages/modifyMessage
     *
     * @param  array<string, mixed>  $parameters
     */
    public function modify(string $threadId, string $messageId, array $parameters): ThreadMessageResponse;

    /**
     * Deletes a message.
     *
     * @see https://platform.openai.com/docs/api-reference/messages/deleteMessage
     */
    public function delete(string $threadId, string $messageId): ThreadMessageDeleteResponse;

    /**
     * Returns a list of messages for a given thread.
     *
     * @see https://platform.openai.com/docs/api-reference/messages/listMessages
     *
     * @param  array<string, mixed>  $parameters
     */
    public function list(string $threadId, array $parameters = []): ThreadMessageListResponse;
}
PK     S%W]Êudˆ2	  2	  7  client/src/Contracts/Resources/VectorStoresContract.phpnu „[µü¤        <?php

namespace OpenAI\Contracts\Resources;

use OpenAI\Responses\VectorStores\Search\VectorStoreSearchResponse;
use OpenAI\Responses\VectorStores\VectorStoreDeleteResponse;
use OpenAI\Responses\VectorStores\VectorStoreListResponse;
use OpenAI\Responses\VectorStores\VectorStoreResponse;

interface VectorStoresContract
{
    /**
     * Create a vector store
     *
     * @see https://platform.openai.com/docs/api-reference/vector-stores/create
     *
     * @param  array<string, mixed>  $parameters
     */
    public function create(array $parameters): VectorStoreResponse;

    /**
     * Returns a list of vector stores.
     *
     * @see https://platform.openai.com/docs/api-reference/vector-stores/list
     *
     * @param  array<string, mixed>  $parameters
     */
    public function list(array $parameters = []): VectorStoreListResponse;

    /**
     * Retrieves a vector store.
     *
     * @see https://platform.openai.com/docs/api-reference/vector-stores/retrieve
     */
    public function retrieve(string $vectorStoreId): VectorStoreResponse;

    /**
     * Modify a vector store
     *
     * @see https://platform.openai.com/docs/api-reference/vector-stores/modify
     *
     * @param  array<string, mixed>  $parameters
     */
    public function modify(string $vectorStoreId, array $parameters): VectorStoreResponse;

    /**
     * Delete a vector store.
     *
     * https://platform.openai.com/docs/api-reference/vector-stores/delete
     */
    public function delete(string $vectorStoreId): VectorStoreDeleteResponse;

    /**
     * Manage the files related to the vector store
     *
     * @see https://platform.openai.com/docs/api-reference/vector-stores-files
     */
    public function files(): VectorStoresFilesContract;

    /**
     * Manage the file batches related to the vector store
     *
     * @see https://platform.openai.com/docs/api-reference/vector-stores-file-batches
     */
    public function batches(): VectorStoresFileBatchesContract;

    /**
     * Search a vector store for relevant chunks based on a query and file attributes filter.
     *
     * @see https://platform.openai.com/docs/api-reference/vector-stores/search
     *
     * @param  array<string, mixed>  $parameters
     */
    public function search(string $vectorStoreId, array $parameters = []): VectorStoreSearchResponse;
}
PK     S%W]ÊýO  O  3  client/src/Contracts/Resources/RealtimeContract.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Contracts\Resources;

use OpenAI\Responses\Realtime\SessionResponse;
use OpenAI\Responses\Realtime\TranscriptionSessionResponse;

interface RealtimeContract
{
    /**
     * Create an ephemeral API token for real time sessions.
     *
     * @see https://platform.openai.com/docs/api-reference/realtime-sessions/create
     *
     * @param  array<string, mixed>  $parameters
     */
    public function token(array $parameters = []): SessionResponse;

    /**
     * Create an ephemeral API token for real time transcription sessions.
     *
     * @see https://platform.openai.com/docs/api-reference/realtime-sessions/create-transcription
     *
     * @param  array<string, mixed>  $parameters
     */
    public function transcribeToken(array $parameters = []): TranscriptionSessionResponse;
}
PK     S%W]Û°$ðÂ  Â  B  client/src/Contracts/Resources/VectorStoresFileBatchesContract.phpnu „[µü¤        <?php

namespace OpenAI\Contracts\Resources;

use OpenAI\Responses\VectorStores\FileBatches\VectorStoreFileBatchResponse;
use OpenAI\Responses\VectorStores\Files\VectorStoreFileListResponse;

interface VectorStoresFileBatchesContract
{
    /**
     * Create a file batch on a vector store
     *
     * @see https://platform.openai.com/docs/api-reference/vector-stores-file-batches/createBatch
     *
     * @param  array<string, mixed>  $parameters
     */
    public function create(string $vectorStoreId, array $parameters): VectorStoreFileBatchResponse;

    /**
     * Retrieves a file batch within a vector store.
     *
     * @see https://platform.openai.com/docs/api-reference/vector-stores-file-batches/getBatch
     */
    public function retrieve(string $vectorStoreId, string $fileBatchId): VectorStoreFileBatchResponse;

    /**
     * Cancel a vector store file batch
     *
     * @see https://platform.openai.com/docs/api-reference/vector-stores-file-batches/cancelBatch
     */
    public function cancel(string $vectorStoreId, string $fileBatchId): VectorStoreFileBatchResponse;

    /**
     * Lists the files within a file batch within a vector store
     *
     * @see https://platform.openai.com/docs/api-reference/vector-stores-file-batches/listBatchFiles
     *
     * @param  array<string, mixed>  $parameters
     */
    public function listFiles(string $vectorStoreId, string $fileBatchId, array $parameters = []): VectorStoreFileListResponse;
}
PK     S%W]_šÖux  x  4  client/src/Contracts/Resources/FineTunesContract.phpnu „[µü¤        <?php

namespace OpenAI\Contracts\Resources;

use OpenAI\Responses\FineTunes\ListEventsResponse;
use OpenAI\Responses\FineTunes\ListResponse;
use OpenAI\Responses\FineTunes\RetrieveResponse;
use OpenAI\Responses\FineTunes\RetrieveStreamedResponseEvent;
use OpenAI\Responses\StreamResponse;

interface FineTunesContract
{
    /**
     * Creates a job that fine-tunes a specified model from a given dataset.
     *
     * Response includes details of the enqueued job including job status and the name of the fine-tuned models once complete.
     *
     * @see https://platform.openai.com/docs/api-reference/fine-tunes/create
     *
     * @param  array<string, mixed>  $parameters
     */
    public function create(array $parameters): RetrieveResponse;

    /**
     * List your organization's fine-tuning jobs.
     *
     * @see https://platform.openai.com/docs/api-reference/fine-tunes/list
     */
    public function list(): ListResponse;

    /**
     * Gets info about the fine-tune job.
     *
     * @see https://platform.openai.com/docs/api-reference/fine-tunes/list
     */
    public function retrieve(string $fineTuneId): RetrieveResponse;

    /**
     * Immediately cancel a fine-tune job.
     *
     * @see https://platform.openai.com/docs/api-reference/fine-tunes/cancel
     */
    public function cancel(string $fineTuneId): RetrieveResponse;

    /**
     * Get fine-grained status updates for a fine-tune job.
     *
     * @see https://platform.openai.com/docs/api-reference/fine-tunes/events
     */
    public function listEvents(string $fineTuneId): ListEventsResponse;

    /**
     * Get streamed fine-grained status updates for a fine-tune job.
     *
     * @see https://platform.openai.com/docs/api-reference/fine-tunes/events
     *
     * @return StreamResponse<RetrieveStreamedResponseEvent>
     */
    public function listEventsStreamed(string $fineTuneId): StreamResponse;
}
PK     S%W]ÿß/ïe  e  0  client/src/Contracts/Resources/EditsContract.phpnu „[µü¤        <?php

namespace OpenAI\Contracts\Resources;

use OpenAI\Responses\Edits\CreateResponse;

interface EditsContract
{
    /**
     * Creates a new edit for the provided input, instruction, and parameters.
     *
     *
     *
     * @deprecated OpenAI has deprecated this endpoint and will stop working by January 4, 2024.
     * https://openai.com/blog/gpt-4-api-general-availability#deprecation-of-the-edits-api
     * @see https://platform.openai.com/docs/api-reference/edits/create
     *
     * @param  array<string, mixed>  $parameters
     */
    public function create(array $parameters): CreateResponse;
}
PK     S%W]lÕ¸™ÿ  ÿ  ;  client/src/Contracts/Resources/ThreadsRunsStepsContract.phpnu „[µü¤        <?php

namespace OpenAI\Contracts\Resources;

use OpenAI\Responses\Threads\Runs\Steps\ThreadRunStepListResponse;
use OpenAI\Responses\Threads\Runs\Steps\ThreadRunStepResponse;

interface ThreadsRunsStepsContract
{
    /**
     * Retrieves a run step.
     *
     * @see https://platform.openai.com/docs/api-reference/runs/getRunStep
     */
    public function retrieve(string $threadId, string $runId, string $stepId): ThreadRunStepResponse;

    /**
     * Returns a list of run steps belonging to a run.
     *
     * @see https://platform.openai.com/docs/api-reference/runs/listRunSteps
     *
     * @param  array<string, mixed>  $parameters
     */
    public function list(string $threadId, string $runId, array $parameters = []): ThreadRunStepListResponse;
}
PK     S%W]ÖËãŸ  Ÿ  5  client/src/Contracts/Resources/FineTuningContract.phpnu „[µü¤        <?php

namespace OpenAI\Contracts\Resources;

use OpenAI\Responses\FineTuning\ListJobEventsResponse;
use OpenAI\Responses\FineTuning\ListJobsResponse;
use OpenAI\Responses\FineTuning\RetrieveJobResponse;

interface FineTuningContract
{
    /**
     * Creates a job that fine-tunes a specified model from a given dataset.
     *
     * Response includes details of the enqueued job including job status and the name of the fine-tuned models once complete.
     *
     * @see https://platform.openai.com/docs/api-reference/fine-tuning/create
     *
     * @param  array<string, mixed>  $parameters
     */
    public function createJob(array $parameters): RetrieveJobResponse;

    /**
     * List your organization's fine-tuning jobs.
     *
     * @see https://platform.openai.com/docs/api-reference/fine-tuning/undefined
     *
     * @param  array<string, mixed>  $parameters
     */
    public function listJobs(array $parameters = []): ListJobsResponse;

    /**
     * Get info about a fine-tuning job.
     *
     * @see https://platform.openai.com/docs/api-reference/fine-tuning/retrieve
     */
    public function retrieveJob(string $jobId): RetrieveJobResponse;

    /**
     * Immediately cancel a fine-tune job.
     *
     * @see https://platform.openai.com/docs/api-reference/fine-tuning/cancel
     */
    public function cancelJob(string $jobId): RetrieveJobResponse;

    /**
     * Get status updates for a fine-tuning job.
     *
     * @see https://platform.openai.com/docs/api-reference/fine-tuning/list-events
     *
     * @param  array<string, mixed>  $parameters
     */
    public function listJobEvents(string $jobId, array $parameters = []): ListJobEventsResponse;
}
PK     S%W]½mí
&  &  /  client/src/Contracts/Resources/ChatContract.phpnu „[µü¤        <?php

namespace OpenAI\Contracts\Resources;

use OpenAI\Responses\Chat\CreateResponse;
use OpenAI\Responses\Chat\CreateStreamedResponse;
use OpenAI\Responses\StreamResponse;

interface ChatContract
{
    /**
     * Creates a completion for the chat message
     *
     * @see https://platform.openai.com/docs/api-reference/chat/create
     *
     * @param  array<string, mixed>  $parameters
     */
    public function create(array $parameters): CreateResponse;

    /**
     * Creates a streamed completion for the chat message
     *
     * @see https://platform.openai.com/docs/api-reference/chat/create
     *
     * @param  array<string, mixed>  $parameters
     *
     * @return StreamResponse<CreateStreamedResponse>
     */
    public function createStreamed(array $parameters): StreamResponse;
}
PK     S%W]Ë¨°–    1  client/src/Contracts/Resources/ImagesContract.phpnu „[µü¤        <?php

namespace OpenAI\Contracts\Resources;

use OpenAI\Responses\Images\CreateResponse;
use OpenAI\Responses\Images\EditResponse;
use OpenAI\Responses\Images\VariationResponse;

interface ImagesContract
{
    /**
     * Creates an image given a prompt.
     *
     * @see https://platform.openai.com/docs/api-reference/images/create
     *
     * @param  array<string, mixed>  $parameters
     */
    public function create(array $parameters): CreateResponse;

    /**
     * Creates an edited or extended image given an original image and a prompt.
     *
     * @see https://platform.openai.com/docs/api-reference/images/create-edit
     *
     * @param  array<string, mixed>  $parameters
     */
    public function edit(array $parameters): EditResponse;

    /**
     * Creates a variation of a given image.
     *
     * @see https://platform.openai.com/docs/api-reference/images/create-variation
     *
     * @param  array<string, mixed>  $parameters
     */
    public function variation(array $parameters): VariationResponse;
}
PK     S%W]š.d›  ›  5  client/src/Contracts/Resources/EmbeddingsContract.phpnu „[µü¤        <?php

namespace OpenAI\Contracts\Resources;

use OpenAI\Responses\Embeddings\CreateResponse;

interface EmbeddingsContract
{
    /**
     * Creates an embedding vector representing the input text.
     *
     * @see https://platform.openai.com/docs/api-reference/embeddings/create
     *
     * @param  array<string, mixed>  $parameters
     */
    public function create(array $parameters): CreateResponse;
}
PK     S%W]Ì‚fÁ  Á  2  client/src/Contracts/Resources/ThreadsContract.phpnu „[µü¤        <?php

namespace OpenAI\Contracts\Resources;

use OpenAI\Responses\StreamResponse;
use OpenAI\Responses\Threads\Runs\ThreadRunResponse;
use OpenAI\Responses\Threads\Runs\ThreadRunStreamResponse;
use OpenAI\Responses\Threads\ThreadDeleteResponse;
use OpenAI\Responses\Threads\ThreadResponse;

interface ThreadsContract
{
    /**
     * Create a thread.
     *
     * @see https://platform.openai.com/docs/api-reference/threads/createThread
     *
     * @param  array<string, mixed>  $parameters
     */
    public function create(array $parameters): ThreadResponse;

    /**
     * Create a thread and run it in one request.
     *
     * @see https://platform.openai.com/docs/api-reference/runs/createThreadAndRun
     *
     * @param  array<string, mixed>  $parameters
     */
    public function createAndRun(array $parameters): ThreadRunResponse;

    /**
     * Create a thread and run it in one request, returning a stream.
     *
     * @see https://platform.openai.com/docs/api-reference/runs/createThreadAndRun
     *
     * @param  array<string, mixed>  $parameters
     *
     * @return StreamResponse<ThreadRunStreamResponse>
     */
    public function createAndRunStreamed(array $parameters): StreamResponse;

    /**
     * Retrieves a thread.
     *
     * @see https://platform.openai.com/docs/api-reference/threads/getThread
     */
    public function retrieve(string $id): ThreadResponse;

    /**
     * Modifies a thread.
     *
     * @see https://platform.openai.com/docs/api-reference/threads/modifyThread
     *
     * @param  array<string, mixed>  $parameters
     */
    public function modify(string $id, array $parameters): ThreadResponse;

    /**
     * Delete a thread.
     *
     * @see https://platform.openai.com/docs/api-reference/threads/deleteThread
     */
    public function delete(string $id): ThreadDeleteResponse;

    /**
     * Manage messages attached to a thread.
     *
     * @see https://platform.openai.com/docs/api-reference/messages
     */
    public function messages(): ThreadsMessagesContract;

    /**
     * Represents an execution run on a thread.
     *
     * @see https://platform.openai.com/docs/api-reference/runs
     */
    public function runs(): ThreadsRunsContract;
}
PK     S%W]l~2ƒ  ƒ  6  client/src/Contracts/Resources/CompletionsContract.phpnu „[µü¤        <?php

namespace OpenAI\Contracts\Resources;

use OpenAI\Responses\Completions\CreateResponse;
use OpenAI\Responses\Completions\CreateStreamedResponse;
use OpenAI\Responses\StreamResponse;

interface CompletionsContract
{
    /**
     * Creates a completion for the provided prompt and parameters
     *
     * @see https://platform.openai.com/docs/api-reference/completions/create-completion
     *
     * @param  array<string, mixed>  $parameters
     */
    public function create(array $parameters): CreateResponse;

    /**
     * Creates a streamed completion for the provided prompt and parameters
     *
     * @see https://platform.openai.com/docs/api-reference/completions/create-completion
     *
     * @param  array<string, mixed>  $parameters
     *
     * @return StreamResponse<CreateStreamedResponse>
     */
    public function createStreamed(array $parameters): StreamResponse;
}
PK     S%W]aÒùSš  š  6  client/src/Contracts/Resources/ModerationsContract.phpnu „[µü¤        <?php

namespace OpenAI\Contracts\Resources;

use OpenAI\Responses\Moderations\CreateResponse;

interface ModerationsContract
{
    /**
     * Classifies if text violates OpenAI's Content Policy.
     *
     * @see https://platform.openai.com/docs/api-reference/moderations/create
     *
     * @param  array<string, mixed>  $parameters
     */
    public function create(array $parameters): CreateResponse;
}
PK     S%W]>…Ñòš  š  0  client/src/Contracts/Resources/FilesContract.phpnu „[µü¤        <?php

namespace OpenAI\Contracts\Resources;

use OpenAI\Responses\Files\CreateResponse;
use OpenAI\Responses\Files\DeleteResponse;
use OpenAI\Responses\Files\ListResponse;
use OpenAI\Responses\Files\RetrieveResponse;

interface FilesContract
{
    /**
     * Returns a list of files that belong to the user's organization.
     *
     * @see https://platform.openai.com/docs/api-reference/files/list
     *
     * @param  array<string, mixed>  $parameters
     */
    public function list(array $parameters = []): ListResponse;

    /**
     * Returns information about a specific file.
     *
     * @see https://platform.openai.com/docs/api-reference/files/retrieve
     */
    public function retrieve(string $file): RetrieveResponse;

    /**
     * Returns the contents of the specified file.
     *
     * @see https://platform.openai.com/docs/api-reference/files/retrieve-content
     */
    public function download(string $file): string;

    /**
     * Upload a file that contains document(s) to be used across various endpoints/features.
     *
     * @see https://platform.openai.com/docs/api-reference/files/upload
     *
     * @param  array<string, mixed>  $parameters
     */
    public function upload(array $parameters): CreateResponse;

    /**
     * Delete a file.
     *
     * @see https://platform.openai.com/docs/api-reference/files/delete
     */
    public function delete(string $file): DeleteResponse;
}
PK     S%W]Z3#¯…  …  <  client/src/Contracts/Resources/VectorStoresFilesContract.phpnu „[µü¤        <?php

namespace OpenAI\Contracts\Resources;

use OpenAI\Responses\VectorStores\Files\VectorStoreFileDeleteResponse;
use OpenAI\Responses\VectorStores\Files\VectorStoreFileListResponse;
use OpenAI\Responses\VectorStores\Files\VectorStoreFileResponse;

interface VectorStoresFilesContract
{
    /**
     * Create a file on a vector store
     *
     * @see https://platform.openai.com/docs/api-reference/vector-stores-files/createFile
     *
     * @param  array<string, mixed>  $parameters
     */
    public function create(string $vectorStoreId, array $parameters): VectorStoreFileResponse;

    /**
     * Returns a list of files within a vector store.
     *
     * @see https://platform.openai.com/docs/api-reference/vector-stores-files/listFiles
     *
     * @param  array<string, mixed>  $parameters
     */
    public function list(string $vectorStoreId, array $parameters = []): VectorStoreFileListResponse;

    /**
     * Retrieves a file within a vector store.
     *
     * @see https://platform.openai.com/docs/api-reference/vector-stores-files/getFile
     */
    public function retrieve(string $vectorStoreId, string $fileId): VectorStoreFileResponse;

    /**
     * Delete a file within a vector store.
     *
     * https://platform.openai.com/docs/api-reference/vector-stores/delete
     */
    public function delete(string $vectorStoreId, string $fileId): VectorStoreFileDeleteResponse;
}
PK     S%W]7Ÿˆh  h  6  client/src/Contracts/Resources/ThreadsRunsContract.phpnu „[µü¤        <?php

namespace OpenAI\Contracts\Resources;

use OpenAI\Responses\StreamResponse;
use OpenAI\Responses\Threads\Runs\ThreadRunListResponse;
use OpenAI\Responses\Threads\Runs\ThreadRunResponse;
use OpenAI\Responses\Threads\Runs\ThreadRunStreamResponse;

interface ThreadsRunsContract
{
    /**
     * Create a run.
     *
     * @see https://platform.openai.com/docs/api-reference/runs/createRun
     *
     * @param  array<string, mixed>  $parameters
     */
    public function create(string $threadId, array $parameters): ThreadRunResponse;

    /**
     * Create a streamed run.
     *
     * @see https://platform.openai.com/docs/api-reference/runs/createRun
     *
     * @param  array<string, mixed>  $parameters
     *
     * @return StreamResponse<ThreadRunStreamResponse>
     */
    public function createStreamed(string $threadId, array $parameters): StreamResponse;

    /**
     * Retrieves a run.
     *
     * @see https://platform.openai.com/docs/api-reference/runs/getRun
     */
    public function retrieve(string $threadId, string $runId): ThreadRunResponse;

    /**
     * Modifies a run.
     *
     * @see https://platform.openai.com/docs/api-reference/runs/modifyRun
     *
     * @param  array<string, mixed>  $parameters
     */
    public function modify(string $threadId, string $runId, array $parameters): ThreadRunResponse;

    /**
     * This endpoint can be used to submit the outputs from the tool calls once they're all completed.
     *
     * @see https://platform.openai.com/docs/api-reference/runs/submitToolOutputs
     *
     * @param  array<string, mixed>  $parameters
     */
    public function submitToolOutputs(string $threadId, string $runId, array $parameters): ThreadRunResponse;

    /**
     * This endpoint can be used to submit the outputs from the tool calls once they're all completed.
     * And stream back the response
     *
     * @see https://platform.openai.com/docs/api-reference/runs/submitToolOutputs
     *
     * @param  array<string, mixed>  $parameters
     *
     * @return StreamResponse<ThreadRunStreamResponse>
     */
    public function submitToolOutputsStreamed(string $threadId, string $runId, array $parameters): StreamResponse;

    /**
     * Cancels a run that is `in_progress`.
     *
     * @see https://platform.openai.com/docs/api-reference/runs/cancelRun
     */
    public function cancel(string $threadId, string $runId): ThreadRunResponse;

    /**
     * Returns a list of runs belonging to a thread.
     *
     * @see https://platform.openai.com/docs/api-reference/runs/listRuns
     *
     * @param  array<string, mixed>  $parameters
     */
    public function list(string $threadId, array $parameters = []): ThreadRunListResponse;

    /**
     * Get steps attached to a run.
     *
     * @see https://platform.openai.com/docs/api-reference/runs/step-object
     */
    public function steps(): ThreadsRunsStepsContract;
}
PK     S%W]ƒ#XOè  è  1  client/src/Contracts/Resources/ModelsContract.phpnu „[µü¤        <?php

namespace OpenAI\Contracts\Resources;

use OpenAI\Responses\Models\DeleteResponse;
use OpenAI\Responses\Models\ListResponse;
use OpenAI\Responses\Models\RetrieveResponse;

interface ModelsContract
{
    /**
     * Lists the currently available models, and provides basic information about each one such as the owner and availability.
     *
     * @see https://platform.openai.com/docs/api-reference/models/list
     */
    public function list(): ListResponse;

    /**
     * Retrieves a model instance, providing basic information about the model such as the owner and permissioning.
     *
     * @see https://platform.openai.com/docs/api-reference/models/retrieve
     */
    public function retrieve(string $model): RetrieveResponse;

    /**
     * Delete a fine-tuned model. You must have the Owner role in your organization.
     *
     * @see https://platform.openai.com/docs/api-reference/fine-tunes/delete-model
     */
    public function delete(string $model): DeleteResponse;
}
PK     S%W]óQë    0  client/src/Contracts/Resources/AudioContract.phpnu „[µü¤        <?php

namespace OpenAI\Contracts\Resources;

use OpenAI\Responses\Audio\SpeechStreamResponse;
use OpenAI\Responses\Audio\TranscriptionResponse;
use OpenAI\Responses\Audio\TranscriptionStreamResponse;
use OpenAI\Responses\Audio\TranslationResponse;
use OpenAI\Responses\StreamResponse;

interface AudioContract
{
    /**
     * Generates audio from the input text.
     *
     * @see https://platform.openai.com/docs/api-reference/audio/createSpeech
     *
     * @param  array<string, mixed>  $parameters
     */
    public function speech(array $parameters): string;

    /**
     * Generates streamed audio from the input text.
     *
     * @see https://platform.openai.com/docs/api-reference/audio/createSpeech
     *
     * @param  array<string, mixed>  $parameters
     */
    public function speechStreamed(array $parameters): SpeechStreamResponse;

    /**
     * Transcribes audio into the input language.
     *
     * @see https://platform.openai.com/docs/api-reference/audio/createTranscription
     *
     * @param  array<string, mixed>  $parameters
     */
    public function transcribe(array $parameters): TranscriptionResponse;

    /**
     * Transcribes audio input the streamed events.
     *
     * @see https://platform.openai.com/docs/api-reference/audio/createTranscription#audio-createtranscription-stream
     *
     * @param  array<string, mixed>  $parameters
     *
     * @return StreamResponse<TranscriptionStreamResponse>
     */
    public function transcribeStreamed(array $parameters): StreamResponse;

    /**
     * Translates audio into English.
     *
     * @see https://platform.openai.com/docs/api-reference/audio/createTranslation
     *
     * @param  array<string, mixed>  $parameters
     */
    public function translate(array $parameters): TranslationResponse;
}
PK     S%W]¦îËB    5  client/src/Contracts/Resources/ContainersContract.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Contracts\Resources;

use OpenAI\Responses\Containers\CreateContainer;
use OpenAI\Responses\Containers\DeleteContainer;
use OpenAI\Responses\Containers\ListContainers;
use OpenAI\Responses\Containers\RetrieveContainer;

interface ContainersContract
{
    /**
     * Creates a container for use with the Code Interpreter tool.
     *
     * @see https://platform.openai.com/docs/api-reference/containers/createContainers
     *
     * @param  array<string, mixed>  $parameters
     */
    public function create(array $parameters): CreateContainer;

    /**
     * Retrieves a container with the given ID.
     *
     * @see https://platform.openai.com/docs/api-reference/containers/retrieveContainer
     */
    public function retrieve(string $id): RetrieveContainer;

    /**
     * Delete a container with the given ID.
     *
     * @see https://platform.openai.com/docs/api-reference/containers/deleteContainer
     */
    public function delete(string $id): DeleteContainer;

    /**
     * List containers
     *
     * @see https://platform.openai.com/docs/api-reference/containers/listContainers
     *
     * @param  array<string, mixed>  $parameters
     */
    public function list(array $parameters = []): ListContainers;
}
PK     S%W]`Äá®~  ~  4  client/src/Contracts/Resources/ResponsesContract.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Contracts\Resources;

use OpenAI\Responses\Responses\CreateResponse;
use OpenAI\Responses\Responses\CreateStreamedResponse;
use OpenAI\Responses\Responses\DeleteResponse;
use OpenAI\Responses\Responses\ListInputItems;
use OpenAI\Responses\Responses\RetrieveResponse;
use OpenAI\Responses\StreamResponse;

interface ResponsesContract
{
    /**
     * Creates a model response.
     * Provide text or image inputs to generate text or JSON outputs.
     * Have the model call your own custom code or use built-in tools
     * like web search or file search to use your own data as input for the model's response.
     *
     * @see https://platform.openai.com/docs/api-reference/responses/create
     *
     * @param  array<string, mixed>  $parameters
     */
    public function create(array $parameters): CreateResponse;

    /**
     * Create a streamed response.
     *
     * @see https://platform.openai.com/docs/api-reference/responses/create
     *
     * @param  array<string, mixed>  $parameters
     *
     * @return StreamResponse<CreateStreamedResponse>
     */
    public function createStreamed(array $parameters): StreamResponse;

    /**
     * Retrieves a model response with the given ID.
     *
     * @see https://platform.openai.com/docs/api-reference/responses/retrieve
     */
    public function retrieve(string $id): RetrieveResponse;

    /**
     * Cancels a model response with the given ID. Must be marked as 'background' to be cancellable.
     *
     * @see https://platform.openai.com/docs/api-reference/responses/cancel
     */
    public function cancel(string $id): RetrieveResponse;

    /**
     * Deletes a model response with the given ID.
     *
     * @see https://platform.openai.com/docs/api-reference/responses/delete
     */
    public function delete(string $id): DeleteResponse;

    /**
     * Returns a list of input items for a given response.
     *
     * @see https://platform.openai.com/docs/api-reference/responses/input-items
     *
     * @param  array<string, mixed>  $parameters
     */
    public function list(string $id, array $parameters = []): ListInputItems;
}
PK     S%W]Oç„=  =  2  client/src/Contracts/Resources/BatchesContract.phpnu „[µü¤        <?php

namespace OpenAI\Contracts\Resources;

use OpenAI\Responses\Batches\BatchListResponse;
use OpenAI\Responses\Batches\BatchResponse;

interface BatchesContract
{
    /**
     * Creates and executes a batch from an uploaded file of requests
     *
     * @see https://platform.openai.com/docs/api-reference/batch/create
     *
     * @param  array<string, mixed>  $parameters
     */
    public function create(array $parameters): BatchResponse;

    /**
     * Retrieves a batch.
     * *
     * @see https://platform.openai.com/docs/api-reference/batch/retrieve
     */
    public function retrieve(string $id): BatchResponse;

    /**
     * Cancels an in-progress batch.
     * *
     * @see https://platform.openai.com/docs/api-reference/batch/cancel
     */
    public function cancel(string $id): BatchResponse;

    /**
     * List your organization's batches.
     *
     * @see https://platform.openai.com/docs/api-reference/batch/list
     *
     * @param  array<string, mixed>  $parameters
     */
    public function list(array $parameters = []): BatchListResponse;
}
PK     S%W]'úx+Ë  Ë  5  client/src/Contracts/Resources/AssistantsContract.phpnu „[µü¤        <?php

namespace OpenAI\Contracts\Resources;

use OpenAI\Responses\Assistants\AssistantDeleteResponse;
use OpenAI\Responses\Assistants\AssistantListResponse;
use OpenAI\Responses\Assistants\AssistantResponse;

interface AssistantsContract
{
    /**
     * Create an assistant with a model and instructions.
     *
     * @see https://platform.openai.com/docs/api-reference/assistants/createAssistant
     *
     * @param  array<string, mixed>  $parameters
     */
    public function create(array $parameters): AssistantResponse;

    /**
     * Retrieves an assistant.
     *
     * @see https://platform.openai.com/docs/api-reference/assistants/getAssistant
     */
    public function retrieve(string $id): AssistantResponse;

    /**
     * Modifies an assistant.
     *
     * @see https://platform.openai.com/docs/api-reference/assistants/modifyAssistant
     *
     * @param  array<string, mixed>  $parameters
     */
    public function modify(string $id, array $parameters): AssistantResponse;

    /**
     * Delete an assistant.
     *
     * @see https://platform.openai.com/docs/api-reference/assistants/deleteAssistant
     */
    public function delete(string $id): AssistantDeleteResponse;

    /**
     * Returns a list of assistants.
     *
     * @see https://platform.openai.com/docs/api-reference/assistants/listAssistants
     *
     * @param  array<string, mixed>  $parameters
     */
    public function list(array $parameters = []): AssistantListResponse;
}
PK     S%W]G¡Uä   ä   /  client/src/Contracts/ResponseStreamContract.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Contracts;

use IteratorAggregate;

/**
 * @template T
 *
 * @extends IteratorAggregate<int, T>
 *
 * @internal
 */
interface ResponseStreamContract extends IteratorAggregate {}
PK     S%W]Kêä   ä   +  client/src/Contracts/StringableContract.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Contracts;

/**
 * @internal
 */
interface StringableContract
{
    /**
     * Returns the string representation of the object.
     */
    public function toString(): string;
}
PK     S%W]i4‰  ‰  '  client/src/Contracts/ClientContract.phpnu „[µü¤        <?php

namespace OpenAI\Contracts;

use OpenAI\Contracts\Resources\AssistantsContract;
use OpenAI\Contracts\Resources\AudioContract;
use OpenAI\Contracts\Resources\BatchesContract;
use OpenAI\Contracts\Resources\ChatContract;
use OpenAI\Contracts\Resources\CompletionsContract;
use OpenAI\Contracts\Resources\EditsContract;
use OpenAI\Contracts\Resources\EmbeddingsContract;
use OpenAI\Contracts\Resources\FilesContract;
use OpenAI\Contracts\Resources\FineTunesContract;
use OpenAI\Contracts\Resources\FineTuningContract;
use OpenAI\Contracts\Resources\ImagesContract;
use OpenAI\Contracts\Resources\ModelsContract;
use OpenAI\Contracts\Resources\ModerationsContract;
use OpenAI\Contracts\Resources\RealtimeContract;
use OpenAI\Contracts\Resources\ResponsesContract;
use OpenAI\Contracts\Resources\ThreadsContract;
use OpenAI\Contracts\Resources\VectorStoresContract;

interface ClientContract
{
    /**
     * Given a prompt, the model will return one or more predicted completions, and can also return the probabilities
     * of alternative tokens at each position.
     *
     * @see https://platform.openai.com/docs/api-reference/completions
     */
    public function completions(): CompletionsContract;

    /**
     * Manage responses to assist models with tasks.
     *
     * @see https://platform.openai.com/docs/api-reference/responses
     */
    public function responses(): ResponsesContract;

    /**
     * Communicate with a GPT-4o class model in real time using WebRTC or WebSockets. Supports text and audio inputs and outputs, along with audio transcriptions.
     *
     * @see https://platform.openai.com/docs/api-reference/realtime-sessions
     */
    public function realtime(): RealtimeContract;

    /**
     * Given a chat conversation, the model will return a chat completion response.
     *
     * @see https://platform.openai.com/docs/api-reference/chat
     */
    public function chat(): ChatContract;

    /**
     * Get a vector representation of a given input that can be easily consumed by machine learning models and algorithms.
     *
     * @see https://platform.openai.com/docs/api-reference/embeddings
     */
    public function embeddings(): EmbeddingsContract;

    /**
     * Learn how to turn audio into text.
     *
     * @see https://platform.openai.com/docs/api-reference/audio
     */
    public function audio(): AudioContract;

    /**
     * Given a prompt and an instruction, the model will return an edited version of the prompt.
     *
     * @deprecated OpenAI has deprecated this endpoint and will stop working by January 4, 2024.
     * https://openai.com/blog/gpt-4-api-general-availability#deprecation-of-the-edits-api
     * @see https://platform.openai.com/docs/api-reference/edits
     */
    public function edits(): EditsContract;

    /**
     * Files are used to upload documents that can be used with features like Fine-tuning.
     *
     * @see https://platform.openai.com/docs/api-reference/files
     */
    public function files(): FilesContract;

    /**
     * List and describe the various models available in the API.
     *
     * @see https://platform.openai.com/docs/api-reference/models
     */
    public function models(): ModelsContract;

    /**
     * Manage fine-tuning jobs to tailor a model to your specific training data.
     *
     * @see https://platform.openai.com/docs/api-reference/fine-tuning
     */
    public function fineTuning(): FineTuningContract;

    /**
     * Manage fine-tuning jobs to tailor a model to your specific training data.
     *
     * @deprecated OpenAI has deprecated this endpoint and will stop working by January 4, 2024.
     * https://openai.com/blog/gpt-3-5-turbo-fine-tuning-and-api-updates#updated-gpt-3-models
     * @see https://platform.openai.com/docs/api-reference/fine-tunes
     */
    public function fineTunes(): FineTunesContract;

    /**
     * Given an input text, outputs if the model classifies it as violating OpenAI's content policy.
     *
     * @see https://platform.openai.com/docs/api-reference/moderations
     */
    public function moderations(): ModerationsContract;

    /**
     * Given a prompt and/or an input image, the model will generate a new image.
     *
     * @see https://platform.openai.com/docs/api-reference/images
     */
    public function images(): ImagesContract;

    /**
     * Build assistants that can call models and use tools to perform tasks.
     *
     * @see https://platform.openai.com/docs/api-reference/assistants
     */
    public function assistants(): AssistantsContract;

    /**
     * Create threads that assistants can interact with.
     *
     * @see https://platform.openai.com/docs/api-reference/threads
     */
    public function threads(): ThreadsContract;

    /**
     * Create large batches of API requests for asynchronous processing. The Batch API returns completions within 24 hours.
     *
     * @see https://platform.openai.com/docs/api-reference/batch
     */
    public function batches(): BatchesContract;

    /**
     * Create and update vector stores that assistants can interact with
     *
     * @see https://platform.openai.com/docs/api-reference/vector-stores
     */
    public function vectorStores(): VectorStoresContract;
}
PK     S%W]EžÌ®¼  ¼    client/src/Client.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI;

use OpenAI\Contracts\ClientContract;
use OpenAI\Contracts\Resources\RealtimeContract;
use OpenAI\Contracts\Resources\ThreadsContract;
use OpenAI\Contracts\Resources\VectorStoresContract;
use OpenAI\Contracts\TransporterContract;
use OpenAI\Resources\Assistants;
use OpenAI\Resources\Audio;
use OpenAI\Resources\Batches;
use OpenAI\Resources\Chat;
use OpenAI\Resources\Completions;
use OpenAI\Resources\Containers;
use OpenAI\Resources\Edits;
use OpenAI\Resources\Embeddings;
use OpenAI\Resources\Files;
use OpenAI\Resources\FineTunes;
use OpenAI\Resources\FineTuning;
use OpenAI\Resources\Images;
use OpenAI\Resources\Models;
use OpenAI\Resources\Moderations;
use OpenAI\Resources\Realtime;
use OpenAI\Resources\Responses;
use OpenAI\Resources\Threads;
use OpenAI\Resources\VectorStores;

final class Client implements ClientContract
{
    /**
     * Creates a Client instance with the given API token.
     */
    public function __construct(private readonly TransporterContract $transporter)
    {
        // ..
    }

    /**
     * Manage responses to assist models with tasks.
     *
     * @see https://platform.openai.com/docs/api-reference/responses
     */
    public function responses(): Responses
    {
        return new Responses($this->transporter);
    }

    /**
     * Given a prompt, the model will return one or more predicted completions, and can also return the probabilities
     * of alternative tokens at each position.
     *
     * @see https://platform.openai.com/docs/api-reference/completions
     */
    public function completions(): Completions
    {
        return new Completions($this->transporter);
    }

    /**
     * Given a chat conversation, the model will return a chat completion response.
     *
     * @see https://platform.openai.com/docs/api-reference/chat
     */
    public function chat(): Chat
    {
        return new Chat($this->transporter);
    }

    /**
     * Create and manage containers for use with the Code Interpreter tool.
     *
     * @see https://platform.openai.com/docs/api-reference/containers
     */
    public function containers(): Containers
    {
        return new Containers($this->transporter);
    }

    /**
     * Get a vector representation of a given input that can be easily consumed by machine learning models and algorithms.
     *
     * @see https://platform.openai.com/docs/api-reference/embeddings
     */
    public function embeddings(): Embeddings
    {
        return new Embeddings($this->transporter);
    }

    /**
     * Learn how to turn audio into text.
     *
     * @see https://platform.openai.com/docs/api-reference/audio
     */
    public function audio(): Audio
    {
        return new Audio($this->transporter);
    }

    /**
     * Given a prompt and an instruction, the model will return an edited version of the prompt.
     *
     * @see https://platform.openai.com/docs/api-reference/edits
     */
    public function edits(): Edits
    {
        return new Edits($this->transporter);
    }

    /**
     * Files are used to upload documents that can be used with features like Fine-tuning.
     *
     * @see https://platform.openai.com/docs/api-reference/files
     */
    public function files(): Files
    {
        return new Files($this->transporter);
    }

    /**
     * List and describe the various models available in the API.
     *
     * @see https://platform.openai.com/docs/api-reference/models
     */
    public function models(): Models
    {
        return new Models($this->transporter);
    }

    /**
     * Manage fine-tuning jobs to tailor a model to your specific training data.
     *
     * @see https://platform.openai.com/docs/api-reference/fine-tuning
     */
    public function fineTuning(): FineTuning
    {
        return new FineTuning($this->transporter);
    }

    /**
     * Manage fine-tuning jobs to tailor a model to your specific training data.
     *
     * @deprecated OpenAI has deprecated this endpoint and will stop working by January 4, 2024.
     * https://openai.com/blog/gpt-3-5-turbo-fine-tuning-and-api-updates#updated-gpt-3-models
     * @see https://platform.openai.com/docs/api-reference/fine-tunes
     */
    public function fineTunes(): FineTunes
    {
        return new FineTunes($this->transporter);
    }

    /**
     * Given an input text, outputs if the model classifies it as violating OpenAI's content policy.
     *
     * @see https://platform.openai.com/docs/api-reference/moderations
     */
    public function moderations(): Moderations
    {
        return new Moderations($this->transporter);
    }

    /**
     * Given a prompt and/or an input image, the model will generate a new image.
     *
     * @see https://platform.openai.com/docs/api-reference/images
     */
    public function images(): Images
    {
        return new Images($this->transporter);
    }

    /**
     * Build assistants that can call models and use tools to perform tasks.
     *
     * @see https://platform.openai.com/docs/api-reference/assistants
     */
    public function assistants(): Assistants
    {
        return new Assistants($this->transporter);
    }

    /**
     * Communicate with a model in real time using WebRTC or WebSockets.
     *
     * @see https://platform.openai.com/docs/api-reference/realtime
     */
    public function realtime(): RealtimeContract
    {
        return new Realtime($this->transporter);
    }

    /**
     * Create threads that assistants can interact with.
     *
     * @see https://platform.openai.com/docs/api-reference/threads
     */
    public function threads(): ThreadsContract
    {
        return new Threads($this->transporter);
    }

    /**
     * Create large batches of API requests for asynchronous processing. The Batch API returns completions within 24 hours.
     *
     * @see https://platform.openai.com/docs/api-reference/batch
     */
    public function batches(): Batches
    {
        return new Batches($this->transporter);
    }

    /**
     * Create and update vector stores that assistants can interact with
     *
     * @see https://platform.openai.com/docs/api-reference/vector-stores
     */
    public function vectorStores(): VectorStoresContract
    {
        return new VectorStores($this->transporter);
    }
}
PK     S%W]kàˆhm  m  5  client/src/Responses/Assistants/AssistantResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Assistants;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{id: string, object: string, created_at: int, name: ?string, reasoning_effort?: ?string, description: ?string, model: string, instructions: ?string, tools: array<int, array{type: string}|array{type: string}|array{type: string, function: array{description: ?string, name: string, parameters: array<string, mixed>}}>, tool_resources: ?array{code_interpreter?: array{file_ids: array<int,string>}, file_search?: array{vector_store_ids: array<int,string>}}, metadata: array<string, string>, temperature: ?float, top_p: ?float, response_format: string|array{type: string}}>
 */
final class AssistantResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{id: string, object: string, created_at: int, name: ?string, reasoning_effort?: ?string, description: ?string, model: string, instructions: ?string, tools: array<int, array{type: string}|array{type: string}|array{type: string, function: array{description: ?string, name: string, parameters: array<string, mixed>}}>, tool_resources: ?array{code_interpreter?: array{file_ids: array<int,string>}, file_search?: array{vector_store_ids: array<int,string>}}, metadata: array<string, string>, temperature: ?float, top_p: ?float, response_format: string|array{type: string}}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<int, AssistantResponseToolCodeInterpreter|AssistantResponseToolFileSearch|AssistantResponseToolFunction>  $tools
     * @param  array<string, string>  $metadata
     */
    private function __construct(
        public string $id,
        public string $object,
        public int $createdAt,
        public ?string $name,
        public ?string $reasoningEffort,
        public ?string $description,
        public string $model,
        public ?string $instructions,
        public array $tools,
        public ?AssistantResponseToolResources $toolResources,
        public array $metadata,
        public ?float $temperature,
        public ?float $topP,
        public string|AssistantResponseResponseFormat $responseFormat,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{id: string, object: string, created_at: int, name: ?string, reasoning_effort?: ?string, description: ?string, model: string, instructions: ?string, tools: array<int, array{type: 'code_interpreter'}|array{type: 'file_search'}|array{type: 'function', function: array{description: ?string, name: string, parameters: array<string, mixed>}}>, tool_resources: ?array{code_interpreter?: array{file_ids: array<int,string>}, file_search?: array{vector_store_ids: array<int,string>}}, metadata: array<string, string>, temperature: ?float, top_p: ?float, response_format: string|array{type: 'text'|'json_object'}}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        $tools = array_map(
            fn (array $tool): AssistantResponseToolCodeInterpreter|AssistantResponseToolFileSearch|AssistantResponseToolFunction => match ($tool['type']) {
                'code_interpreter' => AssistantResponseToolCodeInterpreter::from($tool),
                'file_search'      => AssistantResponseToolFileSearch::from($tool),
                'function'         => AssistantResponseToolFunction::from($tool),
            },
            $attributes['tools'],
        );

        $responseFormat = is_array($attributes['response_format']) ?
            AssistantResponseResponseFormat::from($attributes['response_format']) :
            $attributes['response_format'];

        return new self(
            $attributes['id'],
            $attributes['object'],
            $attributes['created_at'],
            $attributes['name'],
            $attributes['reasoning_effort'] ?? null,
            $attributes['description'],
            $attributes['model'],
            $attributes['instructions'],
            $tools,
            isset($attributes['tool_resources']) ? AssistantResponseToolResources::from($attributes['tool_resources']) : null,
            $attributes['metadata'],
            $attributes['temperature'],
            $attributes['top_p'],
            $responseFormat,
            $meta
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        $response = [
            'id'               => $this->id,
            'object'           => $this->object,
            'created_at'       => $this->createdAt,
            'name'             => $this->name,
            'reasoning_effort' => $this->reasoningEffort,
            'description'      => $this->description,
            'model'            => $this->model,
            'instructions'     => $this->instructions,
            'tools'            => array_map(fn (AssistantResponseToolCodeInterpreter|AssistantResponseToolFileSearch|AssistantResponseToolFunction $tool): array => $tool->toArray(), $this->tools),
            'tool_resources'   => $this->toolResources?->toArray(),
            'metadata'         => $this->metadata,
            'temperature'      => $this->temperature,
            'top_p'            => $this->topP,
            'response_format'  => is_string($this->responseFormat) ? $this->responseFormat : $this->responseFormat->toArray(),
        ];

        // Only reasoning models will have this property.
        if (! $this->reasoningEffort) {
            unset($response['reasoning_effort']);
        }

        return $response;
    }
}
PK     S%W]Z1š¸Ž  Ž  A  client/src/Responses/Assistants/AssistantResponseToolFunction.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Assistants;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{type: string, function: array{description: ?string, name: string, parameters: array<string, mixed>}}>
 */
final class AssistantResponseToolFunction implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{type: string, function: array{description: ?string, name: string, parameters: array<string, mixed>}}>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public string $type,
        public AssistantResponseToolFunctionFunction $function,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{type: 'function', function: array{description: ?string, name: string, parameters: array<string, mixed>}}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['type'],
            AssistantResponseToolFunctionFunction::from($attributes['function']),
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type'     => $this->type,
            'function' => $this->function->toArray(),
        ];
    }
}
PK     S%W]{#By>  >  P  client/src/Responses/Assistants/AssistantResponseToolResourceCodeInterpreter.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Assistants;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{file_ids: array<int,string>}>
 */
final class AssistantResponseToolResourceCodeInterpreter implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{file_ids: array<int,string>}>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  array<int, string>  $fileIds
     */
    private function __construct(
        public array $fileIds,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{file_ids: array<int,string>}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['file_ids'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'file_ids' => $this->fileIds,
        ];
    }
}
PK     S%W]-:Gì¨  ¨  I  client/src/Responses/Assistants/AssistantResponseToolFunctionFunction.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Assistants;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{description: ?string, name: string, parameters: array<string, mixed>}>
 */
final class AssistantResponseToolFunctionFunction implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{description: ?string, name: string, parameters: array<string, mixed>}>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  array<string, mixed>  $parameters
     */
    private function __construct(
        public ?string $description,
        public string $name,
        public array $parameters,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{description: ?string, name: string, parameters: array<string, mixed>}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['description'],
            $attributes['name'],
            $attributes['parameters'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'name'        => $this->name,
            'description' => $this->description,
            'parameters'  => $this->parameters,
        ];
    }
}
PK     S%W]…o½lÂ  Â  C  client/src/Responses/Assistants/AssistantResponseToolFileSearch.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Assistants;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{type: string}>
 */
final class AssistantResponseToolFileSearch implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{type: string}>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public string $type,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{type: 'file_search'}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type' => $this->type,
        ];
    }
}
PK     S%W]AË:¬ƒ  ƒ  9  client/src/Responses/Assistants/AssistantListResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Assistants;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{object: string, data: array<int, array{id: string, object: string, created_at: int, name: ?string, description: ?string, model: string, instructions: ?string, tools: array<int, array{type: string}|array{type: string}|array{type: string, function: array{description: ?string, name: string, parameters: array<string, mixed>}}>, tool_resources: ?array{code_interpreter?: array{file_ids: array<int,string>}, file_search?: array{vector_store_ids: array<int,string>}}, metadata: array<string, string>, temperature: ?float, top_p: ?float, response_format: string|array{type: string}}>, first_id: ?string, last_id: ?string, has_more: bool}>
 */
final class AssistantListResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{object: string, data: array<int, array{id: string, object: string, created_at: int, name: ?string, description: ?string, model: string, instructions: ?string, tools: array<int, array{type: string}|array{type: string}|array{type: string, function: array{description: ?string, name: string, parameters: array<string, mixed>}}>, tool_resources: ?array{code_interpreter?: array{file_ids: array<int,string>}, file_search?: array{vector_store_ids: array<int,string>}}, metadata: array<string, string>, temperature: ?float, top_p: ?float, response_format: string|array{type: string}}>, first_id: ?string, last_id: ?string, has_more: bool}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<int, AssistantResponse>  $data
     */
    private function __construct(
        public readonly string $object,
        public readonly array $data,
        public readonly ?string $firstId,
        public readonly ?string $lastId,
        public readonly bool $hasMore,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{object: string, data: array<int, array{id: string, object: string, created_at: int, name: ?string, description: ?string, model: string, instructions: ?string, tools: array<int, array{type: 'code_interpreter'}|array{type: 'file_search'}|array{type: 'function', function: array{description: ?string, name: string, parameters: array<string, mixed>}}>, tool_resources: ?array{code_interpreter?: array{file_ids: array<int,string>}, file_search?: array{vector_store_ids: array<int,string>}}, metadata: array<string, string>, temperature: ?float, top_p: ?float, response_format: string|array{type: 'text'|'json_object'}}>, first_id: ?string, last_id: ?string, has_more: bool}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        $data = array_map(fn (array $result): AssistantResponse => AssistantResponse::from(
            $result,
            $meta,
        ), $attributes['data']);

        return new self(
            $attributes['object'],
            $data,
            $attributes['first_id'],
            $attributes['last_id'],
            $attributes['has_more'],
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'object' => $this->object,
            'data'   => array_map(
                static fn (AssistantResponse $response): array => $response->toArray(),
                $this->data,
            ),
            'first_id' => $this->firstId,
            'last_id'  => $this->lastId,
            'has_more' => $this->hasMore,
        ];
    }
}
PK     S%W]vÂè,'  '  ;  client/src/Responses/Assistants/AssistantDeleteResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Assistants;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{id: string, object: string, deleted: bool}>
 */
final class AssistantDeleteResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{id: string, object: string, deleted: bool}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly string $id,
        public readonly string $object,
        public readonly bool $deleted,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{id: string, object: string, deleted: bool}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            $attributes['id'],
            $attributes['object'],
            $attributes['deleted'],
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'      => $this->id,
            'object'  => $this->object,
            'deleted' => $this->deleted,
        ];
    }
}
PK     S%W]›©É  É  C  client/src/Responses/Assistants/AssistantResponseResponseFormat.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Assistants;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{type: string}>
 */
final class AssistantResponseResponseFormat implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{type: string}>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public string $type,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{type: 'text'|'json_object'}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type' => $this->type,
        ];
    }
}
PK     S%W]ÊJÚ3v  v  K  client/src/Responses/Assistants/AssistantResponseToolResourceFileSearch.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Assistants;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{vector_store_ids: array<int,string>}>
 */
final class AssistantResponseToolResourceFileSearch implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{vector_store_ids: array<int,string>}>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  array<int, string>  $vectorStoreIds
     */
    private function __construct(
        public array $vectorStoreIds,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{vector_store_ids: array<int,string>}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['vector_store_ids'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'vector_store_ids' => $this->vectorStoreIds,
        ];
    }
}
PK     S%W]‚™Ì  Ì  H  client/src/Responses/Assistants/AssistantResponseToolCodeInterpreter.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Assistants;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{type: string}>
 */
final class AssistantResponseToolCodeInterpreter implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{type: string}>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public string $type,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{type: 'code_interpreter'}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type' => $this->type,
        ];
    }
}
PK     S%W]ÒR¾  ¾  B  client/src/Responses/Assistants/AssistantResponseToolResources.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Assistants;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{code_interpreter?: array{file_ids: array<int,string>}, file_search?: array{vector_store_ids: array<int,string>}}>
 */
final class AssistantResponseToolResources implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{code_interpreter?: array{file_ids: array<int,string>}, file_search?: array{vector_store_ids: array<int,string>}}>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public ?AssistantResponseToolResourceCodeInterpreter $codeInterpreter,
        public ?AssistantResponseToolResourceFileSearch $fileSearch,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{code_interpreter?: array{file_ids: array<int,string>}, file_search?: array{vector_store_ids: array<int,string>}}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            isset($attributes['code_interpreter']) ? AssistantResponseToolResourceCodeInterpreter::from($attributes['code_interpreter']) : null,
            isset($attributes['file_search']) ? AssistantResponseToolResourceFileSearch::from($attributes['file_search']) : null,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return array_filter([
            'code_interpreter' => $this->codeInterpreter?->toArray(),
            'file_search'      => $this->fileSearch?->toArray(),
        ]);
    }
}
PK     S%W], î¿  ¿  G  client/src/Responses/Assistants/AssistantResponseResponseFormatText.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Assistants;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{type: string}>
 */
final class AssistantResponseResponseFormatText implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{type: string}>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public string $type,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{type: 'text'}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type' => $this->type,
        ];
    }
}
PK     S%W]$›Ù«g	  g	  3  client/src/Responses/Moderations/CreateResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Moderations;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{id: string, model: string, results: array<int, array{categories: array<string, bool>, category_scores: array<string, float>, flagged: bool, category_applied_input_types?: array<string, array<int, string>>}>}>
 */
final class CreateResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{id: string, model: string, results: array<int, array{categories: array<string, bool>, category_scores: array<string, float>, flagged: bool, category_applied_input_types?: array<string, array<int, string>>}>}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<int, CreateResponseResult>  $results
     */
    private function __construct(
        public readonly string $id,
        public readonly string $model,
        public readonly array $results,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{id: string, model: string, results: array<int, array{categories: array<string, bool>, category_scores: array<string, float>, flagged: bool, category_applied_input_types?: array<string, array<int, string>>}>}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        $results = array_map(fn (array $result): CreateResponseResult => CreateResponseResult::from(
            $result
        ), $attributes['results']);

        return new self(
            $attributes['id'],
            $attributes['model'],
            $results,
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'      => $this->id,
            'model'   => $this->model,
            'results' => array_map(
                static fn (CreateResponseResult $result): array => $result->toArray(),
                $this->results,
            ),
        ];
    }
}
PK     S%W]Ljý ]	  ]	  9  client/src/Responses/Moderations/CreateResponseResult.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Moderations;

use OpenAI\Enums\Moderations\Category;

final class CreateResponseResult
{
    /**
     * @param  array<string, CreateResponseCategory>  $categories
     * @param  array<string, array<string>>  $categoryAppliedInputTypes
     */
    private function __construct(
        public readonly array $categories,
        public readonly bool $flagged,
        public readonly ?array $categoryAppliedInputTypes,
    ) {
        // ..
    }

    /**
     * @param  array{categories: array<string, bool>, category_scores: array<string, float>, flagged: bool, category_applied_input_types?: array<string, array<int, string>>}  $attributes
     */
    public static function from(array $attributes): self
    {
        /** @var array<string, CreateResponseCategory> $categories */
        $categories = [];

        foreach (Category::cases() as $category) {
            if (! isset($attributes['category_scores'][$category->value])) {
                continue;
            }

            $categories[$category->value] = CreateResponseCategory::from([
                'category' => $category->value,
                'violated' => $attributes['categories'][$category->value],
                'score'    => $attributes['category_scores'][$category->value],
            ]);
        }

        return new CreateResponseResult(
            $categories,
            $attributes['flagged'],
            $attributes['category_applied_input_types'] ?? null,
        );
    }

    /**
     * @return array{ categories: array<string, bool>, category_scores: array<string, float>, flagged: bool, category_applied_input_types?: array<string, array<int, string>>}
     */
    public function toArray(): array
    {
        $categories = [];
        $categoryScores = [];
        foreach ($this->categories as $category) {
            $categories[$category->category->value] = $category->violated;
            $categoryScores[$category->category->value] = $category->score;
        }

        $result = [
            'categories'      => $categories,
            'category_scores' => $categoryScores,
            'flagged'         => $this->flagged,
        ];

        if ($this->categoryAppliedInputTypes !== null) {
            $result['category_applied_input_types'] = $this->categoryAppliedInputTypes;
        }

        return $result;
    }
}
PK     S%W]öOÀ†  †  ;  client/src/Responses/Moderations/CreateResponseCategory.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Moderations;

use OpenAI\Enums\Moderations\Category;

final class CreateResponseCategory
{
    private function __construct(
        public readonly Category $category,
        public readonly bool $violated,
        public readonly float $score,
    ) {}

    /**
     * @param  array{category: string, violated: bool, score: float}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            Category::from($attributes['category']),
            $attributes['violated'],
            $attributes['score'],
        );
    }
}
PK     S%W]1gìKŽ  Ž  <  client/src/Responses/Audio/Streaming/TranscriptTextDelta.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Audio\Streaming;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-import-type LogprobsType from Logprobs
 *
 * @phpstan-type TranscriptTextDeltaType array{logprobs?: array<int, LogprobsType>|null, delta: string}
 *
 * @implements ResponseContract<TranscriptTextDeltaType>
 */
final class TranscriptTextDelta implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<TranscriptTextDeltaType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<int, Logprobs>|null  $logprobs
     */
    private function __construct(
        public readonly ?array $logprobs,
        public readonly string $delta,
        public readonly MetaInformation $meta,
    ) {}

    /**
     * @param  TranscriptTextDeltaType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        if (isset($attributes['logprobs'])) {
            $logprobs = array_map(
                fn (array $logprob): Logprobs => Logprobs::from($logprob, $meta),
                $attributes['logprobs']
            );
        }

        return new self(
            logprobs: $logprobs ?? null,
            delta: $attributes['delta'],
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'logprobs' => $this->logprobs ? array_map(
                fn (Logprobs $logprob): array => $logprob->toArray(),
                $this->logprobs
            ) : null,
            'delta' => $this->delta,
        ];
    }
}
PK     S%W]KKÑƒ  ƒ  ;  client/src/Responses/Audio/Streaming/TranscriptTextDone.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Audio\Streaming;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-import-type LogprobsType from Logprobs
 *
 * @phpstan-type TranscriptTextDoneType array{logprobs?: array<int, LogprobsType>|null, text: string}
 *
 * @implements ResponseContract<TranscriptTextDoneType>
 */
final class TranscriptTextDone implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<TranscriptTextDoneType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<int, Logprobs>|null  $logprobs
     */
    private function __construct(
        public readonly ?array $logprobs,
        public readonly string $text,
        public readonly MetaInformation $meta,
    ) {}

    /**
     * @param  TranscriptTextDoneType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        if (isset($attributes['logprobs'])) {
            $logprobs = array_map(
                fn (array $logprob): Logprobs => Logprobs::from($logprob, $meta),
                $attributes['logprobs']
            );
        }

        return new self(
            logprobs: $logprobs ?? null,
            text: $attributes['text'],
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'logprobs' => $this->logprobs ? array_map(
                fn (Logprobs $logprob): array => $logprob->toArray(),
                $this->logprobs
            ) : null,
            'text' => $this->text,
        ];
    }
}
PK     S%W]†êª'  '  1  client/src/Responses/Audio/Streaming/Logprobs.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Audio\Streaming;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type LogprobsType array{bytes: array<int, string>, logprobs: int, token: string}
 *
 * @implements ResponseContract<LogprobsType>
 */
final class Logprobs implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<LogprobsType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<int, string>  $bytes
     */
    private function __construct(
        public readonly array $bytes,
        public readonly int $logprobs,
        public readonly string $token,
        public readonly MetaInformation $meta,
    ) {}

    /**
     * @param  LogprobsType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            bytes: $attributes['bytes'],
            logprobs: $attributes['logprobs'],
            token: $attributes['token'],
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'bytes'    => $this->bytes,
            'logprobs' => $this->logprobs,
            'token'    => $this->token,
        ];
    }
}
PK     S%W]ÂÕ«04  4  ;  client/src/Responses/Audio/TranscriptionResponseSegment.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Audio;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;

/**
 * @implements ResponseContract<array{id: int, seek: int, start: float, end: float, text: string, tokens: array<int, int>, temperature: float, avg_logprob: float, compression_ratio: float, no_speech_prob: float, transient?: bool}>
 */
final class TranscriptionResponseSegment implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{id: int, seek: int, start: float, end: float, text: string, tokens: array<int, int>, temperature: float, avg_logprob: float, compression_ratio: float, no_speech_prob: float, transient?: bool}>
     */
    use ArrayAccessible;

    /**
     * @param  array<int, int>  $tokens
     */
    private function __construct(
        public readonly int $id,
        public readonly int $seek,
        public readonly float $start,
        public readonly float $end,
        public readonly string $text,
        public readonly array $tokens,
        public readonly float $temperature,
        public readonly float $avgLogprob,
        public readonly float $compressionRatio,
        public readonly float $noSpeechProb,
        public readonly ?bool $transient,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{id: int, seek: int, start: float, end: float, text: string, tokens: array<int, int>, temperature: float, avg_logprob: float, compression_ratio: float, no_speech_prob: float, transient?: bool}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['id'],
            $attributes['seek'],
            $attributes['start'],
            $attributes['end'],
            $attributes['text'],
            $attributes['tokens'],
            $attributes['temperature'],
            $attributes['avg_logprob'],
            $attributes['compression_ratio'],
            $attributes['no_speech_prob'],
            $attributes['transient'] ?? null,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        $data = [
            'id'                => $this->id,
            'seek'              => $this->seek,
            'start'             => $this->start,
            'end'               => $this->end,
            'text'              => $this->text,
            'tokens'            => $this->tokens,
            'temperature'       => $this->temperature,
            'avg_logprob'       => $this->avgLogprob,
            'compression_ratio' => $this->compressionRatio,
            'no_speech_prob'    => $this->noSpeechProb,
        ];

        if ($this->transient !== null) {
            $data['transient'] = $this->transient;
        }

        return $data;
    }
}
PK     S%W]šW)¹    3  client/src/Responses/Audio/SpeechStreamResponse.phpnu „[µü¤        <?php

namespace OpenAI\Responses\Audio;

use Generator;
use Http\Discovery\Psr17Factory;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Contracts\ResponseStreamContract;
use OpenAI\Responses\Meta\MetaInformation;
use Psr\Http\Message\ResponseInterface;

/**
 * @implements ResponseStreamContract<string>
 */
final class SpeechStreamResponse implements ResponseHasMetaInformationContract, ResponseStreamContract
{
    public function __construct(
        private readonly ResponseInterface $response,
    ) {
        //
    }

    /**
     * {@inheritDoc}
     */
    public function getIterator(): Generator
    {
        while (! $this->response->getBody()->eof()) {
            yield $this->response->getBody()->read(1024);
        }
    }

    public function meta(): MetaInformation
    {
        // @phpstan-ignore-next-line
        return MetaInformation::from($this->response->getHeaders());
    }

    public static function fake(?string $content = null, ?MetaInformation $meta = null): static
    {
        $psr17Factory = new Psr17Factory;
        $response = $psr17Factory->createResponse()
            ->withBody($psr17Factory->createStream($content ?? (string) file_get_contents(__DIR__ . '/../../Testing/Responses/Fixtures/Audio/speech-streamed.mp3')));

        if ($meta instanceof \OpenAI\Responses\Meta\MetaInformation) {
            foreach ($meta->toArray() as $key => $value) {
                $response = $response->withHeader($key, (string) $value);
            }
        }

        return new self($response);
    }
}
PK     S%W] ¥”X¨  ¨  :  client/src/Responses/Audio/TranscriptionStreamResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Audio;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Exceptions\UnknownEventException;
use OpenAI\Responses\Audio\Streaming\TranscriptTextDelta;
use OpenAI\Responses\Audio\Streaming\TranscriptTextDone;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\FakeableForStreamedResponse;

/**
 * @phpstan-type CreateStreamedResponseType array{event: string, data: array<string, mixed>}
 *
 * @implements ResponseContract<CreateStreamedResponseType>
 */
final class TranscriptionStreamResponse implements ResponseContract
{
    /**
     * @use ArrayAccessible<CreateStreamedResponseType>
     */
    use ArrayAccessible;

    use FakeableForStreamedResponse;

    private function __construct(
        public readonly string $event,
        public readonly TranscriptTextDelta|TranscriptTextDone $response,
    ) {}

    /**
     * @param  array<string, mixed>  $attributes
     */
    public static function from(array $attributes): self
    {
        $event = $attributes['type'] ?? throw new UnknownEventException('Missing event type in streamed response');
        $meta = $attributes['__meta'];
        unset($attributes['__meta']);

        $response = match ($event) {
            'transcript.text.delta' => TranscriptTextDelta::from($attributes, $meta), // @phpstan-ignore-line
            'transcript.text.done'  => TranscriptTextDone::from($attributes, $meta), // @phpstan-ignore-line
            default                 => throw new UnknownEventException('Unknown Audio Transcription streaming event: ' . $event),
        };

        return new self(
            event: $event, // @phpstan-ignore-line
            response: $response,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'event' => $this->event,
            'data'  => $this->response->toArray(),
        ];
    }
}
PK     S%W]— L)Ò  Ò  4  client/src/Responses/Audio/TranscriptionResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Audio;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{task: ?string, language: ?string, duration: ?float, segments: array<int, array{id: int, seek: int, start: float, end: float, text: string, tokens: array<int, int>, temperature: float, avg_logprob: float, compression_ratio: float, no_speech_prob: float, transient?: bool}>, words: array<int, array{word: string, start: float, end: float}>, text: string}>
 */
final class TranscriptionResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{task: ?string, language: ?string, duration: ?float, segments: array<int, array{id: int, seek: int, start: float, end: float, text: string, tokens: array<int, int>, temperature: float, avg_logprob: float, compression_ratio: float, no_speech_prob: float, transient?: bool}>, words: array<int, array{word: string, start: float, end: float}>, text: string}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<int, TranscriptionResponseSegment>  $segments
     * @param  array<int, TranscriptionResponseWord>  $words
     */
    private function __construct(
        public readonly ?string $task,
        public readonly ?string $language,
        public readonly ?float $duration,
        public readonly array $segments,
        public readonly array $words,
        public readonly string $text,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{task: ?string, language: ?string, duration: ?float, segments: array<int, array{id: int, seek: int, start: float, end: float, text: string, tokens: array<int, int>, temperature: float, avg_logprob: float, compression_ratio: float, no_speech_prob: float, transient?: bool}>, words: array<int, array{word: string, start: float, end: float}>, text: string}|string  $attributes
     */
    public static function from(array|string $attributes, MetaInformation $meta): self
    {
        if (is_string($attributes)) {
            $attributes = ['text' => $attributes];
        }

        $segments = isset($attributes['segments']) ? array_map(fn (array $result): TranscriptionResponseSegment => TranscriptionResponseSegment::from(
            $result
        ), $attributes['segments']) : [];

        $words = isset($attributes['words']) ? array_map(fn (array $result): TranscriptionResponseWord => TranscriptionResponseWord::from(
            $result
        ), $attributes['words']) : [];

        return new self(
            $attributes['task'] ?? null,
            $attributes['language'] ?? null,
            $attributes['duration'] ?? null,
            $segments,
            $words,
            $attributes['text'],
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'task'     => $this->task,
            'language' => $this->language,
            'duration' => $this->duration,
            'segments' => array_map(
                static fn (TranscriptionResponseSegment $result): array => $result->toArray(),
                $this->segments,
            ),
            'words' => array_map(
                static fn (TranscriptionResponseWord $result): array => $result->toArray(),
                $this->words,
            ),
            'text' => $this->text,
        ];
    }
}
PK     S%W]‘u5¤™  ™  8  client/src/Responses/Audio/TranscriptionResponseWord.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Audio;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;

/**
 * @implements ResponseContract<array{word: string, start: float, end: float}>
 */
final class TranscriptionResponseWord implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{word: string, start: float, end: float}>
     */
    use ArrayAccessible;

    private function __construct(
        public readonly string $word,
        public readonly float $start,
        public readonly float $end,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{word: string, start: float, end: float}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['word'],
            $attributes['start'],
            $attributes['end'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'word'  => $this->word,
            'start' => $this->start,
            'end'   => $this->end,
        ];
    }
}
PK     S%W]z·O    2  client/src/Responses/Audio/TranslationResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Audio;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{task: ?string, language: ?string, duration: ?float, segments: array<int, array{id: int, seek: int, start: float, end: float, text: string, tokens: array<int, int>, temperature: float, avg_logprob: float, compression_ratio: float, no_speech_prob: float, transient?: bool}>, text: string}>
 */
final class TranslationResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{task: ?string, language: ?string, duration: ?float, segments: array<int, array{id: int, seek: int, start: float, end: float, text: string, tokens: array<int, int>, temperature: float, avg_logprob: float, compression_ratio: float, no_speech_prob: float, transient?: bool}>, text: string}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<int, TranslationResponseSegment>  $segments
     */
    private function __construct(
        public readonly ?string $task,
        public readonly ?string $language,
        public readonly ?float $duration,
        public readonly array $segments,
        public readonly string $text,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{task: ?string, language: ?string, duration: ?float, segments: array<int, array{id: int, seek: int, start: float, end: float, text: string, tokens: array<int, int>, temperature: float, avg_logprob: float, compression_ratio: float, no_speech_prob: float, transient?: bool}>, text: string}  $attributes
     */
    public static function from(array|string $attributes, MetaInformation $meta): self
    {
        if (is_string($attributes)) {
            $attributes = ['text' => $attributes];
        }

        $segments = isset($attributes['segments']) ? array_map(fn (array $result): TranslationResponseSegment => TranslationResponseSegment::from(
            $result
        ), $attributes['segments']) : [];

        return new self(
            $attributes['task'] ?? null,
            $attributes['language'] ?? null,
            $attributes['duration'] ?? null,
            $segments,
            $attributes['text'],
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'task'     => $this->task,
            'language' => $this->language,
            'duration' => $this->duration,
            'segments' => array_map(
                static fn (TranslationResponseSegment $result): array => $result->toArray(),
                $this->segments,
            ),
            'text' => $this->text,
        ];
    }
}
PK     S%W]”ÝšÕ2  2  9  client/src/Responses/Audio/TranslationResponseSegment.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Audio;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;

/**
 * @implements ResponseContract<array{id: int, seek: int, start: float, end: float, text: string, tokens: array<int, int>, temperature: float, avg_logprob: float, compression_ratio: float, no_speech_prob: float, transient?: bool}>
 */
final class TranslationResponseSegment implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{id: int, seek: int, start: float, end: float, text: string, tokens: array<int, int>, temperature: float, avg_logprob: float, compression_ratio: float, no_speech_prob: float, transient?: bool}>
     */
    use ArrayAccessible;

    /**
     * @param  array<int, int>  $tokens
     */
    private function __construct(
        public readonly int $id,
        public readonly int $seek,
        public readonly float $start,
        public readonly float $end,
        public readonly string $text,
        public readonly array $tokens,
        public readonly float $temperature,
        public readonly float $avgLogprob,
        public readonly float $compressionRatio,
        public readonly float $noSpeechProb,
        public readonly ?bool $transient,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{id: int, seek: int, start: float, end: float, text: string, tokens: array<int, int>, temperature: float, avg_logprob: float, compression_ratio: float, no_speech_prob: float, transient?: bool}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['id'],
            $attributes['seek'],
            $attributes['start'],
            $attributes['end'],
            $attributes['text'],
            $attributes['tokens'],
            $attributes['temperature'],
            $attributes['avg_logprob'],
            $attributes['compression_ratio'],
            $attributes['no_speech_prob'],
            $attributes['transient'] ?? null,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        $data = [
            'id'                => $this->id,
            'seek'              => $this->seek,
            'start'             => $this->start,
            'end'               => $this->end,
            'text'              => $this->text,
            'tokens'            => $this->tokens,
            'temperature'       => $this->temperature,
            'avg_logprob'       => $this->avgLogprob,
            'compression_ratio' => $this->compressionRatio,
            'no_speech_prob'    => $this->noSpeechProb,
        ];

        if ($this->transient !== null) {
            $data['transient'] = $this->transient;
        }

        return $data;
    }
}
PK     S%W]¯Â
  
  /  client/src/Responses/Threads/ThreadResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Assistants\AssistantResponseToolResources;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{id: string, object: string, created_at: int, tool_resources: ?array{code_interpreter?: array{file_ids: array<int,string>}, file_search?: array{vector_store_ids: array<int,string>}}, metadata: array<string, string>}>
 */
final class ThreadResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{id: string, object: string, created_at: int, tool_resources: ?array{code_interpreter?: array{file_ids: array<int,string>}, file_search?: array{vector_store_ids: array<int,string>}}, metadata: array<string, string>}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<string, string>  $metadata
     */
    private function __construct(
        public string $id,
        public string $object,
        public int $createdAt,
        public ?AssistantResponseToolResources $toolResources,
        public array $metadata,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{id: string, object: string, created_at: int, tool_resources: ?array{code_interpreter?: array{file_ids: array<int,string>}, file_search?: array{vector_store_ids: array<int,string>}}, metadata: array<string, string>}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            $attributes['id'],
            $attributes['object'],
            $attributes['created_at'],
            isset($attributes['tool_resources']) ? AssistantResponseToolResources::from($attributes['tool_resources']) : null,
            $attributes['metadata'],
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'             => $this->id,
            'object'         => $this->object,
            'created_at'     => $this->createdAt,
            'tool_resources' => $this->toolResources?->toArray(),
            'metadata'       => $this->metadata,
        ];
    }
}
PK     S%W]é¨¢ !  !  5  client/src/Responses/Threads/ThreadDeleteResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{id: string, object: string, deleted: bool}>
 */
final class ThreadDeleteResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{id: string, object: string, deleted: bool}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly string $id,
        public readonly string $object,
        public readonly bool $deleted,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{id: string, object: string, deleted: bool}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            $attributes['id'],
            $attributes['object'],
            $attributes['deleted'],
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'      => $this->id,
            'object'  => $this->object,
            'deleted' => $this->deleted,
        ];
    }
}
PK     S%W]ƒùŒ§  §  A  client/src/Responses/Threads/Runs/ThreadRunResponseToolChoice.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Runs;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{type: string, function?: array{name: string}}>
 */
final class ThreadRunResponseToolChoice implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{type: string, function?: array{name: string}}>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public string $type,
        public ?ThreadRunResponseToolChoiceFunction $function
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{type: string, function?: array{name: string}}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['type'],
            empty($attributes['function']) ? null : ThreadRunResponseToolChoiceFunction::from($attributes['function']),
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        $response = [
            'type' => $this->type,
        ];

        if ($this->function instanceof \OpenAI\Responses\Threads\Runs\ThreadRunResponseToolChoiceFunction) {
            $response['function'] = $this->function->toArray();
        }

        return $response;
    }
}
PK     S%W]~B\[  [  @  client/src/Responses/Threads/Runs/ThreadRunResponseLastError.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Runs;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{code: string, message: string}>
 */
final class ThreadRunResponseLastError implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{code: string, message: string}>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public string $code,
        public string $message,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{code: string, message: string}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['code'],
            $attributes['message'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'code'    => $this->code,
            'message' => $this->message,
        ];
    }
}
PK     S%W]Žæ£“  “  E  client/src/Responses/Threads/Runs/Steps/ThreadRunStepListResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Runs\Steps;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{object: string, data: array<int, array{id: string, object: string, created_at: int, thread_id: string, assistant_id: string, run_id: string, type: string, status: string, step_details: array{type: 'tool_calls', tool_calls: array<int, array{id: ?string, type: 'code_interpreter', code_interpreter: array{input?: string, outputs?: array<int, array{type: 'image', image: array{file_id: string}}|array{type: 'logs', logs: string}>}}|array{id: string, type: 'file_search', file_search: array<string, string>}|array{id: ?string, type: 'function', function: array{name: ?string, arguments: string, output: ?string}}>}|array{type: 'message_creation', message_creation: array{message_id: string}}, last_error: ?array{code: string, message: string}, expires_at: ?int, cancelled_at: ?int, failed_at: ?int, completed_at: ?int, metadata?: array<string, string>, usage: ?array{prompt_tokens: int, completion_tokens: int, total_tokens: int}}>, first_id: ?string, last_id: ?string, has_more: bool}>
 */
final class ThreadRunStepListResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{object: string, data: array<int, array{id: string, object: string, created_at: int, thread_id: string, assistant_id: string, run_id: string, type: string, status: string, step_details: array{type: 'tool_calls', tool_calls: array<int, array{id: ?string, type: 'code_interpreter', code_interpreter: array{input?: string, outputs?: array<int, array{type: 'image', image: array{file_id: string}}|array{type: 'logs', logs: string}>}}|array{id: string, type: 'file_search', file_search: array<string, string>}|array{id: ?string, type: 'function', function: array{name: ?string, arguments: string, output: ?string}}>}|array{type: 'message_creation', message_creation: array{message_id: string}}, last_error: ?array{code: string, message: string}, expires_at: ?int, cancelled_at: ?int, failed_at: ?int, completed_at: ?int, metadata?: array<string, string>, usage: ?array{prompt_tokens: int, completion_tokens: int, total_tokens: int}}>, first_id: ?string, last_id: ?string, has_more: bool}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<int, ThreadRunStepResponse>  $data
     */
    private function __construct(
        public readonly string $object,
        public readonly array $data,
        public readonly ?string $firstId,
        public readonly ?string $lastId,
        public readonly bool $hasMore,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{object: string, data: array<int, array{id: string, object: string, created_at: int, thread_id: string, assistant_id: string, run_id: string, type: string, status: string, step_details: array{type: 'tool_calls', tool_calls: array<int, array{id?: string, type: 'code_interpreter', code_interpreter: array{input: string, outputs: array<int, array{type: 'image', image: array{file_id: string}}|array{type: 'logs', logs: string}>}}|array{id: string, type: 'file_search', file_search: array<string, string>}|array{id?: string, type: 'function', function: array{name?: string, arguments: string, output?: ?string}}>}|array{type: 'message_creation', message_creation: array{message_id: string}}, last_error: ?array{code: string, message: string}, expires_at: ?int, cancelled_at: ?int, failed_at: ?int, completed_at: ?int, metadata?: array<string, string>, usage: ?array{prompt_tokens: int, completion_tokens: int, total_tokens: int}}>, first_id: ?string, last_id: ?string, has_more: bool}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        $data = array_map(fn (array $result): ThreadRunStepResponse => ThreadRunStepResponse::from(
            $result,
            $meta,
        ), $attributes['data']);

        return new self(
            $attributes['object'],
            $data,
            $attributes['first_id'],
            $attributes['last_id'],
            $attributes['has_more'],
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'object' => $this->object,
            'data'   => array_map(
                static fn (ThreadRunStepResponse $response): array => $response->toArray(),
                $this->data,
            ),
            'first_id' => $this->firstId,
            'last_id'  => $this->lastId,
            'has_more' => $this->hasMore,
        ];
    }
}
PK     S%W];ÅøI…  …  F  client/src/Responses/Threads/Runs/Steps/ThreadRunStepResponseUsage.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Runs\Steps;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{prompt_tokens: int, completion_tokens: int, total_tokens: int}>
 */
final class ThreadRunStepResponseUsage implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{prompt_tokens: int, completion_tokens: int, total_tokens: int}>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public int $completionTokens,
        public int $promptTokens,
        public int $totalTokens,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{prompt_tokens: int, completion_tokens: int, total_tokens: int}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['completion_tokens'],
            $attributes['prompt_tokens'],
            $attributes['total_tokens'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'prompt_tokens'     => $this->promptTokens,
            'completion_tokens' => $this->completionTokens,
            'total_tokens'      => $this->totalTokens,
        ];
    }
}
PK     S%W]¸­=JŠ  Š  Z  client/src/Responses/Threads/Runs/Steps/ThreadRunStepResponseCodeInterpreterOutputLogs.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Runs\Steps;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{type: 'logs', logs: string}>
 */
final class ThreadRunStepResponseCodeInterpreterOutputLogs implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{type: 'logs', logs: string}>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'logs'  $type
     */
    private function __construct(
        public string $type,
        public string $logs,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{type: 'logs', logs: string}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['type'],
            $attributes['logs'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type' => $this->type,
            'logs' => $this->logs,
        ];
    }
}
PK     S%W]d†º¤	  ¤	  P  client/src/Responses/Threads/Runs/Steps/ThreadRunStepResponseCodeInterpreter.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Runs\Steps;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{input?: string, outputs?: array<int, array{type: 'image', image: array{file_id: string}}|array{type: 'logs', logs: string}>}>
 */
final class ThreadRunStepResponseCodeInterpreter implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{input?: string, outputs?: array<int, array{type: 'image', image: array{file_id: string}}|array{type: 'logs', logs: string}>}>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  \OpenAI\Responses\Threads\Runs\Steps\ThreadRunStepResponseCodeInterpreterOutputLogs[]|\OpenAI\Responses\Threads\Runs\Steps\ThreadRunStepResponseCodeInterpreterOutputImage[]|null  $outputs
     */
    private function __construct(
        public ?string $input,
        public ?array $outputs,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{input?: string, outputs?: array<int, array{type: 'image', image: array{file_id: string}}|array{type: 'logs', logs: string}>}  $attributes
     */
    public static function from(array $attributes): self
    {
        $outputs = array_map(
            fn (array $output): \OpenAI\Responses\Threads\Runs\Steps\ThreadRunStepResponseCodeInterpreterOutputImage|\OpenAI\Responses\Threads\Runs\Steps\ThreadRunStepResponseCodeInterpreterOutputLogs => match ($output['type']) {
                'image' => ThreadRunStepResponseCodeInterpreterOutputImage::from($output),
                'logs'  => ThreadRunStepResponseCodeInterpreterOutputLogs::from($output),
            },
            $attributes['outputs'] ?? [],
        );

        return new self(
            $attributes['input'] ?? null,
            $outputs,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        $response = [];

        if (! is_null($this->input)) {
            $response['input'] = $this->input;
        }

        if ($this->outputs) {
            $response['outputs'] = array_map(
                fn (ThreadRunStepResponseCodeInterpreterOutputImage|ThreadRunStepResponseCodeInterpreterOutputLogs $output): array => $output->toArray(),
                $this->outputs,
            );
        }

        return $response;
    }
}
PK     S%W]Ì61ú  ú  J  client/src/Responses/Threads/Runs/Steps/Delta/ThreadRunStepDeltaObject.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Runs\Steps\Delta;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Threads\Runs\Steps\ThreadRunStepResponseMessageCreationStepDetails;
use OpenAI\Responses\Threads\Runs\Steps\ThreadRunStepResponseToolCallsStepDetails;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{step_details: array{type: 'tool_calls', tool_calls: array<int, array{id: ?string, type: 'code_interpreter', code_interpreter: array{input?: string, outputs?: array<int, array{type: 'image', image: array{file_id: string}}|array{type: 'logs', logs: string}>}}|array{id: string, type: 'file_search', file_search: array<string, string>}|array{id: ?string, type: 'function', function: array{name: ?string, arguments: string, output: ?string}}>}|array{type: 'message_creation', message_creation: array{message_id: string}}}>
 */
final class ThreadRunStepDeltaObject implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{step_details: array{type: 'tool_calls', tool_calls: array<int, array{id: ?string, type: 'code_interpreter', code_interpreter: array{input?: string, outputs?: array<int, array{type: 'image', image: array{file_id: string}}|array{type: 'logs', logs: string}>}}|array{id: string, type: 'file_search', file_search: array<string, string>}|array{id: ?string, type: 'function', function: array{name: ?string, arguments: string, output: ?string}}>}|array{type: 'message_creation', message_creation: array{message_id: string}}}>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public ThreadRunStepResponseMessageCreationStepDetails|ThreadRunStepResponseToolCallsStepDetails $stepDetails,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{step_details: array{type: 'tool_calls', tool_calls: array<int, array{id?: string, type: 'code_interpreter', code_interpreter: array{input: string, outputs?: array<int, array{type: 'image', image: array{file_id: string}}|array{type: 'logs', logs: string}>}}|array{id: string, type: 'file_search', file_search: array<string, string>}|array{id?: string, type: 'function', function: array{name?: string, arguments: string, output?: ?string}}>}|array{type: 'message_creation', message_creation: array{message_id: string}}}  $attributes
     */
    public static function from(array $attributes): self
    {
        $stepDetails = match ($attributes['step_details']['type']) {
            'message_creation' => ThreadRunStepResponseMessageCreationStepDetails::from($attributes['step_details']),
            'tool_calls'       => ThreadRunStepResponseToolCallsStepDetails::from($attributes['step_details']),
        };

        return new self(
            $stepDetails,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'step_details' => $this->stepDetails->toArray(),
        ];
    }
}
PK     S%W]¬­"‹>  >  L  client/src/Responses/Threads/Runs/Steps/Delta/ThreadRunStepDeltaResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Runs\Steps\Delta;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{id: ?string, object: string, delta: array{step_details: array{type: 'tool_calls', tool_calls: array<int, array{id: ?string, type: 'code_interpreter', code_interpreter: array{input?: string, outputs?: array<int, array{type: 'image', image: array{file_id: string}}|array{type: 'logs', logs: string}>}}|array{id: string, type: 'file_search', file_search: array<string, string>}|array{id: ?string, type: 'function', function: array{name: ?string, arguments: string, output: ?string}}>}|array{type: 'message_creation', message_creation: array{message_id: string}}}}>
 */
final class ThreadRunStepDeltaResponse implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{id: ?string, object: string, delta: array{step_details: array{type: 'tool_calls', tool_calls: array<int, array{id: ?string, type: 'code_interpreter', code_interpreter: array{input?: string, outputs?: array<int, array{type: 'image', image: array{file_id: string}}|array{type: 'logs', logs: string}>}}|array{id: string, type: 'file_search', file_search: array<string, string>}|array{id: ?string, type: 'function', function: array{name: ?string, arguments: string, output: ?string}}>}|array{type: 'message_creation', message_creation: array{message_id: string}}}}>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public ?string $id,
        public string $object,
        public ThreadRunStepDeltaObject $delta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{id?: string, object: string, delta: array{step_details: array{type: 'tool_calls', tool_calls: array<int, array{id?: string, type: 'code_interpreter', code_interpreter: array{input: string, outputs?: array<int, array{type: 'image', image: array{file_id: string}}|array{type: 'logs', logs: string}>}}|array{id: string, type: 'file_search', file_search: array<string, string>}|array{id?: string, type: 'function', function: array{name?: string, arguments: string, output?: ?string}}>}|array{type: 'message_creation', message_creation: array{message_id: string}}}}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['id'] ?? null,
            $attributes['object'],
            ThreadRunStepDeltaObject::from($attributes['delta']),
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'     => $this->id,
            'object' => $this->object,
            'delta'  => $this->delta->toArray(),
        ];
    }
}
PK     S%W]¶œ³ô¼  ¼  S  client/src/Responses/Threads/Runs/Steps/ThreadRunStepResponseFileSearchToolCall.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Runs\Steps;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{id: string, type: 'file_search', file_search: array<string, string>}>
 */
final class ThreadRunStepResponseFileSearchToolCall implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{id: string, type: 'file_search', file_search: array<string, string>}>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'file_search'  $type
     * @param  array<string, string>  $file_search
     */
    private function __construct(
        public string $id,
        public string $type,
        public array $file_search,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{id: string, type: 'file_search', file_search: array<string, string>}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['id'],
            $attributes['type'],
            $attributes['file_search'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'          => $this->id,
            'type'        => $this->type,
            'file_search' => $this->file_search,
        ];
    }
}
PK     S%W]EÉ|-§  §  [  client/src/Responses/Threads/Runs/Steps/ThreadRunStepResponseMessageCreationStepDetails.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Runs\Steps;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{type: 'message_creation', message_creation: array{message_id: string}}>
 */
final class ThreadRunStepResponseMessageCreationStepDetails implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{type: 'message_creation', message_creation: array{message_id: string}}>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'message_creation'  $type
     */
    private function __construct(
        public string $type,
        public ThreadRunStepResponseMessageCreation $messageCreation,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{type: 'message_creation', message_creation: array{message_id: string}}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['type'],
            ThreadRunStepResponseMessageCreation::from($attributes['message_creation']),
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type'             => $this->type,
            'message_creation' => $this->messageCreation->toArray(),
        ];
    }
}
PK     S%W]hÖà§k  k  M  client/src/Responses/Threads/Runs/Steps/ThreadRunStepResponseCodeToolCall.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Runs\Steps;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{id: ?string, type: 'code_interpreter', code_interpreter: array{input?: string, outputs?: array<int, array{type: 'image', image: array{file_id: string}}|array{type: 'logs', logs: string}>}}>
 */
final class ThreadRunStepResponseCodeToolCall implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{id: ?string, type: 'code_interpreter', code_interpreter: array{input?: string, outputs?: array<int, array{type: 'image', image: array{file_id: string}}|array{type: 'logs', logs: string}>}}>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'code_interpreter'  $type
     */
    private function __construct(
        public ?string $id,
        public string $type,
        public ThreadRunStepResponseCodeInterpreter $codeInterpreter,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{id?: string, type: 'code_interpreter', code_interpreter: array{input?: string, outputs?: array<int, array{type: 'image', image: array{file_id: string}}|array{type: 'logs', logs: string}>}}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['id'] ?? null,
            $attributes['type'],
            ThreadRunStepResponseCodeInterpreter::from($attributes['code_interpreter']),
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'               => $this->id,
            'type'             => $this->type,
            'code_interpreter' => $this->codeInterpreter->toArray(),
        ];
    }
}
PK     S%W]ï¡V¹Ê  Ê  U  client/src/Responses/Threads/Runs/Steps/ThreadRunStepResponseToolCallsStepDetails.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Runs\Steps;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{type: 'tool_calls', tool_calls: array<int, array{id: ?string, type: 'code_interpreter', code_interpreter: array{input?: string, outputs?: array<int, array{type: 'image', image: array{file_id: string}}|array{type: 'logs', logs: string}>}}|array{id: string, type: 'file_search', file_search: array<string, string>}|array{id: ?string, type: 'function', function: array{name: ?string, arguments: string, output: ?string}}>}>
 */
final class ThreadRunStepResponseToolCallsStepDetails implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{type: 'tool_calls', tool_calls: array<int, array{id: ?string, type: 'code_interpreter', code_interpreter: array{input?: string, outputs?: array<int, array{type: 'image', image: array{file_id: string}}|array{type: 'logs', logs: string}>}}|array{id: string, type: 'file_search', file_search: array<string, string>}|array{id: ?string, type: 'function', function: array{name: ?string, arguments: string, output: ?string}}>}>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'tool_calls'  $type
     * @param  array<int, ThreadRunStepResponseCodeToolCall|ThreadRunStepResponseFileSearchToolCall|ThreadRunStepResponseFunctionToolCall>  $toolCalls
     */
    private function __construct(
        public string $type,
        public array $toolCalls,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{type: 'tool_calls', tool_calls: array<int, array{id?: string, type: 'code_interpreter', code_interpreter: array{input: string, outputs?: array<int, array{type: 'image', image: array{file_id: string}}|array{type: 'logs', logs: string}>}}|array{id: string, type: 'file_search', file_search: array<string, string>}|array{id?: string, type: 'function', function: array{name?: string, arguments: string, output?: ?string}}>}  $attributes
     */
    public static function from(array $attributes): self
    {
        $toolCalls = array_map(
            fn (array $toolCall): ThreadRunStepResponseCodeToolCall|ThreadRunStepResponseFileSearchToolCall|ThreadRunStepResponseFunctionToolCall => match ($toolCall['type']) {
                'code_interpreter' => ThreadRunStepResponseCodeToolCall::from($toolCall),
                'file_search'      => ThreadRunStepResponseFileSearchToolCall::from($toolCall),
                'function'         => ThreadRunStepResponseFunctionToolCall::from($toolCall),
            },
            $attributes['tool_calls'],
        );

        return new self(
            $attributes['type'],
            $toolCalls,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type'       => $this->type,
            'tool_calls' => array_map(
                fn (ThreadRunStepResponseCodeToolCall|ThreadRunStepResponseFileSearchToolCall|ThreadRunStepResponseFunctionToolCall $toolCall): array => $toolCall->toArray(),
                $this->toolCalls,
            ),
        ];
    }
}
PK     S%W]tÛEÔ<  <  [  client/src/Responses/Threads/Runs/Steps/ThreadRunStepResponseCodeInterpreterOutputImage.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Runs\Steps;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{type: 'image', image: array{file_id: string}}>
 */
final class ThreadRunStepResponseCodeInterpreterOutputImage implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{type: 'image', image: array{file_id: string}}>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'image'  $type
     */
    private function __construct(
        public string $type,
        public ThreadRunStepResponseCodeInterpreterOutputImageImage $image,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{type: 'image', image: array{file_id: string}}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['type'],
            ThreadRunStepResponseCodeInterpreterOutputImageImage::from($attributes['image']),
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type'  => $this->type,
            'image' => $this->image->toArray(),
        ];
    }
}
PK     S%W]#Srì    Q  client/src/Responses/Threads/Runs/Steps/ThreadRunStepResponseFunctionToolCall.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Runs\Steps;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{id: ?string, type: 'function', function: array{name: ?string, arguments: string, output: ?string}}>
 */
final class ThreadRunStepResponseFunctionToolCall implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{id: ?string, type: 'function', function: array{name: ?string, arguments: string, output: ?string}}>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'function'  $type
     */
    private function __construct(
        public ?string $id,
        public string $type,
        public ThreadRunStepResponseFunction $function,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{id?: string, type: 'function', function: array{name?: string, arguments: string, output?: ?string}}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['id'] ?? null,
            $attributes['type'],
            ThreadRunStepResponseFunction::from($attributes['function']),
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'       => $this->id,
            'type'     => $this->type,
            'function' => $this->function->toArray(),
        ];
    }
}
PK     S%W]]U³Àë  ë  `  client/src/Responses/Threads/Runs/Steps/ThreadRunStepResponseCodeInterpreterOutputImageImage.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Runs\Steps;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{file_id: string}>
 */
final class ThreadRunStepResponseCodeInterpreterOutputImageImage implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{file_id: string}>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public string $fileId,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{file_id: string}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['file_id'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'file_id' => $this->fileId,
        ];
    }
}
PK     S%W]Äªÿýð  ð  P  client/src/Responses/Threads/Runs/Steps/ThreadRunStepResponseMessageCreation.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Runs\Steps;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{message_id: string}>
 */
final class ThreadRunStepResponseMessageCreation implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{message_id: string}>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public string $messageId,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{message_id: string}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['message_id'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'message_id' => $this->messageId,
        ];
    }
}
PK     S%W]T	«-  -  A  client/src/Responses/Threads/Runs/Steps/ThreadRunStepResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Runs\Steps;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Responses\Threads\Runs\ThreadRunResponseLastError;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{id: string, object: string, created_at: int, thread_id: string, assistant_id: string, run_id: string, type: string, status: string, step_details: array{type: 'tool_calls', tool_calls: array<int, array{id: ?string, type: 'code_interpreter', code_interpreter: array{input?: string, outputs?: array<int, array{type: 'image', image: array{file_id: string}}|array{type: 'logs', logs: string}>}}|array{id: string, type: 'file_search', file_search: array<string, string>}|array{id: ?string, type: 'function', function: array{name: ?string, arguments: string, output: ?string}}>}|array{type: 'message_creation', message_creation: array{message_id: string}}, last_error: ?array{code: string, message: string}, expires_at: ?int, cancelled_at: ?int, failed_at: ?int, completed_at: ?int, metadata?: array<string, string>, usage: ?array{prompt_tokens: int, completion_tokens: int, total_tokens: int}}>
 */
final class ThreadRunStepResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{id: string, object: string, created_at: int, thread_id: string, assistant_id: string, run_id: string, type: string, status: string, step_details: array{type: 'tool_calls', tool_calls: array<int, array{id: ?string, type: 'code_interpreter', code_interpreter: array{input?: string, outputs?: array<int, array{type: 'image', image: array{file_id: string}}|array{type: 'logs', logs: string}>}}|array{id: string, type: 'file_search', file_search: array<string, string>}|array{id: ?string, type: 'function', function: array{name: ?string, arguments: string, output: ?string}}>}|array{type: 'message_creation', message_creation: array{message_id: string}}, last_error: ?array{code: string, message: string}, expires_at: ?int, cancelled_at: ?int, failed_at: ?int, completed_at: ?int, metadata?: array<string, string>, usage: ?array{prompt_tokens: int, completion_tokens: int, total_tokens: int}}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<string, string>  $metadata
     */
    private function __construct(
        public string $id,
        public string $object,
        public int $createdAt,
        public string $threadId,
        public string $assistantId,
        public string $runId,
        public string $type,
        public string $status,
        public ThreadRunStepResponseMessageCreationStepDetails|ThreadRunStepResponseToolCallsStepDetails $stepDetails,
        public ?ThreadRunResponseLastError $lastError,
        public ?int $expiresAt,
        public ?int $cancelledAt,
        public ?int $failedAt,
        public ?int $completedAt,
        public array $metadata,
        private readonly MetaInformation $meta,
        public ?ThreadRunStepResponseUsage $usage
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{id: string, object: string, created_at: int, thread_id: string, assistant_id: string, run_id: string, type: string, status: string, step_details: array{type: 'tool_calls', tool_calls: array<int, array{id?: string, type: 'code_interpreter', code_interpreter: array{input: string, outputs: array<int, array{type: 'image', image: array{file_id: string}}|array{type: 'logs', logs: string}>}}|array{id: string, type: 'file_search', file_search: array<string, string>}|array{id?: string, type: 'function', function: array{name?: string, arguments: string, output?: ?string}}>}|array{type: 'message_creation', message_creation: array{message_id: string}}, last_error: ?array{code: string, message: string}, expires_at: ?int, cancelled_at: ?int, failed_at: ?int, completed_at: ?int, metadata?: array<string, string>, usage: ?array{prompt_tokens: int, completion_tokens: int, total_tokens: int}}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        $stepDetails = match ($attributes['step_details']['type']) {
            'message_creation' => ThreadRunStepResponseMessageCreationStepDetails::from($attributes['step_details']),
            'tool_calls'       => ThreadRunStepResponseToolCallsStepDetails::from($attributes['step_details']),
        };

        return new self(
            $attributes['id'],
            $attributes['object'],
            $attributes['created_at'],
            $attributes['thread_id'],
            $attributes['assistant_id'],
            $attributes['run_id'],
            $attributes['type'],
            $attributes['status'],
            $stepDetails,
            isset($attributes['last_error']) ? ThreadRunResponseLastError::from($attributes['last_error']) : null,
            $attributes['expires_at'],
            $attributes['cancelled_at'],
            $attributes['failed_at'],
            $attributes['completed_at'],
            $attributes['metadata'] ?? [],
            $meta,
            empty($attributes['usage']) ? null : ThreadRunStepResponseUsage::from($attributes['usage']),
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        $data = [
            'id'           => $this->id,
            'object'       => $this->object,
            'created_at'   => $this->createdAt,
            'run_id'       => $this->runId,
            'assistant_id' => $this->assistantId,
            'thread_id'    => $this->threadId,
            'type'         => $this->type,
            'status'       => $this->status,
            'cancelled_at' => $this->cancelledAt,
            'completed_at' => $this->completedAt,
            'expires_at'   => $this->expiresAt,
            'failed_at'    => $this->failedAt,
            'last_error'   => $this->lastError?->toArray(),
            'step_details' => $this->stepDetails->toArray(),
            'usage'        => $this->usage?->toArray(),
        ];

        if ($this->metadata !== []) {
            $data['metadata'] = $this->metadata;
        }

        return $data;
    }
}
PK     S%W]þ6ò)  )  I  client/src/Responses/Threads/Runs/Steps/ThreadRunStepResponseFunction.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Runs\Steps;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{name: ?string, arguments: string, output: ?string}>
 */
final class ThreadRunStepResponseFunction implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{name: ?string, arguments: string, output: ?string}>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public ?string $name,
        public string $arguments,
        public ?string $output,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{name?: string, arguments: string, output?: ?string}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['name'] ?? null,
            $attributes['arguments'],
            $attributes['output'] ?? null,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'name'      => $this->name,
            'arguments' => $this->arguments,
            'output'    => $this->output,
        ];
    }
}
PK     S%W]ö¯i  i  =  client/src/Responses/Threads/Runs/ThreadRunStreamResponse.phpnu „[µü¤        <?php

namespace OpenAI\Responses\Threads\Runs;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Exceptions\UnknownEventException;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Threads\Messages\Delta\ThreadMessageDeltaResponse;
use OpenAI\Responses\Threads\Messages\ThreadMessageResponse;
use OpenAI\Responses\Threads\Runs\Steps\Delta\ThreadRunStepDeltaResponse;
use OpenAI\Responses\Threads\Runs\Steps\ThreadRunStepResponse;
use OpenAI\Responses\Threads\ThreadResponse;
use OpenAI\Testing\Responses\Concerns\FakeableForStreamedResponse;

/**
 * @implements ResponseContract<array{event: string, data: array<string, mixed>}>
 */
class ThreadRunStreamResponse implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{event: string, data: array<string, mixed>}>
     */
    use ArrayAccessible;

    use FakeableForStreamedResponse;

    private function __construct(
        public readonly string $event,
        public readonly ThreadResponse|ThreadRunResponse|ThreadRunStepResponse|ThreadRunStepDeltaResponse|ThreadMessageResponse|ThreadMessageDeltaResponse $response,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     *  Maps the appropriate classes onto each event from the assistants streaming api
     *  https://platform.openai.com/docs/api-reference/assistants-streaming/events
     *
     * @param  array<string, mixed>  $attributes
     */
    public static function from(array $attributes): self
    {
        $event = $attributes['__event'];
        unset($attributes['__event']);

        $meta = $attributes['__meta'];
        unset($attributes['__meta']);

        $response = match ($event) {
            'thread.created' => ThreadResponse::from($attributes, $meta), // @phpstan-ignore-line
            'thread.run.created',
            'thread.run.queued',
            'thread.run.in_progress',
            'thread.run.requires_action',
            'thread.run.completed',
            'thread.run.incomplete',
            'thread.run.failed',
            'thread.run.cancelling',
            'thread.run.cancelled',
            'thread.run.expired' => ThreadRunResponse::from($attributes, $meta), // @phpstan-ignore-line
            'thread.run.step.created',
            'thread.run.step.in_progress',
            'thread.run.step.completed',
            'thread.run.step.failed',
            'thread.run.step.cancelled',
            'thread.run.step.expired' => ThreadRunStepResponse::from($attributes, $meta), // @phpstan-ignore-line
            'thread.run.step.delta'   => ThreadRunStepDeltaResponse::from($attributes), // @phpstan-ignore-line
            'thread.message.created',
            'thread.message.in_progress',
            'thread.message.completed',
            'thread.message.incomplete' => ThreadMessageResponse::from($attributes, $meta), // @phpstan-ignore-line
            'thread.message.delta'      => ThreadMessageDeltaResponse::from($attributes), // @phpstan-ignore-line
            default                     => throw new UnknownEventException('Unknown event: ' . $event),
        };

        return new self(
            $event, // @phpstan-ignore-line
            $response,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'event' => $this->event,
            'data'  => $this->response->toArray(),
        ];
    }
}
PK     S%W]SÚ´DÀ  À  A  client/src/Responses/Threads/Runs/ThreadRunResponseFileSearch.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Runs;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{type: string}>
 */
final class ThreadRunResponseFileSearch implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{type: string}>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public string $type,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{type: 'file_search'}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type' => $this->type,
        ];
    }
}
PK     S%W]I},úÎ  Î  J  client/src/Responses/Threads/Runs/ThreadRunResponseToolCodeInterpreter.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Runs;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{type: string}>
 */
final class ThreadRunResponseToolCodeInterpreter implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{type: string}>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public string $type,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{type: 'code_interpreter'}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type' => $this->type,
        ];
    }
}
PK     S%W]æÖº    C  client/src/Responses/Threads/Runs/ThreadRunResponseToolFunction.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Runs;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{type: string, function: array{description: string, name: string, parameters: array<string, mixed>}}>
 */
final class ThreadRunResponseToolFunction implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{type: string, function: array{description: string, name: string, parameters: array<string, mixed>}}>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public string $type,
        public ThreadRunResponseToolFunctionFunction $function,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{type: 'function', function: array{description: string, name: string, parameters: array<string, mixed>}}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['type'],
            ThreadRunResponseToolFunctionFunction::from($attributes['function']),
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type'     => $this->type,
            'function' => $this->function->toArray(),
        ];
    }
}
PK     S%W]ý%*ÄŠ  Š  I  client/src/Responses/Threads/Runs/ThreadRunResponseTruncationStrategy.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Runs;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{type: string, last_messages: ?int}>
 */
final class ThreadRunResponseTruncationStrategy implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{type: string, last_messages: ?int}>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public string $type,
        public ?int $lastMessages,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{type: string, last_messages: ?int}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['type'],
            $attributes['last_messages'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type'          => $this->type,
            'last_messages' => $this->lastMessages,
        ];
    }
}
PK     S%W]sƒòƒ  ƒ  V  client/src/Responses/Threads/Runs/ThreadRunResponseRequiredActionSubmitToolOutputs.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Runs;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{tool_calls: array<int, array{id: string, type: string, function: array{name: string, arguments: string}}>}>
 */
final class ThreadRunResponseRequiredActionSubmitToolOutputs implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{tool_calls: array<int, array{id: string, type: string, function: array{name: string, arguments: string}}>}>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  array<int, ThreadRunResponseRequiredActionFunctionToolCall>  $toolCalls
     */
    private function __construct(
        public array $toolCalls,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{tool_calls: array<int, array{id: string, type: string, function: array{name: string, arguments: string}}>}  $attributes
     */
    public static function from(array $attributes): self
    {
        $toolCalls = array_map(fn (array $toolCall): ThreadRunResponseRequiredActionFunctionToolCall => ThreadRunResponseRequiredActionFunctionToolCall::from($toolCall), $attributes['tool_calls']);

        return new self(
            $toolCalls,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'tool_calls' => array_map(fn (ThreadRunResponseRequiredActionFunctionToolCall $toolCall): array => $toolCall->toArray(), $this->toolCalls),
        ];
    }
}
PK     S%W]ÞÖ  Ö  U  client/src/Responses/Threads/Runs/ThreadRunResponseRequiredActionFunctionToolCall.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Runs;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{id: string, type: string, function: array{name: string, arguments: string}}>
 */
final class ThreadRunResponseRequiredActionFunctionToolCall implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{id: string, type: string, function: array{name: string, arguments: string}}>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public string $id,
        public string $type,
        public ThreadRunResponseRequiredActionFunctionToolCallFunction $function,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{id: string, type: string, function: array{name: string, arguments: string}}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['id'],
            $attributes['type'],
            ThreadRunResponseRequiredActionFunctionToolCallFunction::from($attributes['function']),
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'       => $this->id,
            'type'     => $this->type,
            'function' => $this->function->toArray(),
        ];
    }
}
PK     S%W]ÁÝŒug  g  E  client/src/Responses/Threads/Runs/ThreadRunResponseRequiredAction.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Runs;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{type: string, submit_tool_outputs: array{tool_calls: array<int, array{id: string, type: string, function: array{name: string, arguments: string}}>}}>
 */
final class ThreadRunResponseRequiredAction implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{type: string, submit_tool_outputs: array{tool_calls: array<int, array{id: string, type: string, function: array{name: string, arguments: string}}>}}>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public string $type,
        public ThreadRunResponseRequiredActionSubmitToolOutputs $submitToolOutputs,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{type: string, submit_tool_outputs: array{tool_calls: array<int, array{id: string, type: string, function: array{name: string, arguments: string}}>}}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['type'],
            ThreadRunResponseRequiredActionSubmitToolOutputs::from($attributes['submit_tool_outputs']),
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type'                => $this->type,
            'submit_tool_outputs' => $this->submitToolOutputs->toArray(),
        ];
    }
}
PK     S%W]ƒìg¦  ¦  K  client/src/Responses/Threads/Runs/ThreadRunResponseToolFunctionFunction.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Runs;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{description: string, name: string, parameters: array<string, mixed>}>
 */
final class ThreadRunResponseToolFunctionFunction implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{description: string, name: string, parameters: array<string, mixed>}>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  array<string, mixed>  $parameters
     */
    private function __construct(
        public string $name,
        public string $description,
        public array $parameters,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{description: string, name: string, parameters: array<string, mixed>}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['name'],
            $attributes['description'],
            $attributes['parameters'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'name'        => $this->name,
            'description' => $this->description,
            'parameters'  => $this->parameters,
        ];
    }
}
PK     S%W]02tÁ  Á  I  client/src/Responses/Threads/Runs/ThreadRunResponseToolChoiceFunction.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Runs;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{name: string}>
 */
final class ThreadRunResponseToolChoiceFunction implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{name: string}>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public string $name,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{name: string}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['name'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'name' => $this->name,
        ];
    }
}
PK     S%W] ©¤í  í  <  client/src/Responses/Threads/Runs/ThreadRunResponseUsage.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Runs;

final class ThreadRunResponseUsage
{
    private function __construct(
        public readonly int $promptTokens,
        public readonly ?int $completionTokens,
        public readonly int $totalTokens,
    ) {}

    /**
     * @param  array{prompt_tokens: int, completion_tokens: int|null, total_tokens: int}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['prompt_tokens'],
            $attributes['completion_tokens'] ?? null,
            $attributes['total_tokens'],
        );
    }

    /**
     * @return array{prompt_tokens: int, completion_tokens: int|null, total_tokens: int}
     */
    public function toArray(): array
    {
        return [
            'prompt_tokens'     => $this->promptTokens,
            'completion_tokens' => $this->completionTokens,
            'total_tokens'      => $this->totalTokens,
        ];
    }
}
PK     S%W]
z¹‚Î  Î  H  client/src/Responses/Threads/Runs/ThreadRunResponseIncompleteDetails.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Runs;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{reason: string}>
 */
final class ThreadRunResponseIncompleteDetails implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{reason: string}>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public string $reason,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{reason: string}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['reason'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'reason' => $this->reason,
        ];
    }
}
PK     S%W]^®„åh'  h'  7  client/src/Responses/Threads/Runs/ThreadRunResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Runs;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Assistants\AssistantResponseResponseFormat;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{id: string, object: string, created_at: int, thread_id: string, assistant_id: string, status: string, required_action?: array{type: string, submit_tool_outputs: array{tool_calls: array<int, array{id: string, type: string, function: array{name: string, arguments: string}}>}}, last_error: ?array{code: string, message: string}, expires_at: ?int, started_at: ?int, cancelled_at: ?int, failed_at: ?int, completed_at: ?int, model: string, instructions: ?string, tools: array<int, array{type: string}|array{type: string}|array{type: string, function: array{description: string, name: string, parameters: array<string, mixed>}}>, metadata: array<string, string>, usage?: array{prompt_tokens: int, completion_tokens: int|null, total_tokens: int}, incomplete_details: null|array{reason: string}, temperature: float|int|null, top_p: null|float|int, max_prompt_tokens: ?int, max_completion_tokens: ?int, truncation_strategy: ?array{type: string, last_messages: ?int}, tool_choice: null|string|array{type: string, function?: array{name: string}}, response_format: null|string|array{type: string}}>
 */
final class ThreadRunResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{id: string, object: string, created_at: int, thread_id: string, assistant_id: string, status: string, required_action?: array{type: string, submit_tool_outputs: array{tool_calls: array<int, array{id: string, type: string, function: array{name: string, arguments: string}}>}}, last_error: ?array{code: string, message: string}, expires_at: ?int, started_at: ?int, cancelled_at: ?int, failed_at: ?int, completed_at: ?int, model: string, instructions: ?string, tools: array<int, array{type: string}|array{type: string}|array{type: string, function: array{description: string, name: string, parameters: array<string, mixed>}}>, metadata: array<string, string>, usage?: array{prompt_tokens: int, completion_tokens: int|null, total_tokens: int}, incomplete_details: ?array{reason: string}, temperature: float|int|null, top_p: null|float|int, max_prompt_tokens: ?int, max_completion_tokens: ?int, truncation_strategy: ?array{type: string, last_messages: ?int}, tool_choice: null|string|array{type: string, function?: array{name: string}}, response_format: null|string|array{type: string}}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<int, ThreadRunResponseToolCodeInterpreter|ThreadRunResponseFileSearch|ThreadRunResponseToolFunction>  $tools
     * @param  array<string, string>  $metadata
     */
    private function __construct(
        public string $id,
        public string $object,
        public int $createdAt,
        public string $threadId,
        public string $assistantId,
        public string $status,
        public ?ThreadRunResponseRequiredAction $requiredAction,
        public ?ThreadRunResponseLastError $lastError,
        public ?int $expiresAt,
        public ?int $startedAt,
        public ?int $cancelledAt,
        public ?int $failedAt,
        public ?int $completedAt,
        public ?ThreadRunResponseIncompleteDetails $incompleteDetails,
        public string $model,
        public ?string $instructions,
        public array $tools,
        public array $metadata,
        public ?ThreadRunResponseUsage $usage,
        public ?float $temperature,
        public ?float $topP,
        public ?int $maxPromptTokens,
        public ?int $maxCompletionTokens,
        public ?ThreadRunResponseTruncationStrategy $truncationStrategy,
        public null|string|ThreadRunResponseToolChoice $toolChoice,
        public null|string|AssistantResponseResponseFormat $responseFormat,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{id: string, object: string, created_at: int, thread_id: string, assistant_id: string, status: string, required_action?: array{type: string, submit_tool_outputs: array{tool_calls: array<int, array{id: string, type: string, function: array{name: string, arguments: string}}>}}, last_error: ?array{code: string, message: string}, expires_at: ?int, started_at: ?int, cancelled_at: ?int, failed_at: ?int, completed_at: ?int, model: string, instructions: ?string, tools: array<int, array{type: 'code_interpreter'}|array{type: 'file_search'}|array{type: 'function', function: array{description: string, name: string, parameters: array<string, mixed>}}>, metadata: array<string, string>, usage?: array{prompt_tokens: int, completion_tokens: int|null, total_tokens: int}, incomplete_details: ?array{reason: string}, temperature: float|int|null, top_p: null|float|int, max_prompt_tokens: ?int, max_completion_tokens: ?int, truncation_strategy: ?array{type: string, last_messages: ?int}, tool_choice: null|string|array{type: string, function?: array{name: string}}, response_format: null|string|array{type: 'text'|'json_object'}}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        $tools = array_map(
            fn (array $tool): ThreadRunResponseToolCodeInterpreter|ThreadRunResponseFileSearch|ThreadRunResponseToolFunction => match ($tool['type']) {
                'code_interpreter' => ThreadRunResponseToolCodeInterpreter::from($tool),
                'file_search'      => ThreadRunResponseFileSearch::from($tool),
                'function'         => ThreadRunResponseToolFunction::from($tool),
            },
            $attributes['tools'],
        );

        $responseFormat = is_array($attributes['response_format']) ?
            AssistantResponseResponseFormat::from($attributes['response_format']) :
            $attributes['response_format'];

        return new self(
            $attributes['id'],
            $attributes['object'],
            $attributes['created_at'],
            $attributes['thread_id'],
            $attributes['assistant_id'],
            $attributes['status'],
            isset($attributes['required_action']) ? ThreadRunResponseRequiredAction::from($attributes['required_action']) : null,
            isset($attributes['last_error']) ? ThreadRunResponseLastError::from($attributes['last_error']) : null,
            $attributes['expires_at'],
            $attributes['started_at'],
            $attributes['cancelled_at'],
            $attributes['failed_at'],
            $attributes['completed_at'],
            isset($attributes['incomplete_details']) ? ThreadRunResponseIncompleteDetails::from($attributes['incomplete_details']) : null,
            $attributes['model'],
            $attributes['instructions'],
            $tools,
            $attributes['metadata'],
            isset($attributes['usage']) ? ThreadRunResponseUsage::from($attributes['usage']) : null,
            $attributes['temperature'] ?? null,
            $attributes['top_p'] ?? null,
            $attributes['max_prompt_tokens'] ?? null,
            $attributes['max_completion_tokens'] ?? null,
            $attributes['truncation_strategy'] !== null ? ThreadRunResponseTruncationStrategy::from($attributes['truncation_strategy']) : null,
            is_array($attributes['tool_choice']) ? ThreadRunResponseToolChoice::from($attributes['tool_choice']) : $attributes['tool_choice'],
            $responseFormat,
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        $data = [
            'id'                 => $this->id,
            'object'             => $this->object,
            'created_at'         => $this->createdAt,
            'assistant_id'       => $this->assistantId,
            'thread_id'          => $this->threadId,
            'status'             => $this->status,
            'started_at'         => $this->startedAt,
            'expires_at'         => $this->expiresAt,
            'cancelled_at'       => $this->cancelledAt,
            'failed_at'          => $this->failedAt,
            'completed_at'       => $this->completedAt,
            'incomplete_details' => $this->incompleteDetails?->toArray(),
            'required_action'    => $this->requiredAction?->toArray(),
            'last_error'         => $this->lastError?->toArray(),
            'model'              => $this->model,
            'instructions'       => $this->instructions,
            'tools'              => array_map(
                fn (ThreadRunResponseToolCodeInterpreter|ThreadRunResponseFileSearch|ThreadRunResponseToolFunction $tool): array => $tool->toArray(),
                $this->tools,
            ),
            'metadata'              => $this->metadata,
            'usage'                 => $this->usage?->toArray(),
            'temperature'           => $this->temperature,
            'top_p'                 => $this->topP,
            'max_prompt_tokens'     => $this->maxPromptTokens,
            'max_completion_tokens' => $this->maxCompletionTokens,
            'truncation_strategy'   => $this->truncationStrategy?->toArray(),
            'tool_choice'           => $this->toolChoice instanceof ThreadRunResponseToolChoice ? $this->toolChoice->toArray() : $this->toolChoice,
            'response_format'       => $this->responseFormat instanceof AssistantResponseResponseFormat ? $this->responseFormat->toArray() : $this->responseFormat,
        ];

        if ($data['required_action'] === null) {
            unset($data['required_action']);
        }

        if ($data['usage'] === null) {
            unset($data['usage']);
        }

        return $data;
    }
}
PK     S%W]}Tˆ  ˆ  ]  client/src/Responses/Threads/Runs/ThreadRunResponseRequiredActionFunctionToolCallFunction.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Runs;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{name: string, arguments: string}>
 */
final class ThreadRunResponseRequiredActionFunctionToolCallFunction implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{name: string, arguments: string}>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public string $name,
        public string $arguments,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{name: string, arguments: string}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['name'],
            $attributes['arguments'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'name'      => $this->name,
            'arguments' => $this->arguments,
        ];
    }
}
PK     S%W]ôãëâ  â  ;  client/src/Responses/Threads/Runs/ThreadRunListResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Runs;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{object: string, data: array<int, array{id: string, object: string, created_at: int, thread_id: string, assistant_id: string, status: string, required_action?: array{type: string, submit_tool_outputs: array{tool_calls: array<int, array{id: string, type: string, function: array{name: string, arguments: string}}>}}, last_error: ?array{code: string, message: string}, expires_at: ?int, started_at: ?int, cancelled_at: ?int, failed_at: ?int, completed_at: ?int, model: string, instructions: ?string, tools: array<int, array{type: string}|array{type: string}|array{type: string, function: array{description: string, name: string, parameters: array<string, mixed>}}>, metadata: array<string, string>, usage?: array{prompt_tokens: int, completion_tokens: int|null, total_tokens: int}, incomplete_details: null|array{reason: string}, temperature: float|int|null, top_p: null|float|int, max_prompt_tokens: ?int, max_completion_tokens: ?int, truncation_strategy: ?array{type: string, last_messages: ?int}, tool_choice: null|string|array{type: string, function?: array{name: string}}, response_format: null|string|array{type: string}}>, first_id: ?string, last_id: ?string, has_more: bool}>
 */
final class ThreadRunListResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{object: string, data: array<int, array{id: string, object: string, created_at: int, thread_id: string, assistant_id: string, status: string, required_action?: array{type: string, submit_tool_outputs: array{tool_calls: array<int, array{id: string, type: string, function: array{name: string, arguments: string}}>}}, last_error: ?array{code: string, message: string}, expires_at: ?int, started_at: ?int, cancelled_at: ?int, failed_at: ?int, completed_at: ?int, model: string, instructions: ?string, tools: array<int, array{type: string}|array{type: string}|array{type: string, function: array{description: string, name: string, parameters: array<string, mixed>}}>, metadata: array<string, string>, usage?: array{prompt_tokens: int, completion_tokens: int|null, total_tokens: int}, incomplete_details: null|array{reason: string}, temperature: float|int|null, top_p: null|float|int, max_prompt_tokens: ?int, max_completion_tokens: ?int, truncation_strategy: ?array{type: string, last_messages: ?int}, tool_choice: null|string|array{type: string, function?: array{name: string}}, response_format: null|string|array{type: string}}>, first_id: ?string, last_id: ?string, has_more: bool}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<int, ThreadRunResponse>  $data
     */
    private function __construct(
        public readonly string $object,
        public readonly array $data,
        public readonly ?string $firstId,
        public readonly ?string $lastId,
        public readonly bool $hasMore,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{object: string, data: array<int, array{id: string, object: string, created_at: int, thread_id: string, assistant_id: string, status: string, required_action?: array{type: string, submit_tool_outputs: array{tool_calls: array<int, array{id: string, type: string, function: array{name: string, arguments: string}}>}}, last_error: ?array{code: string, message: string}, expires_at: ?int, started_at: ?int, cancelled_at: ?int, failed_at: ?int, completed_at: ?int, model: string, instructions: ?string, tools: array<int, array{type: 'code_interpreter'}|array{type: 'file_search'}|array{type: 'function', function: array{description: string, name: string, parameters: array<string, mixed>}}>, metadata: array<string, string>, usage?: array{prompt_tokens: int, completion_tokens: int|null, total_tokens: int}, incomplete_details: ?array{reason: string}, temperature: float|int|null, top_p: null|float|int, max_prompt_tokens: ?int, max_completion_tokens: ?int, truncation_strategy: array{type: string, last_messages: ?int}, tool_choice: string|array{type: string, function?: array{name: string}}, response_format: string|array{type: 'text'|'json_object'}}>, first_id: ?string, last_id: ?string, has_more: bool}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        $data = array_map(fn (array $result): ThreadRunResponse => ThreadRunResponse::from(
            $result,
            $meta,
        ), $attributes['data']);

        return new self(
            $attributes['object'],
            $data,
            $attributes['first_id'],
            $attributes['last_id'],
            $attributes['has_more'],
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'object' => $this->object,
            'data'   => array_map(
                static fn (ThreadRunResponse $response): array => $response->toArray(),
                $this->data,
            ),
            'first_id' => $this->firstId,
            'last_id'  => $this->lastId,
            'has_more' => $this->hasMore,
        ];
    }
}
PK     S%W]ë&ãè  è  \  client/src/Responses/Threads/Messages/ThreadMessageResponseContentTextAnnotationFilePath.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Messages;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{file_id: string}>
 */
final class ThreadMessageResponseContentTextAnnotationFilePath implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{file_id: string}>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public string $fileId,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{file_id: string}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['file_id'],

        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'file_id' => $this->fileId,
        ];
    }
}
PK     S%W]‰3,Ç  Ç  `  client/src/Responses/Threads/Messages/ThreadMessageResponseContentTextAnnotationFileCitation.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Messages;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{file_id: string, quote?: string}>
 */
final class ThreadMessageResponseContentTextAnnotationFileCitation implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{file_id: string, quote?: string}>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public string $fileId,
        public ?string $quote,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{file_id: string, quote?: string}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['file_id'],
            $attributes['quote'] ?? null,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return array_filter([
            'file_id' => $this->fileId,
            'quote'   => $this->quote,
        ], fn (?string $value): bool => $value !== null);
    }
}
PK     S%W]±ÿí;  ;  H  client/src/Responses/Threads/Messages/Delta/ThreadMessageDeltaObject.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Messages\Delta;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{role: ?string, content: array<int, array{index: int, type: 'image_file', image_file: array{file_id: string, detail?: string}}|array{index: int, type: 'text', text: array{value: ?string, annotations: array<int, array{type: 'file_citation', text: string, file_citation: array{file_id: string, quote?: string}, start_index: int, end_index: int}|array{type: 'file_path', text: string, file_path: array{file_id: string}, start_index: int, end_index: int}>}}>, file_ids: ?array<int, string>}>
 */
final class ThreadMessageDeltaObject implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{role: ?string, content: array<int, array{index: int, type: 'image_file', image_file: array{file_id: string, detail?: string}}|array{index: int, type: 'text', text: array{value: ?string, annotations: array<int, array{type: 'file_citation', text: string, file_citation: array{file_id: string, quote?: string}, start_index: int, end_index: int}|array{type: 'file_path', text: string, file_path: array{file_id: string}, start_index: int, end_index: int}>}}>, file_ids: ?array<int, string>}>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  array<int, ThreadMessageDeltaResponseContentImageFileObject|ThreadMessageDeltaResponseContentTextObject>  $content
     * @param  array<int, string>|null  $fileIds
     */
    private function __construct(
        public ?string $role,
        public array $content,
        public ?array $fileIds,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{role?: string, content: array<int, array{index: int, type: 'image_file', image_file: array{file_id: string, detail?: string}}|array{index: int, type: 'text', text: array{value?: string, annotations: array<int, array{type: 'file_citation', text: string, file_citation: array{file_id: string, quote?: string}, start_index: int, end_index: int}|array{type: 'file_path', text: string, file_path: array{file_id: string}, start_index: int, end_index: int}>}}>, file_ids?: array<int, string>}  $attributes
     */
    public static function from(array $attributes): self
    {
        $content = array_map(
            fn (array $content): ThreadMessageDeltaResponseContentTextObject|ThreadMessageDeltaResponseContentImageFileObject => match ($content['type']) {
                'text'       => ThreadMessageDeltaResponseContentTextObject::from($content),
                'image_file' => ThreadMessageDeltaResponseContentImageFileObject::from($content),
            },
            $attributes['content'],
        );

        return new self(
            $attributes['role'] ?? null,
            $content,
            $attributes['file_ids'] ?? null,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'role'     => $this->role,
            'content'  => array_map(fn (ThreadMessageDeltaResponseContentImageFileObject|ThreadMessageDeltaResponseContentTextObject $content): array => $content->toArray(), $this->content),
            'file_ids' => $this->fileIds,
        ];
    }
}
PK     S%W]2Äœh  h  `  client/src/Responses/Threads/Messages/Delta/ThreadMessageDeltaResponseContentImageFileObject.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Messages\Delta;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Threads\Messages\ThreadMessageResponseContentImageFile;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{index: int, type: 'image_file', image_file: array{file_id: string, detail?: string}}>
 */
final class ThreadMessageDeltaResponseContentImageFileObject implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{index: int, type: 'image_file', image_file: array{file_id: string, detail?: string}}>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'image_file'  $type
     */
    private function __construct(
        public int $index,
        public string $type,
        public ThreadMessageResponseContentImageFile $imageFile,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{index: int, type: 'image_file', image_file: array{file_id: string, detail?: string}}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['index'],
            $attributes['type'],
            ThreadMessageResponseContentImageFile::from($attributes['image_file']),
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'index'      => $this->index,
            'type'       => $this->type,
            'image_file' => $this->imageFile->toArray(),
        ];
    }
}
PK     S%W]õÂQUµ  µ  [  client/src/Responses/Threads/Messages/Delta/ThreadMessageDeltaResponseContentTextObject.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Messages\Delta;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{index: int, type: 'text', text: array{value: ?string, annotations: array<int, array{type: 'file_citation', text: string, file_citation: array{file_id: string, quote?: string}, start_index: int, end_index: int}|array{type: 'file_path', text: string, file_path: array{file_id: string}, start_index: int, end_index: int}>}}>
 */
final class ThreadMessageDeltaResponseContentTextObject implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{index: int, type: 'text', text: array{value: ?string, annotations: array<int, array{type: 'file_citation', text: string, file_citation: array{file_id: string, quote?: string}, start_index: int, end_index: int}|array{type: 'file_path', text: string, file_path: array{file_id: string}, start_index: int, end_index: int}>}}>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'text'  $type
     */
    private function __construct(
        public int $index,
        public string $type,
        public ThreadMessageDeltaResponseContentText $text,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{index: int, type: 'text', text: array{value?: string, annotations: array<int, array{type: 'file_citation', text: string, file_citation: array{file_id: string, quote?: string}, start_index: int, end_index: int}|array{type: 'file_path', text: string, file_path: array{file_id: string}, start_index: int, end_index: int}>}}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['index'],
            $attributes['type'],
            ThreadMessageDeltaResponseContentText::from($attributes['text']),
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'index' => $this->index,
            'type'  => $this->type,
            'text'  => $this->text->toArray(),
        ];
    }
}
PK     S%W]èºl·    U  client/src/Responses/Threads/Messages/Delta/ThreadMessageDeltaResponseContentText.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Messages\Delta;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Threads\Messages\ThreadMessageResponseContentTextAnnotationFileCitationObject;
use OpenAI\Responses\Threads\Messages\ThreadMessageResponseContentTextAnnotationFilePathObject;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{value: ?string, annotations: array<int, array{type: 'file_citation', text: string, file_citation: array{file_id: string, quote?: string}, start_index: int, end_index: int}|array{type: 'file_path', text: string, file_path: array{file_id: string}, start_index: int, end_index: int}>}>
 */
final class ThreadMessageDeltaResponseContentText implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{value: ?string, annotations: array<int, array{type: 'file_citation', text: string, file_citation: array{file_id: string, quote?: string}, start_index: int, end_index: int}|array{type: 'file_path', text: string, file_path: array{file_id: string}, start_index: int, end_index: int}>}>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  \OpenAI\Responses\Threads\Messages\ThreadMessageResponseContentTextAnnotationFilePathObject[]|\OpenAI\Responses\Threads\Messages\ThreadMessageResponseContentTextAnnotationFileCitationObject[]  $annotations
     */
    private function __construct(
        public ?string $value,
        public array $annotations,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{value?: string, annotations?: array<int, array{type: 'file_citation', text: string, file_citation: array{file_id: string, quote?: string}, start_index: int, end_index: int}|array{type: 'file_path', text: string, file_path: array{file_id: string}, start_index: int, end_index: int}>}  $attributes
     */
    public static function from(array $attributes): self
    {
        $annotations = array_map(
            fn (array $annotation): ThreadMessageResponseContentTextAnnotationFileCitationObject|ThreadMessageResponseContentTextAnnotationFilePathObject => match ($annotation['type']) {
                'file_citation' => ThreadMessageResponseContentTextAnnotationFileCitationObject::from($annotation),
                'file_path'     => ThreadMessageResponseContentTextAnnotationFilePathObject::from($annotation),
            },
            $attributes['annotations'] ?? [],
        );

        return new self(
            $attributes['value'] ?? null,
            $annotations,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'value'       => $this->value,
            'annotations' => array_map(
                fn (ThreadMessageResponseContentTextAnnotationFilePathObject|ThreadMessageResponseContentTextAnnotationFileCitationObject $annotation): array => $annotation->toArray(),
                $this->annotations,
            ),
        ];
    }
}
PK     S%W]øóäÆ¬
  ¬
  J  client/src/Responses/Threads/Messages/Delta/ThreadMessageDeltaResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Messages\Delta;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{id: string, object: string, delta: array{role: string|null, content: array<int, array{index: int, type: 'image_file', image_file: array{file_id: string}}|array{index: int, type: 'text', text: array{value: ?string, annotations: array<int, array{type: 'file_citation', text: string, file_citation: array{file_id: string, quote?: string}, start_index: int, end_index: int}|array{type: 'file_path', text: string, file_path: array{file_id: string}, start_index: int, end_index: int}>}}>, file_ids: array<int, string>|null}}>
 */
final class ThreadMessageDeltaResponse implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{id: string, object: string, delta: array{role: string|null, content: array<int, array{index: int, type: 'image_file', image_file: array{file_id: string}}|array{index: int, type: 'text', text: array{value: ?string, annotations: array<int, array{type: 'file_citation', text: string, file_citation: array{file_id: string, quote?: string}, start_index: int, end_index: int}|array{type: 'file_path', text: string, file_path: array{file_id: string}, start_index: int, end_index: int}>}}>, file_ids: array<int, string>|null}}>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public string $id,
        public string $object,
        public ThreadMessageDeltaObject $delta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{id: string, object: string, delta: array{role?: string, content: array<int, array{index: int, type: 'image_file', image_file: array{file_id: string}}|array{index: int, type: 'text', text: array{value?: string, annotations: array<int, array{type: 'file_citation', text: string, file_citation: array{file_id: string, quote?: string}, start_index: int, end_index: int}|array{type: 'file_path', text: string, file_path: array{file_id: string}, start_index: int, end_index: int}>}}>, file_ids?: array<int, string>}}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['id'],
            $attributes['object'],
            ThreadMessageDeltaObject::from($attributes['delta'])
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'     => $this->id,
            'object' => $this->object,
            'delta'  => $this->delta->toArray(),
        ];
    }
}
PK     S%W]ß‚îÁ  Á  f  client/src/Responses/Threads/Messages/ThreadMessageResponseContentTextAnnotationFileCitationObject.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Messages;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{type: 'file_citation', text: string, file_citation: array{file_id: string, quote?: string}, start_index: int, end_index: int}>
 */
final class ThreadMessageResponseContentTextAnnotationFileCitationObject implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{type: 'file_citation', text: string, file_citation: array{file_id: string, quote?: string}, start_index: int, end_index: int}>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'file_citation'  $type
     */
    private function __construct(
        public string $type,
        public string $text,
        public int $startIndex,
        public int $endIndex,
        public ThreadMessageResponseContentTextAnnotationFileCitation $fileCitation,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{type: 'file_citation', text: string, file_citation: array{file_id: string, quote?: string}, start_index: int, end_index: int}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['type'],
            $attributes['text'],
            $attributes['start_index'],
            $attributes['end_index'],
            ThreadMessageResponseContentTextAnnotationFileCitation::from($attributes['file_citation']),
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type'          => $this->type,
            'text'          => $this->text,
            'start_index'   => $this->startIndex,
            'end_index'     => $this->endIndex,
            'file_citation' => $this->fileCitation->toArray(),
        ];
    }
}
PK     S%W]xå¹l  l  T  client/src/Responses/Threads/Messages/ThreadMessageResponseContentImageUrlObject.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Messages;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{type: 'image_url', image_url: array{url: string, detail?: string}}>
 */
final class ThreadMessageResponseContentImageUrlObject implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{type: 'image_url', image_url: array{url: string, detail?: string}}>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'image_url'  $type
     */
    private function __construct(
        public string $type,
        public ThreadMessageResponseContentImageUrl $imageFile,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{type: 'image_url', image_url: array{url: string, detail?: string}}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['type'],
            ThreadMessageResponseContentImageUrl::from($attributes['image_url']),
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type'      => $this->type,
            'image_url' => $this->imageFile->toArray(),
        ];
    }
}
PK     S%W]üzÆ*ò
  ò
  J  client/src/Responses/Threads/Messages/ThreadMessageResponseContentText.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Messages;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{value: string, annotations: array<int, array{type: 'file_citation', text: string, file_citation: array{file_id: string, quote?: string}, start_index: int, end_index: int}|array{type: 'file_path', text: string, file_path: array{file_id: string}, start_index: int, end_index: int}>}>
 */
final class ThreadMessageResponseContentText implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{value: string, annotations: array<int, array{type: 'file_citation', text: string, file_citation: array{file_id: string, quote?: string}, start_index: int, end_index: int}|array{type: 'file_path', text: string, file_path: array{file_id: string}, start_index: int, end_index: int}>}>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  array<int, ThreadMessageResponseContentTextAnnotationFilePathObject|ThreadMessageResponseContentTextAnnotationFileCitationObject>  $annotations
     */
    private function __construct(
        public string $value,
        public array $annotations,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{value: string, annotations: array<int, array{type: 'file_citation', text: string, file_citation: array{file_id: string, quote?: string}, start_index: int, end_index: int}|array{type: 'file_path', text: string, file_path: array{file_id: string}, start_index: int, end_index: int}>}  $attributes
     */
    public static function from(array $attributes): self
    {
        $annotations = array_map(
            fn (array $annotation): ThreadMessageResponseContentTextAnnotationFileCitationObject|ThreadMessageResponseContentTextAnnotationFilePathObject => match ($annotation['type']) {
                'file_citation' => ThreadMessageResponseContentTextAnnotationFileCitationObject::from($annotation),
                'file_path'     => ThreadMessageResponseContentTextAnnotationFilePathObject::from($annotation),
            },
            $attributes['annotations'],
        );

        return new self(
            $attributes['value'],
            $annotations,

        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'value'       => $this->value,
            'annotations' => array_map(
                fn (ThreadMessageResponseContentTextAnnotationFilePathObject|ThreadMessageResponseContentTextAnnotationFileCitationObject $annotation): array => $annotation->toArray(),
                $this->annotations,
            ),
        ];
    }
}
PK     S%W]aŠ<­  ­  I  client/src/Responses/Threads/Messages/ThreadMessageResponseAttachment.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Messages;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{file_id: string, tools: array<int, array{type: string}>}>
 */
final class ThreadMessageResponseAttachment implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{file_id: string, tools: array<int, array{type: string}>}>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  array<int,ThreadMessageResponseAttachmentFileSearchTool|ThreadMessageResponseAttachmentCodeInterpreterTool>  $tools
     */
    private function __construct(
        public string $fileId,
        public array $tools,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{file_id: string, tools: array<int, array{type: 'file_search'}|array{type: 'code_interpreter'}>}  $attributes
     */
    public static function from(array $attributes): self
    {
        $tools = array_map(fn (array $tool): ThreadMessageResponseAttachmentFileSearchTool|ThreadMessageResponseAttachmentCodeInterpreterTool => match ($tool['type']) {
            'file_search'      => ThreadMessageResponseAttachmentFileSearchTool::from($tool),
            'code_interpreter' => ThreadMessageResponseAttachmentCodeInterpreterTool::from($tool),
        }, $attributes['tools']);

        return new self(
            $attributes['file_id'],
            $tools,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'file_id' => $this->fileId,
            'tools'   => array_map(
                fn (ThreadMessageResponseAttachmentCodeInterpreterTool|ThreadMessageResponseAttachmentFileSearchTool $tool): array => $tool->toArray(),
                $this->tools,
            ),
        ];
    }
}
PK     S%W]4Í‰Í    P  client/src/Responses/Threads/Messages/ThreadMessageResponseContentTextObject.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Messages;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{type: 'text', text: array{value: string, annotations: array<int, array{type: 'file_citation', text: string, file_citation: array{file_id: string, quote?: string}, start_index: int, end_index: int}|array{type: 'file_path', text: string, file_path: array{file_id: string}, start_index: int, end_index: int}>}}>
 */
final class ThreadMessageResponseContentTextObject implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{type: 'text', text: array{value: string, annotations: array<int, array{type: 'file_citation', text: string, file_citation: array{file_id: string, quote?: string}, start_index: int, end_index: int}|array{type: 'file_path', text: string, file_path: array{file_id: string}, start_index: int, end_index: int}>}}>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'text'  $type
     */
    private function __construct(
        public string $type,
        public ThreadMessageResponseContentText $text,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{type: 'text', text: array{value: string, annotations: array<int, array{type: 'file_citation', text: string, file_citation: array{file_id: string, quote?: string}, start_index: int, end_index: int}|array{type: 'file_path', text: string, file_path: array{file_id: string}, start_index: int, end_index: int}>}}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['type'],
            ThreadMessageResponseContentText::from($attributes['text']),
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type' => $this->type,
            'text' => $this->text->toArray(),
        ];
    }
}
PK     S%W]3¡¾ÄÖ  Ö  P  client/src/Responses/Threads/Messages/ThreadMessageResponseIncompleteDetails.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Messages;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{reason: string}>
 */
final class ThreadMessageResponseIncompleteDetails implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{reason: string}>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public string $reason,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{reason: string}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['reason'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'reason' => $this->reason,
        ];
    }
}
PK     S%W]EÅn¡¼  ¼  O  client/src/Responses/Threads/Messages/ThreadMessageResponseContentImageFile.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Messages;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{file_id: string, detail?: string}>
 */
final class ThreadMessageResponseContentImageFile implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{file_id: string, detail?: string}>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public string $fileId,
        public ?string $detail,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{file_id: string, detail?: string}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['file_id'],
            $attributes['detail'] ?? null,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return array_filter([
            'file_id' => $this->fileId,
            'detail'  => $this->detail,
        ], fn (?string $value): bool => $value !== null);
    }
}
PK     S%W]jšùB    W  client/src/Responses/Threads/Messages/ThreadMessageResponseAttachmentFileSearchTool.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Messages;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{type: 'file_search'}>
 */
final class ThreadMessageResponseAttachmentFileSearchTool implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{type: 'file_search'}>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'file_search'  $type
     */
    private function __construct(
        public string $type,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{type: 'file_search'}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type' => $this->type,
        ];
    }
}
PK     S%W]ž3e1  1  \  client/src/Responses/Threads/Messages/ThreadMessageResponseAttachmentCodeInterpreterTool.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Messages;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{type: 'code_interpreter'}>
 */
final class ThreadMessageResponseAttachmentCodeInterpreterTool implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{type: 'code_interpreter'}>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'code_interpreter'  $type
     */
    private function __construct(
        public string $type,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{type: 'code_interpreter'}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type' => $this->type,
        ];
    }
}
PK     S%W]wD‹¬  ¬  C  client/src/Responses/Threads/Messages/ThreadMessageListResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Messages;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{object: string, data: array<int, array{id: string, object: string, created_at: int, thread_id: string, role: string, content: array<int, array{type: 'text', text: array{value: string, annotations: array<int, array{type: 'file_citation', text: string, file_citation: array{file_id: string, quote?: string}, start_index: int, end_index: int}|array{type: 'file_path', text: string, file_path: array{file_id: string}, start_index: int, end_index: int}>}}|array{type: string, image_file: array{file_id: string}}|array{type: 'image_url', image_url: array{url: string, detail?: string}}>, assistant_id: ?string, run_id: ?string, attachments: array<int, array{file_id: string, tools: array<int, array{type: string}>}>, metadata: array<string, string>}>, first_id: ?string, last_id: ?string, has_more: bool}>
 */
final class ThreadMessageListResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{object: string, data: array<int, array{id: string, object: string, created_at: int, thread_id: string, role: string, content: array<int, array{type: 'text', text: array{value: string, annotations: array<int, array{type: 'file_citation', text: string, file_citation: array{file_id: string, quote?: string}, start_index: int, end_index: int}|array{type: 'file_path', text: string, file_path: array{file_id: string}, start_index: int, end_index: int}>}}|array{type: string, image_file: array{file_id: string}}|array{type: 'image_url', image_url: array{url: string, detail?: string}}>, assistant_id: ?string, run_id: ?string, attachments: array<int, array{file_id: string, tools: array<int, array{type: string}>}>, metadata: array<string, string>}>, first_id: ?string, last_id: ?string, has_more: bool}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<int, ThreadMessageResponse>  $data
     */
    private function __construct(
        public readonly string $object,
        public readonly array $data,
        public readonly ?string $firstId,
        public readonly ?string $lastId,
        public readonly bool $hasMore,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{object: string, data: array<int, array{id: string, object: string, created_at: int, thread_id: string, role: string, content: array<int, array{type: 'image_url', image_url: array{url: string, detail?: string}}|array{type: 'image_file', image_file: array{file_id: string, detail?: string}}|array{type: 'text', text: array{value: string, annotations: array<int, array{type: 'file_citation', text: string, file_citation: array{file_id: string, quote?: string}, start_index: int, end_index: int}|array{type: 'file_path', text: string, file_path: array{file_id: string}, start_index: int, end_index: int}>}}>, assistant_id: ?string, run_id: ?string, attachments?: array<int, array{file_id: string, tools: array<int, array{type: 'file_search'}|array{type: 'code_interpreter'}>}>, metadata: array<string, string>}>, first_id: ?string, last_id: ?string, has_more: bool}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        $data = array_map(fn (array $result): ThreadMessageResponse => ThreadMessageResponse::from(
            $result,
            $meta,
        ), $attributes['data']);

        return new self(
            $attributes['object'],
            $data,
            $attributes['first_id'],
            $attributes['last_id'],
            $attributes['has_more'],
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'object' => $this->object,
            'data'   => array_map(
                static fn (ThreadMessageResponse $response): array => $response->toArray(),
                $this->data,
            ),
            'first_id' => $this->firstId,
            'last_id'  => $this->lastId,
            'has_more' => $this->hasMore,
        ];
    }
}
PK     S%W]`iú1  1  E  client/src/Responses/Threads/Messages/ThreadMessageDeleteResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Messages;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{id: string, object: string, deleted: bool}>
 */
final class ThreadMessageDeleteResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{id: string, object: string, deleted: bool}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly string $id,
        public readonly string $object,
        public readonly bool $deleted,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{id: string, object: string, deleted: bool}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            $attributes['id'],
            $attributes['object'],
            $attributes['deleted'],
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'      => $this->id,
            'object'  => $this->object,
            'deleted' => $this->deleted,
        ];
    }
}
PK     S%W]û×ì  ì  ?  client/src/Responses/Threads/Messages/ThreadMessageResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Messages;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{id: string, object: string, created_at: int, thread_id: string, role: string, content: array<int, array{type: 'text', text: array{value: string, annotations: array<int, array{type: 'file_citation', text: string, file_citation: array{file_id: string, quote?: string}, start_index: int, end_index: int}|array{type: 'file_path', text: string, file_path: array{file_id: string}, start_index: int, end_index: int}>}}|array{type: string, image_file: array{file_id: string, detail?: string}}|array{type: 'image_url', image_url: array{url: string, detail?: string}}>, assistant_id: ?string, run_id: ?string, attachments: array<int, array{file_id: string, tools: array<int, array{type: string}>}>, metadata: array<string, string>}>
 */
final class ThreadMessageResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{id: string, object: string, created_at: int, thread_id: string, role: string, content: array<int, array{type: 'text', text: array{value: string, annotations: array<int, array{type: 'file_citation', text: string, file_citation: array{file_id: string, quote?: string}, start_index: int, end_index: int}|array{type: 'file_path', text: string, file_path: array{file_id: string}, start_index: int, end_index: int}>}}|array{type: string, image_file: array{file_id: string, detail?: string}}|array{type: 'image_url', image_url: array{url: string, detail?: string}}>, assistant_id: ?string, run_id: ?string, attachments: array<int, array{file_id: string, tools: array<int, array{type: string}>}>, metadata: array<string, string>}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<int, ThreadMessageResponseContentTextObject|ThreadMessageResponseContentImageFileObject|ThreadMessageResponseContentImageUrlObject>  $content
     * @param  array<int, ThreadMessageResponseAttachment>  $attachments
     * @param  array<string, string>  $metadata
     */
    private function __construct(
        public string $id,
        public string $object,
        public int $createdAt,
        public string $threadId,
        public string $role,
        public array $content,
        public ?string $assistantId,
        public ?string $runId,
        public array $attachments,
        public array $metadata,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{id: string, object: string, created_at: int, thread_id: string, role: string, content: array<int, array{type: 'image_url', image_url: array{url: string, detail?: string}}|array{type: 'image_file', image_file: array{file_id: string, detail?: string}}|array{type: 'text', text: array{value: string, annotations: array<int, array{type: 'file_citation', text: string, file_citation: array{file_id: string, quote?: string}, start_index: int, end_index: int}|array{type: 'file_path', text: string, file_path: array{file_id: string}, start_index: int, end_index: int}>}}>, assistant_id: ?string, run_id: ?string, attachments?: array<int, array{file_id: string, tools: array<int, array{type: 'file_search'}|array{type: 'code_interpreter'}>}>, metadata: array<string, string>}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        $content = array_map(
            fn (array $content): ThreadMessageResponseContentTextObject|ThreadMessageResponseContentImageFileObject|ThreadMessageResponseContentImageUrlObject => match ($content['type']) {
                'text'       => ThreadMessageResponseContentTextObject::from($content),
                'image_file' => ThreadMessageResponseContentImageFileObject::from($content),
                'image_url'  => ThreadMessageResponseContentImageUrlObject::from($content),
            },
            $attributes['content'],
        );

        $attachments = array_map(
            fn (array $attachment): ThreadMessageResponseAttachment => ThreadMessageResponseAttachment::from($attachment),
            $attributes['attachments'] ?? []
        );

        return new self(
            $attributes['id'],
            $attributes['object'],
            $attributes['created_at'],
            $attributes['thread_id'],
            $attributes['role'],
            $content,
            $attributes['assistant_id'],
            $attributes['run_id'],
            $attachments,
            $attributes['metadata'],
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'         => $this->id,
            'object'     => $this->object,
            'created_at' => $this->createdAt,
            'thread_id'  => $this->threadId,
            'role'       => $this->role,
            'content'    => array_map(
                fn (ThreadMessageResponseContentImageFileObject|ThreadMessageResponseContentTextObject|ThreadMessageResponseContentImageUrlObject $content): array => $content->toArray(),
                $this->content,
            ),
            'attachments' => array_map(
                fn (ThreadMessageResponseAttachment $attachment): array => $attachment->toArray(),
                $this->attachments
            ),
            'assistant_id' => $this->assistantId,
            'run_id'       => $this->runId,
            'metadata'     => $this->metadata,
        ];
    }
}
PK     S%W]?,‹¡£  £  N  client/src/Responses/Threads/Messages/ThreadMessageResponseContentImageUrl.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Messages;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{url: string, detail?: string}>
 */
final class ThreadMessageResponseContentImageUrl implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{url: string, detail?: string}>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public string $url,
        public ?string $detail,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{url: string, detail?: string}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['url'],
            $attributes['detail'] ?? null,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return array_filter([
            'url'    => $this->url,
            'detail' => $this->detail,
        ], fn (?string $value): bool => $value !== null);
    }
}
PK     S%W]á#b„@  @  U  client/src/Responses/Threads/Messages/ThreadMessageResponseContentImageFileObject.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Messages;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{type: string, image_file: array{file_id: string, detail?: string}}>
 */
final class ThreadMessageResponseContentImageFileObject implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{type: string, image_file: array{file_id: string, detail?: string}}>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public string $type,
        public ThreadMessageResponseContentImageFile $imageFile,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{type: string, image_file: array{file_id: string, detail?: string}}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['type'],
            ThreadMessageResponseContentImageFile::from($attributes['image_file']),
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type'       => $this->type,
            'image_file' => $this->imageFile->toArray(),
        ];
    }
}
PK     S%W]‹-»!S  S  b  client/src/Responses/Threads/Messages/ThreadMessageResponseContentTextAnnotationFilePathObject.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Threads\Messages;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{type: 'file_path', text: string, file_path: array{file_id: string}, start_index: int, end_index: int}>
 */
final class ThreadMessageResponseContentTextAnnotationFilePathObject implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{type: 'file_path', text: string, file_path: array{file_id: string}, start_index: int, end_index: int}>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'file_path'  $type
     */
    private function __construct(
        public string $type,
        public string $text,
        public int $startIndex,
        public int $endIndex,
        public ThreadMessageResponseContentTextAnnotationFilePath $filePath,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{type: 'file_path', text: string, file_path: array{file_id: string}, start_index: int, end_index: int}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['type'],
            $attributes['text'],
            $attributes['start_index'],
            $attributes['end_index'],
            ThreadMessageResponseContentTextAnnotationFilePath::from($attributes['file_path']),
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type'        => $this->type,
            'text'        => $this->text,
            'start_index' => $this->startIndex,
            'end_index'   => $this->endIndex,
            'file_path'   => $this->filePath->toArray(),
        ];
    }
}
PK     S%W]Þþs·/  /  8  client/src/Responses/Batches/BatchResponseErrorsData.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Batches;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;

/**
 * @implements ResponseContract<array{code: string, message: string, param: ?string, line: ?int}>
 */
final class BatchResponseErrorsData implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{code: string, message: string, param: ?string, line: ?int}>
     */
    use ArrayAccessible;

    private function __construct(
        public string $code,
        public string $message,
        public ?string $param,
        public ?int $line,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{code: string, message: string, param: ?string, line: ?int}  $attributes
     */
    public static function from(array $attributes): self
    {

        return new self(
            $attributes['code'],
            $attributes['message'],
            $attributes['param'],
            $attributes['line'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'code'    => $this->code,
            'message' => $this->message,
            'param'   => $this->param,
            'line'    => $this->line,
        ];
    }
}
PK     S%W]"˜«}  }  2  client/src/Responses/Batches/BatchListResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Batches;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{object: string, data: array<int, array{id: string, object: string, endpoint: string, errors: ?array{object: string, data: array<array-key, array{code: string, message: string, param: ?string, line: ?int}>}, input_file_id: string, completion_window: string, status: string, output_file_id: ?string, error_file_id: ?string, created_at: int, in_progress_at: ?int, expires_at: ?int, finalizing_at: ?int, completed_at: ?int, failed_at: ?int, expired_at: ?int, cancelling_at: ?int, cancelled_at: ?int, request_counts: ?array{total: int, completed: int, failed: int}, metadata: ?array<string, string>}>, first_id: ?string, last_id: ?string, has_more: bool}>
 */
final class BatchListResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{object: string, data: array<int, array{id: string, object: string, endpoint: string, errors: ?array{object: string, data: array<array-key, array{code: string, message: string, param: ?string, line: ?int}>}, input_file_id: string, completion_window: string, status: string, output_file_id: ?string, error_file_id: ?string, created_at: int, in_progress_at: ?int, expires_at: ?int, finalizing_at: ?int, completed_at: ?int, failed_at: ?int, expired_at: ?int, cancelling_at: ?int, cancelled_at: ?int, request_counts: ?array{total: int, completed: int, failed: int}, metadata: ?array<string, string>}>, first_id: ?string, last_id: ?string, has_more: bool}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<int, BatchResponse>  $data
     */
    private function __construct(
        public readonly string $object,
        public readonly array $data,
        public readonly ?string $firstId,
        public readonly ?string $lastId,
        public readonly bool $hasMore,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{object: string, data: array<int, array{id: string, object: string, endpoint: string, errors?: array{object: string, data: array<array-key, array{code: string, message: string, param: ?string, line: ?int}>}, input_file_id: string, completion_window: string, status: string, output_file_id: ?string, error_file_id: ?string, created_at: int, in_progress_at: ?int, expires_at: ?int, finalizing_at: ?int, completed_at: ?int, failed_at: ?int, expired_at: ?int, cancelling_at: ?int, cancelled_at: ?int, request_counts?: array{total: int, completed: int, failed: int}, metadata: ?array<string, string>}>, first_id: ?string, last_id: ?string, has_more: bool}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        $data = array_map(fn (array $result): BatchResponse => BatchResponse::from(
            $result,
            $meta,
        ), $attributes['data']);

        return new self(
            $attributes['object'],
            $data,
            $attributes['first_id'],
            $attributes['last_id'],
            $attributes['has_more'],
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'object' => $this->object,
            'data'   => array_map(
                static fn (BatchResponse $response): array => $response->toArray(),
                $this->data,
            ),
            'first_id' => $this->firstId,
            'last_id'  => $this->lastId,
            'has_more' => $this->hasMore,
        ];
    }
}
PK     S%W]3§AÑÈ  È  .  client/src/Responses/Batches/BatchResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Batches;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{id: string, object: string, endpoint: string, errors: ?array{object: string, data: array<array-key, array{code: string, message: string, param: ?string, line: ?int}>}, input_file_id: string, completion_window: string, status: string, output_file_id: ?string, error_file_id: ?string, created_at: int, in_progress_at: ?int, expires_at: ?int, finalizing_at: ?int, completed_at: ?int, failed_at: ?int, expired_at: ?int, cancelling_at: ?int, cancelled_at: ?int, request_counts: ?array{total: int, completed: int, failed: int}, metadata: ?array<string, string>}>
 */
final class BatchResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{id: string, object: string, endpoint: string, errors: ?array{object: string, data: array<array-key, array{code: string, message: string, param: ?string, line: ?int}>}, input_file_id: string, completion_window: string, status: string, output_file_id: ?string, error_file_id: ?string, created_at: int, in_progress_at: ?int, expires_at: ?int, finalizing_at: ?int, completed_at: ?int, failed_at: ?int, expired_at: ?int, cancelling_at: ?int, cancelled_at: ?int, request_counts: ?array{total: int, completed: int, failed: int}, metadata: ?array<string, string>}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<string, string>|null  $metadata
     */
    private function __construct(
        public string $id,
        public string $object,
        public string $endpoint,
        public ?BatchResponseErrors $errors,
        public string $inputFileId,
        public string $completionWindow,
        public string $status,
        public ?string $outputFileId,
        public ?string $errorFileId,
        public int $createdAt,
        public ?int $inProgressAt,
        public ?int $expiresAt,
        public ?int $finalizingAt,
        public ?int $completedAt,
        public ?int $failedAt,
        public ?int $expiredAt,
        public ?int $cancellingAt,
        public ?int $cancelledAt,
        public ?BatchResponseRequestCounts $requestCounts,
        public ?array $metadata,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{id: string, object: string, endpoint: string, errors?: array{object: string, data: array<array-key, array{code: string, message: string, param: ?string, line: ?int}>}, input_file_id: string, completion_window: string, status: string, output_file_id: ?string, error_file_id: ?string, created_at: int, in_progress_at: ?int, expires_at: ?int, finalizing_at: ?int, completed_at: ?int, failed_at: ?int, expired_at: ?int, cancelling_at: ?int, cancelled_at: ?int, request_counts?: array{total: int, completed: int, failed: int}, metadata: ?array<string, string>}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            $attributes['id'],
            $attributes['object'],
            $attributes['endpoint'],
            isset($attributes['errors']) ? BatchResponseErrors::from($attributes['errors']) : null,
            $attributes['input_file_id'],
            $attributes['completion_window'],
            $attributes['status'],
            $attributes['output_file_id'],
            $attributes['error_file_id'],
            $attributes['created_at'],
            $attributes['in_progress_at'],
            $attributes['expires_at'],
            $attributes['finalizing_at'],
            $attributes['completed_at'],
            $attributes['failed_at'],
            $attributes['expired_at'],
            $attributes['cancelling_at'],
            $attributes['cancelled_at'],
            isset($attributes['request_counts']) ? BatchResponseRequestCounts::from($attributes['request_counts']) : null,
            $attributes['metadata'],
            $meta
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'                => $this->id,
            'object'            => $this->object,
            'endpoint'          => $this->endpoint,
            'errors'            => $this->errors?->toArray(),
            'input_file_id'     => $this->inputFileId,
            'completion_window' => $this->completionWindow,
            'status'            => $this->status,
            'output_file_id'    => $this->outputFileId,
            'error_file_id'     => $this->errorFileId,
            'created_at'        => $this->createdAt,
            'in_progress_at'    => $this->inProgressAt,
            'expires_at'        => $this->expiresAt,
            'finalizing_at'     => $this->finalizingAt,
            'completed_at'      => $this->completedAt,
            'failed_at'         => $this->failedAt,
            'expired_at'        => $this->expiredAt,
            'cancelling_at'     => $this->cancellingAt,
            'cancelled_at'      => $this->cancelledAt,
            'request_counts'    => $this->requestCounts?->toArray(),
            'metadata'          => $this->metadata,
        ];
    }
}
PK     S%W]ECh&  &  4  client/src/Responses/Batches/BatchResponseErrors.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Batches;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;

/**
 * @implements ResponseContract<array{object: string, data: array<array-key, array{code: string, message: string, param: ?string, line: ?int}>}>
 */
final class BatchResponseErrors implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{object: string, data: array<array-key, array{code: string, message: string, param: ?string, line: ?int}>}>
     */
    use ArrayAccessible;

    /**
     * @param  array<array-key, BatchResponseErrorsData>  $data
     */
    private function __construct(
        public string $object,
        public array $data,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{object: string, data: array<array-key, array{code: string, message: string, param: ?string, line: ?int}>}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['object'],
            array_map(
                fn (array $data): \OpenAI\Responses\Batches\BatchResponseErrorsData => BatchResponseErrorsData::from($data),
                $attributes['data']
            )
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'object' => $this->object,
            'data'   => array_map(fn (BatchResponseErrorsData $data): array => $data->toArray(), $this->data),
        ];
    }
}
PK     S%W]Nø 9¢  ¢  ;  client/src/Responses/Batches/BatchResponseRequestCounts.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Batches;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;

/**
 * @implements ResponseContract<array{total: int, completed: int, failed: int}>
 */
final class BatchResponseRequestCounts implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{total: int, completed: int, failed: int}>
     */
    use ArrayAccessible;

    private function __construct(
        public int $total,
        public int $completed,
        public int $failed,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{total: int, completed: int, failed: int}  $attributes
     */
    public static function from(array $attributes): self
    {

        return new self(
            $attributes['total'],
            $attributes['completed'],
            $attributes['failed'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'total'     => $this->total,
            'completed' => $this->completed,
            'failed'    => $this->failed,
        ];
    }
}
PK     S%W]Æ'ÝŽ£  £  ,  client/src/Responses/Models/ListResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Models;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{object: string, data: array<int, array{id: string, object: string, created: ?int, created_at?: ?int, owned_by: ?string}>}>
 */
final class ListResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{object: string, data: array<int, array{id: string, object: string, created: ?int, created_at?: ?int, owned_by: ?string}>}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<int, RetrieveResponse>  $data
     */
    private function __construct(
        public readonly string $object,
        public readonly array $data,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  array{object: string, data: array<int, array{id: string, object: string, created: ?int, created_at?: ?int, owned_by: ?string}>}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        $data = array_map(fn (array $result): RetrieveResponse => RetrieveResponse::from(
            $result,
            $meta,
        ), $attributes['data']);

        return new self(
            $attributes['object'],
            $data,
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'object' => $this->object,
            'data'   => array_map(
                static fn (RetrieveResponse $response): array => $response->toArray(),
                $this->data,
            ),
        ];
    }
}
PK     S%W]´;‘•    .  client/src/Responses/Models/DeleteResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Models;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{id: string, object: string, deleted: bool}>
 */
final class DeleteResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{id: string, object: string, deleted: bool}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly string $id,
        public readonly string $object,
        public readonly bool $deleted,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{id: string, object: string, deleted: bool}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            $attributes['id'],
            $attributes['object'],
            $attributes['deleted'],
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'      => $this->id,
            'object'  => $this->object,
            'deleted' => $this->deleted,
        ];
    }
}
PK     S%W]\eGîý  ý  0  client/src/Responses/Models/RetrieveResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Models;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{id: string, object: string, created: ?int, created_at?: ?int, owned_by: ?string}>
 */
final class RetrieveResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{id: string, object: string, created: ?int, owned_by: ?string}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly string $id,
        public readonly string $object,
        public readonly ?int $created,
        public readonly ?string $ownedBy,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  array{id: string, object: string, created: ?int, created_at?: ?int, owned_by: ?string}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            id: $attributes['id'],
            object: $attributes['object'],
            created: $attributes['created'] ?? $attributes['created_at'] ?? null,
            ownedBy: $attributes['owned_by'] ?? null,
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'       => $this->id,
            'object'   => $this->object,
            'created'  => $this->created,
            'owned_by' => $this->ownedBy,
        ];
    }
}
PK     S%W]l@ä   ä   4  client/src/Responses/Concerns/HasMetaInformation.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Concerns;

use OpenAI\Responses\Meta\MetaInformation;

trait HasMetaInformation
{
    public function meta(): MetaInformation
    {
        return $this->meta;
    }
}
PK     S%W]ºÒ?5„  „  1  client/src/Responses/Concerns/ArrayAccessible.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Concerns;

use BadMethodCallException;

/**
 * @template TArray of array
 *
 * @mixin Response<TArray>
 */
trait ArrayAccessible
{
    /**
     * {@inheritDoc}
     */
    public function offsetExists(mixed $offset): bool
    {
        return array_key_exists($offset, $this->toArray());
    }

    /**
     * {@inheritDoc}
     */
    public function offsetGet(mixed $offset): mixed
    {
        return $this->toArray()[$offset]; // @phpstan-ignore-line
    }

    /**
     * {@inheritDoc}
     */
    public function offsetSet(mixed $offset, mixed $value): never
    {
        throw new BadMethodCallException('Cannot set response attributes.');
    }

    /**
     * {@inheritDoc}
     */
    public function offsetUnset(mixed $offset): never
    {
        throw new BadMethodCallException('Cannot unset response attributes.');
    }
}
PK     S%W]¡æi:Ê	  Ê	  -  client/src/Responses/Edits/CreateResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Edits;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{object: string, created: int, choices: array<int, array{text: string, index: int}>, usage: array{prompt_tokens: int, completion_tokens: int, total_tokens: int}}>
 */
final class CreateResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{id: string, object: string, created: int, model: string, choices: array<int, array{text: string, index: int, logprobs: int|null, finish_reason: string}>, usage: array{prompt_tokens: int, completion_tokens: int, total_tokens: int}}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<int, CreateResponseChoice>  $choices
     */
    private function __construct(
        public readonly string $object,
        public readonly int $created,
        public readonly array $choices,
        public readonly CreateResponseUsage $usage,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{object: string, created: int, choices: array<int, array{text: string, index: int}>, usage: array{prompt_tokens: int, completion_tokens: int, total_tokens: int}}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        $choices = array_map(fn (array $result): CreateResponseChoice => CreateResponseChoice::from(
            $result
        ), $attributes['choices']);

        return new self(
            $attributes['object'],
            $attributes['created'],
            $choices,
            CreateResponseUsage::from($attributes['usage']),
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'object'  => $this->object,
            'created' => $this->created,
            'choices' => array_map(
                static fn (CreateResponseChoice $result): array => $result->toArray(),
                $this->choices,
            ),
            'usage' => $this->usage->toArray(),
        ];
    }
}
PK     S%W]0(Ö­  ­  3  client/src/Responses/Edits/CreateResponseChoice.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Edits;

final class CreateResponseChoice
{
    private function __construct(
        public readonly string $text,
        public readonly int $index,
    ) {}

    /**
     * @param  array{text: string, index: int}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['text'],
            $attributes['index'],
        );
    }

    /**
     * @return array{text: string, index: int}
     */
    public function toArray(): array
    {
        return [
            'text'  => $this->text,
            'index' => $this->index,
        ];
    }
}
PK     S%W]j8@Ð  Ð  2  client/src/Responses/Edits/CreateResponseUsage.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Edits;

final class CreateResponseUsage
{
    private function __construct(
        public readonly int $promptTokens,
        public readonly int $completionTokens,
        public readonly int $totalTokens,
    ) {}

    /**
     * @param  array{prompt_tokens: int, completion_tokens: int, total_tokens: int}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['prompt_tokens'],
            $attributes['completion_tokens'],
            $attributes['total_tokens'],
        );
    }

    /**
     * @return array{prompt_tokens: int, completion_tokens: int, total_tokens: int}
     */
    public function toArray(): array
    {
        return [
            'prompt_tokens'     => $this->promptTokens,
            'completion_tokens' => $this->completionTokens,
            'total_tokens'      => $this->totalTokens,
        ];
    }
}
PK     S%W]t}=ž  ž  A  client/src/Responses/Completions/CreateResponseChoiceLogprobs.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Completions;

final class CreateResponseChoiceLogprobs
{
    /**
     * @param  array<int, string>  $tokens
     * @param  array<int, float>  $tokenLogprobs
     * @param  array<int, string>|null  $topLogprobs
     * @param  array<int, int>  $textOffset
     */
    private function __construct(
        public readonly array $tokens,
        public readonly array $tokenLogprobs,
        public readonly ?array $topLogprobs,
        public readonly array $textOffset,
    ) {}

    /**
     * @param  array{tokens: array<int, string>, token_logprobs: array<int, float>, top_logprobs: array<int, string>|null, text_offset: array<int, int>}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['tokens'],
            $attributes['token_logprobs'],
            $attributes['top_logprobs'],
            $attributes['text_offset'],
        );
    }

    /**
     * @return array{tokens: array<int, string>, token_logprobs: array<int, float>, top_logprobs: array<int, string>|null, text_offset: array<int, int>}
     */
    public function toArray(): array
    {
        return [
            'tokens'         => $this->tokens,
            'token_logprobs' => $this->tokenLogprobs,
            'top_logprobs'   => $this->topLogprobs,
            'text_offset'    => $this->textOffset,
        ];
    }
}
PK     S%W]×;˜
  ˜
  ;  client/src/Responses/Completions/CreateStreamedResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Completions;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\FakeableForStreamedResponse;

/**
 * @implements ResponseContract<array{id: string, object: string, created: int, model: string, choices: array<int, array{text: string, index: int, logprobs: array{tokens: array<int, string>, token_logprobs: array<int, float>, top_logprobs: array<int, string>|null, text_offset: array<int, int>}|null, finish_reason: string|null}>}>
 */
final class CreateStreamedResponse implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{id: string, object: string, created: int, model: string, choices: array<int, array{text: string, index: int, logprobs: array{tokens: array<int, string>, token_logprobs: array<int, float>, top_logprobs: array<int, string>|null, text_offset: array<int, int>}|null, finish_reason: string|null}>}>
     */
    use ArrayAccessible;

    use FakeableForStreamedResponse;

    /**
     * @param  array<int, CreateResponseChoice>  $choices
     */
    private function __construct(
        public readonly string $id,
        public readonly string $object,
        public readonly int $created,
        public readonly string $model,
        public readonly array $choices,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{id: string, object: string, created: int, model: string, choices: array<int, array{text: string, index: int, logprobs: array{tokens: array<int, string>, token_logprobs: array<int, float>, top_logprobs: array<int, string>|null, text_offset: array<int, int>}|null, finish_reason: string}>, usage?: array{prompt_tokens: int, completion_tokens: int|null, total_tokens: int}}  $attributes
     */
    public static function from(array $attributes): self
    {
        $choices = array_map(fn (array $result): CreateResponseChoice => CreateResponseChoice::from(
            $result
        ), $attributes['choices']);

        return new self(
            $attributes['id'],
            $attributes['object'],
            $attributes['created'],
            $attributes['model'],
            $choices,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'      => $this->id,
            'object'  => $this->object,
            'created' => $this->created,
            'model'   => $this->model,
            'choices' => array_map(
                static fn (CreateResponseChoice $result): array => $result->toArray(),
                $this->choices,
            ),
        ];
    }
}
PK     S%W]ÊVÝ6Þ  Þ  3  client/src/Responses/Completions/CreateResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Completions;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{id: string, object: string, created: int, model: string, choices: array<int, array{text: string, index: int, logprobs: array{tokens: array<int, string>, token_logprobs: array<int, float>, top_logprobs: array<int, string>|null, text_offset: array<int, int>}|null, finish_reason: string|null}>, usage: array{prompt_tokens: int, completion_tokens: int|null, total_tokens: int}}>
 */
final class CreateResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{id: string, object: string, created: int, model: string, choices: array<int, array{text: string, index: int, logprobs: array{tokens: array<int, string>, token_logprobs: array<int, float>, top_logprobs: array<int, string>|null, text_offset: array<int, int>}|null, finish_reason: string|null}>, usage: array{prompt_tokens: int, completion_tokens: int|null, total_tokens: int}}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<int, CreateResponseChoice>  $choices
     */
    private function __construct(
        public readonly string $id,
        public readonly string $object,
        public readonly int $created,
        public readonly string $model,
        public readonly array $choices,
        public readonly CreateResponseUsage $usage,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{id: string, object: string, created: int, model: string, choices: array<int, array{text: string, index: int, logprobs: array{tokens: array<int, string>, token_logprobs: array<int, float>, top_logprobs: array<int, string>|null, text_offset: array<int, int>}|null, finish_reason: string}>, usage: array{prompt_tokens: int, completion_tokens: int|null, total_tokens: int}}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        $choices = array_map(fn (array $result): CreateResponseChoice => CreateResponseChoice::from(
            $result
        ), $attributes['choices']);

        return new self(
            $attributes['id'],
            $attributes['object'],
            $attributes['created'],
            $attributes['model'],
            $choices,
            CreateResponseUsage::from($attributes['usage']),
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'      => $this->id,
            'object'  => $this->object,
            'created' => $this->created,
            'model'   => $this->model,
            'choices' => array_map(
                static fn (CreateResponseChoice $result): array => $result->toArray(),
                $this->choices,
            ),
            'usage' => $this->usage->toArray(),
        ];
    }
}
PK     S%W]˜–S
  
  9  client/src/Responses/Completions/CreateResponseChoice.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Completions;

final class CreateResponseChoice
{
    private function __construct(
        public readonly string $text,
        public readonly int $index,
        public readonly ?CreateResponseChoiceLogprobs $logprobs,
        public readonly ?string $finishReason,
    ) {}

    /**
     * @param  array{text: string, index: int, logprobs: array{tokens: array<int, string>, token_logprobs: array<int, float>, top_logprobs: array<int, string>|null, text_offset: array<int, int>}|null, finish_reason: string|null}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['text'],
            $attributes['index'],
            isset($attributes['logprobs'])
                ? CreateResponseChoiceLogprobs::from($attributes['logprobs'])
                : null,
            $attributes['finish_reason'],
        );
    }

    /**
     * @return array{text: string, index: int, logprobs: array{tokens: array<int, string>, token_logprobs: array<int, float>, top_logprobs: array<int, string>|null, text_offset: array<int, int>}|null, finish_reason: string|null}
     */
    public function toArray(): array
    {
        return [
            'text'          => $this->text,
            'index'         => $this->index,
            'logprobs'      => $this->logprobs instanceof CreateResponseChoiceLogprobs ? $this->logprobs->toArray() : null,
            'finish_reason' => $this->finishReason,
        ];
    }
}
PK     S%W]íù½¡é  é  8  client/src/Responses/Completions/CreateResponseUsage.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Completions;

final class CreateResponseUsage
{
    private function __construct(
        public readonly int $promptTokens,
        public readonly ?int $completionTokens,
        public readonly int $totalTokens,
    ) {}

    /**
     * @param  array{prompt_tokens: int, completion_tokens: int|null, total_tokens: int}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['prompt_tokens'],
            $attributes['completion_tokens'] ?? null,
            $attributes['total_tokens'],
        );
    }

    /**
     * @return array{prompt_tokens: int, completion_tokens: int|null, total_tokens: int}
     */
    public function toArray(): array
    {
        return [
            'prompt_tokens'     => $this->promptTokens,
            'completion_tokens' => $this->completionTokens,
            'total_tokens'      => $this->totalTokens,
        ];
    }
}
PK     S%W]u—“~  ~  8  client/src/Responses/Containers/Objects/ExpiresAfter.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Containers\Objects;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type ExpiresAfterType array{anchor: 'last_active_at', minutes: int}
 *
 * @implements ResponseContract<ExpiresAfterType>
 */
final class ExpiresAfter implements ResponseContract
{
    /**
     * @use ArrayAccessible<ExpiresAfterType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'last_active_at'  $anchor
     */
    private function __construct(
        public readonly string $anchor,
        public readonly int $minutes,
    ) {}

    /**
     * @param  ExpiresAfterType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            anchor: $attributes['anchor'],
            minutes: $attributes['minutes'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'anchor'  => $this->anchor,
            'minutes' => $this->minutes,
        ];
    }
}
PK     S%W]A˜lJp	  p	  5  client/src/Responses/Containers/RetrieveContainer.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Containers;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Containers\Objects\ExpiresAfter;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-import-type ExpiresAfterType from ExpiresAfter
 *
 * @phpstan-type RetrieveContainerType array{id: string, object: 'container', created_at: int, status: string, expires_after: ExpiresAfterType, last_active_at: int, name: string}
 *
 * @implements ResponseContract<RetrieveContainerType>
 */
final class RetrieveContainer implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<RetrieveContainerType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  'container'  $object
     */
    private function __construct(
        public readonly string $id,
        public readonly string $object,
        public readonly int $createdAt,
        public readonly string $status,
        public readonly ExpiresAfter $expiresAfter,
        public readonly int $lastActiveAt,
        public readonly string $name,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  RetrieveContainerType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            id: $attributes['id'],
            object: $attributes['object'],
            createdAt: $attributes['created_at'],
            status: $attributes['status'],
            expiresAfter: ExpiresAfter::from($attributes['expires_after']),
            lastActiveAt: $attributes['last_active_at'],
            name: $attributes['name'],
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'             => $this->id,
            'object'         => $this->object,
            'created_at'     => $this->createdAt,
            'status'         => $this->status,
            'expires_after'  => $this->expiresAfter->toArray(),
            'last_active_at' => $this->lastActiveAt,
            'name'           => $this->name,
        ];
    }
}
PK     S%W]¢†8°ò  ò  2  client/src/Responses/Containers/ListContainers.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Containers;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-import-type RetrieveContainerType from RetrieveContainer
 *
 * @phpstan-type ListContainersType array{object: 'list', data: RetrieveContainerType[], first_id: string|null, last_id: string|null, has_more: bool}
 *
 * @implements ResponseContract<ListContainersType>
 */
final class ListContainers implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<ListContainersType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  'list'  $object
     * @param  RetrieveContainer[]  $data
     */
    private function __construct(
        public readonly string $object,
        public readonly array $data,
        public readonly ?string $firstId,
        public readonly ?string $lastId,
        public readonly bool $hasMore,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  ListContainersType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            object: $attributes['object'],
            data: array_map(
                fn (array $container): RetrieveContainer => RetrieveContainer::from($container, $meta),
                $attributes['data']
            ),
            firstId: $attributes['first_id'] ?? null,
            lastId: $attributes['last_id'] ?? null,
            hasMore: $attributes['has_more'],
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'object' => $this->object,
            'data'   => array_map(
                fn (RetrieveContainer $container): array => $container->toArray(),
                $this->data
            ),
            'first_id' => $this->firstId,
            'last_id'  => $this->lastId,
            'has_more' => $this->hasMore,
        ];
    }
}
PK     S%W]È’f	  f	  3  client/src/Responses/Containers/CreateContainer.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Containers;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Containers\Objects\ExpiresAfter;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-import-type ExpiresAfterType from ExpiresAfter
 *
 * @phpstan-type CreateContainerType array{id: string, object: 'container', created_at: int, status: string, expires_after: ExpiresAfterType, last_active_at: int, name: string}
 *
 * @implements ResponseContract<CreateContainerType>
 */
final class CreateContainer implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<CreateContainerType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  'container'  $object
     */
    private function __construct(
        public readonly string $id,
        public readonly string $object,
        public readonly int $createdAt,
        public readonly string $status,
        public readonly ExpiresAfter $expiresAfter,
        public readonly int $lastActiveAt,
        public readonly string $name,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  CreateContainerType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            id: $attributes['id'],
            object: $attributes['object'],
            createdAt: $attributes['created_at'],
            status: $attributes['status'],
            expiresAfter: ExpiresAfter::from($attributes['expires_after']),
            lastActiveAt: $attributes['last_active_at'],
            name: $attributes['name'],
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'             => $this->id,
            'object'         => $this->object,
            'created_at'     => $this->createdAt,
            'status'         => $this->status,
            'expires_after'  => $this->expiresAfter->toArray(),
            'last_active_at' => $this->lastActiveAt,
            'name'           => $this->name,
        ];
    }
}
PK     S%W]kîñ  ñ  3  client/src/Responses/Containers/DeleteContainer.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Containers;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type DeleteContainerType array{id: string, object: string, deleted: bool}
 *
 * @implements ResponseContract<DeleteContainerType>
 */
final class DeleteContainer implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<DeleteContainerType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly string $id,
        public readonly string $object,
        public readonly bool $deleted,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  DeleteContainerType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            id: $attributes['id'],
            object: $attributes['object'],
            deleted: $attributes['deleted'],
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'      => $this->id,
            'object'  => $this->object,
            'deleted' => $this->deleted,
        ];
    }
}
PK     S%W]±u‹²Ö  Ö  :  client/src/Responses/Chat/CreateResponseChoiceLogprobs.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Chat;

final class CreateResponseChoiceLogprobs
{
    /**
     * @param  ?array<int, CreateResponseChoiceLogprobsContent>  $content
     */
    private function __construct(
        public readonly ?array $content,
    ) {}

    /**
     * @param  array{content: ?array<int, array{token: string, logprob: float, bytes: ?array<int, int>}>}  $attributes
     */
    public static function from(array $attributes): self
    {
        $content = null;
        if (isset($attributes['content'])) {
            $content = array_map(fn (array $result): CreateResponseChoiceLogprobsContent => CreateResponseChoiceLogprobsContent::from(
                $result
            ), $attributes['content']);
        }

        return new self(
            $content,
        );
    }

    /**
     * @return array{content: ?array<int, array{token: string, logprob: float, bytes: ?array<int, int>}>}
     */
    public function toArray(): array
    {
        return [
            'content' => $this->content ? array_map(
                static fn (CreateResponseChoiceLogprobsContent $result): array => $result->toArray(),
                $this->content,
            ) : null,
        ];
    }
}
PK     S%W]Li¡¸Õ  Õ  4  client/src/Responses/Chat/CreateResponseToolCall.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Chat;

final class CreateResponseToolCall
{
    private function __construct(
        public readonly string $id,
        public readonly string $type,
        public readonly CreateResponseToolCallFunction $function,
    ) {}

    /**
     * @param  array{id: string, type: string, function: array{name: string, arguments: string}}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['id'],
            $attributes['type'],
            CreateResponseToolCallFunction::from($attributes['function']),
        );
    }

    /**
     * @return array{id: string, type: string, function: array{name: string, arguments: string}}
     */
    public function toArray(): array
    {
        return [
            'id'       => $this->id,
            'type'     => $this->type,
            'function' => $this->function->toArray(),
        ];
    }
}
PK     S%W]–B#4ˆ  ˆ  H  client/src/Responses/Chat/CreateResponseUsageCompletionTokensDetails.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Chat;

final class CreateResponseUsageCompletionTokensDetails
{
    private function __construct(
        public readonly ?int $audioTokens,
        public readonly ?int $reasoningTokens,
        public readonly ?int $acceptedPredictionTokens,
        public readonly ?int $rejectedPredictionTokens
    ) {}

    /**
     * @param  array{audio_tokens?:int|null, reasoning_tokens?:int|null, accepted_prediction_tokens?:int|null, rejected_prediction_tokens?:int|null}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['audio_tokens'] ?? null,
            $attributes['reasoning_tokens'] ?? null,
            $attributes['accepted_prediction_tokens'] ?? null,
            $attributes['rejected_prediction_tokens'] ?? null,
        );
    }

    /**
     * @return array{audio_tokens?:int, reasoning_tokens?:int, accepted_prediction_tokens?:int, rejected_prediction_tokens?:int}
     */
    public function toArray(): array
    {
        $result = [];

        if (! is_null($this->reasoningTokens)) {
            $result['reasoning_tokens'] = $this->reasoningTokens;
        }

        if (! is_null($this->acceptedPredictionTokens)) {
            $result['accepted_prediction_tokens'] = $this->acceptedPredictionTokens;
        }

        if (! is_null($this->rejectedPredictionTokens)) {
            $result['rejected_prediction_tokens'] = $this->rejectedPredictionTokens;
        }

        if (! is_null($this->audioTokens)) {
            $result['audio_tokens'] = $this->audioTokens;
        }

        return $result;
    }
}
PK     S%W]In’3      A  client/src/Responses/Chat/CreateResponseChoiceLogprobsContent.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Chat;

final class CreateResponseChoiceLogprobsContent
{
    /**
     * @param  ?array<int, int>  $bytes
     */
    private function __construct(
        public readonly string $token,
        public readonly float $logprob,
        public readonly ?array $bytes,
    ) {}

    /**
     * @param array{
     *     token: string,
     *     logprob: float,
     *     bytes: ?array<int, int>
     * } $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['token'],
            $attributes['logprob'],
            $attributes['bytes'],
        );
    }

    /**
     * @return array{
     *     token: string,
     *     logprob: float,
     *     bytes: ?array<int, int>
     * }
     */
    public function toArray(): array
    {
        return [
            'token'   => $this->token,
            'logprob' => $this->logprob,
            'bytes'   => $this->bytes,
        ];
    }
}
PK     S%W]ë:Eø  ø  I  client/src/Responses/Chat/CreateResponseChoiceAnnotationsUrlCitations.phpnu „[µü¤        <?php

namespace OpenAI\Responses\Chat;

final class CreateResponseChoiceAnnotationsUrlCitations
{
    public function __construct(
        public readonly int $endIndex,
        public readonly int $startIndex,
        public readonly string $title,
        public readonly string $url,
    ) {}

    /**
     * @param  array{end_index: int, start_index: int, title: string, url: string}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['end_index'],
            $attributes['start_index'],
            $attributes['title'],
            $attributes['url'],
        );
    }

    /**
     * @return array{end_index: int, start_index: int, title: string, url: string}
     */
    public function toArray(): array
    {
        return [
            'end_index'   => $this->endIndex,
            'start_index' => $this->startIndex,
            'title'       => $this->title,
            'url'         => $this->url,
        ];
    }
}
PK     S%W]²*\º  º  4  client/src/Responses/Chat/CreateStreamedResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Chat;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\FakeableForStreamedResponse;

/**
 * @implements ResponseContract<array{id?: string, object: string, created: int, model: string, choices: array<int, array{index: int, delta: array{role?: string, content?: string}|array{role?: string, content: null, function_call: array{name?: string, arguments?: string}}, finish_reason: string|null}>, usage?: array{prompt_tokens: int, completion_tokens: int|null, total_tokens: int}}>
 */
final class CreateStreamedResponse implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{id: string, object: string, created: int, model: string, choices: array<int, array{index: int, delta: array{role?: string, content?: string}|array{role?: string, content: null, function_call: array{name?: string, arguments?: string}}, finish_reason: string|null}>, usage?: array{prompt_tokens: int, completion_tokens: int|null, total_tokens: int}}>
     */
    use ArrayAccessible;

    use FakeableForStreamedResponse;

    /**
     * @param  array<int, CreateStreamedResponseChoice>  $choices
     */
    private function __construct(
        public readonly ?string $id,
        public readonly string $object,
        public readonly int $created,
        public readonly string $model,
        public readonly array $choices,
        public readonly ?CreateResponseUsage $usage,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{id?: string, object: string, created: int, model: string, choices: array<int, array{index: int, delta: array{role?: string, content?: string}, finish_reason: string|null}>, usage?: array{prompt_tokens: int, completion_tokens: int|null, total_tokens: int}}  $attributes
     */
    public static function from(array $attributes): self
    {
        $choices = array_map(fn (array $result): CreateStreamedResponseChoice => CreateStreamedResponseChoice::from(
            $result
        ), $attributes['choices']);

        return new self(
            $attributes['id'] ?? null,
            $attributes['object'],
            $attributes['created'],
            $attributes['model'],
            $choices,
            isset($attributes['usage']) ? CreateResponseUsage::from($attributes['usage']) : null,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return array_filter([
            'id'      => $this->id,
            'object'  => $this->object,
            'created' => $this->created,
            'model'   => $this->model,
            'choices' => array_map(
                static fn (CreateStreamedResponseChoice $result): array => $result->toArray(),
                $this->choices,
            ),
            'usage' => $this->usage?->toArray(),
        ], fn (mixed $value): bool => ! is_null($value));
    }
}
PK     S%W]ä1Ù	Û  Û  <  client/src/Responses/Chat/CreateResponseToolCallFunction.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Chat;

final class CreateResponseToolCallFunction
{
    private function __construct(
        public readonly string $name,
        public readonly string $arguments,
    ) {}

    /**
     * @param  array{name: string, arguments: string}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['name'],
            $attributes['arguments'],
        );
    }

    /**
     * @return array{name: string, arguments: string}
     */
    public function toArray(): array
    {
        return [
            'name'      => $this->name,
            'arguments' => $this->arguments,
        ];
    }
}
PK     S%W]lÐ‰î  î  8  client/src/Responses/Chat/CreateResponseFunctionCall.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Chat;

/**
 * @deprecated
 */
final class CreateResponseFunctionCall
{
    private function __construct(
        public readonly string $name,
        public readonly string $arguments,
    ) {}

    /**
     * @param  array{name: string, arguments: string}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['name'],
            $attributes['arguments'],
        );
    }

    /**
     * @return array{name: string, arguments: string}
     */
    public function toArray(): array
    {
        return [
            'name'      => $this->name,
            'arguments' => $this->arguments,
        ];
    }
}
PK     S%W]ŒŠ:¬‹  ‹  @  client/src/Responses/Chat/CreateStreamedResponseFunctionCall.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Chat;

/**
 * @deprecated
 */
final class CreateStreamedResponseFunctionCall
{
    private function __construct(
        public readonly ?string $name,
        public readonly ?string $arguments,
    ) {}

    /**
     * @param  array{name?: ?string, arguments?: ?string}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['name'] ?? null,
            $attributes['arguments'] ?? null,
        );
    }

    /**
     * @return array{name?: string, arguments?: string}
     */
    public function toArray(): array
    {
        $data = [];

        if (! is_null($this->name)) {
            $data['name'] = $this->name;
        }

        if (! is_null($this->arguments)) {
            $data['arguments'] = $this->arguments;
        }

        return $data;
    }
}
PK     S%W]µT…j†  †  ,  client/src/Responses/Chat/CreateResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Chat;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{id?: string, object: string, created: int, model: string, system_fingerprint?: string, choices: array<int, array{index: int, message: array{role: string, content: string|null, annotations?: array<int, array{type: string, url_citation: array{start_index: int, end_index: int, title: string, url: string}}>, function_call?: array{name: string, arguments: string}, tool_calls?: array<int, array{id: string, type: string, function: array{name: string, arguments: string}}>}, logprobs: ?array{content: ?array<int, array{token: string, logprob: float, bytes: ?array<int, int>}>}, finish_reason: string|null}>, usage?: array{prompt_tokens: int, completion_tokens: int|null, total_tokens: int}}>
 */
final class CreateResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{id: string, object: string, created: int, model: string, system_fingerprint?: string, choices: array<int, array{index: int, message: array{role: string, content: string|null, annotations?: array<int, array{type: string, url_citation: array{start_index: int, end_index: int, title: string, url: string}}>, function_call?: array{name: string, arguments: string}, tool_calls?: array<int, array{id: string, type: string, function: array{name: string, arguments: string}}>}, logprobs: ?array{content: ?array<int, array{token: string, logprob: float, bytes: ?array<int, int>}>}, finish_reason: string|null}>, usage: array{prompt_tokens: int, completion_tokens: int|null, total_tokens: int}}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<int, CreateResponseChoice>  $choices
     */
    private function __construct(
        public readonly ?string $id,
        public readonly string $object,
        public readonly int $created,
        public readonly string $model,
        public readonly ?string $systemFingerprint,
        public readonly array $choices,
        public readonly ?CreateResponseUsage $usage,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{id?: string, object: string, created: int, model: string, system_fingerprint?: string, choices: array<int, array{index: int, message: array{role: string, content: ?string, annotations?: array<int, array{type: string, url_citation: array{start_index: int, end_index: int, title: string, url: string}}>, function_call: ?array{name: string, arguments: string}, tool_calls: ?array<int, array{id: string, type: string, function: array{name: string, arguments: string}}>}, logprobs: ?array{content: ?array<int, array{token: string, logprob: float, bytes: ?array<int, int>}>}, finish_reason: string|null}>, usage?: array{prompt_tokens: int, completion_tokens: int|null, total_tokens: int, prompt_tokens_details?:array{cached_tokens:int}, completion_tokens_details?:array{audio_tokens?:int, reasoning_tokens:int, accepted_prediction_tokens:int, rejected_prediction_tokens:int}}}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        $choices = array_map(fn (array $result): CreateResponseChoice => CreateResponseChoice::from(
            $result
        ), $attributes['choices']);

        return new self(
            $attributes['id'] ?? null,
            $attributes['object'],
            $attributes['created'],
            $attributes['model'],
            $attributes['system_fingerprint'] ?? null,
            $choices,
            isset($attributes['usage']) ? CreateResponseUsage::from($attributes['usage']) : null,
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return array_filter([
            'id'                 => $this->id,
            'object'             => $this->object,
            'created'            => $this->created,
            'model'              => $this->model,
            'system_fingerprint' => $this->systemFingerprint,
            'choices'            => array_map(
                static fn (CreateResponseChoice $result): array => $result->toArray(),
                $this->choices,
            ),
            'usage' => $this->usage?->toArray(),
        ], fn (mixed $value): bool => ! is_null($value));
    }
}
PK     S%W];Ï·ä  ä  9  client/src/Responses/Chat/CreateStreamedResponseDelta.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Chat;

final class CreateStreamedResponseDelta
{
    /**
     * @param  array<int, CreateStreamedResponseToolCall>  $toolCalls
     */
    private function __construct(
        public readonly ?string $role,
        public readonly ?string $content,
        public readonly array $toolCalls,
        public readonly ?CreateStreamedResponseFunctionCall $functionCall,
    ) {}

    /**
     * @param  array{role?: string, content?: string, function_call?: array{name?: ?string, arguments?: ?string}, tool_calls?: array<int, array{id?: string, type?: string, function: array{name?: string, arguments: string}}>}  $attributes
     */
    public static function from(array $attributes): self
    {
        $toolCalls = array_map(fn (array $result): CreateStreamedResponseToolCall => CreateStreamedResponseToolCall::from(
            $result
        ), $attributes['tool_calls'] ?? []);

        return new self(
            $attributes['role'] ?? null,
            $attributes['content'] ?? null,
            $toolCalls,
            isset($attributes['function_call']) ? CreateStreamedResponseFunctionCall::from($attributes['function_call']) : null,
        );
    }

    /**
     * @return array{role?: string, content?: string}|array{role?: string, content: null, function_call: array{name?: string, arguments?: string}}
     */
    public function toArray(): array
    {
        $data = array_filter([
            'role'    => $this->role,
            'content' => $this->content,
        ], fn (?string $value): bool => ! is_null($value));

        if ($this->functionCall instanceof CreateStreamedResponseFunctionCall) {
            $data['content'] = null;
            $data['function_call'] = $this->functionCall->toArray();
        }

        if ($this->toolCalls !== []) {
            $data['tool_calls'] = array_map(fn (CreateStreamedResponseToolCall $toolCall): array => $toolCall->toArray(), $this->toolCalls);
        }

        return $data;
    }
}
PK     S%W]so~  ~  D  client/src/Responses/Chat/CreateResponseUsagePromptTokensDetails.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Chat;

final class CreateResponseUsagePromptTokensDetails
{
    private function __construct(
        public readonly ?int $audioTokens,
        public readonly int $cachedTokens
    ) {}

    /**
     * @param  array{audio_tokens?:int|null, cached_tokens?:int}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['audio_tokens'] ?? null,
            $attributes['cached_tokens'] ?? 0,
        );
    }

    /**
     * @return array{cached_tokens: int, audio_tokens?:int}
     */
    public function toArray(): array
    {
        $result = [
            'cached_tokens' => $this->cachedTokens,
        ];

        if (! is_null($this->audioTokens)) {
            $result['audio_tokens'] = $this->audioTokens;
        }

        return $result;
    }
}
PK     S%W]ŒÙV}  }  :  client/src/Responses/Chat/CreateStreamedResponseChoice.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Chat;

final class CreateStreamedResponseChoice
{
    private function __construct(
        public readonly int $index,
        public readonly CreateStreamedResponseDelta $delta,
        public readonly ?string $finishReason,
    ) {}

    /**
     * @param  array{index: int, delta?: array{role?: string, content?: string}, finish_reason: string|null}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['index'],
            CreateStreamedResponseDelta::from($attributes['delta'] ?? []),
            $attributes['finish_reason'] ?? null,
        );
    }

    /**
     * @return array{index: int, delta: array{role?: string, content?: string}|array{role?: string, content: null, function_call: array{name?: string, arguments?: string}}, finish_reason: string|null}
     */
    public function toArray(): array
    {
        return [
            'index'         => $this->index,
            'delta'         => $this->delta->toArray(),
            'finish_reason' => $this->finishReason,
        ];
    }
}
PK     S%W]ž¨83  3  D  client/src/Responses/Chat/CreateStreamedResponseToolCallFunction.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Chat;

final class CreateStreamedResponseToolCallFunction
{
    private function __construct(
        public readonly ?string $name,
        public readonly string $arguments,
    ) {}

    /**
     * @param  array{name?: string, arguments?: string}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['name'] ?? null,
            $attributes['arguments'] ?? '',
        );
    }

    /**
     * @return array{name?: string, arguments: string}
     */
    public function toArray(): array
    {
        return array_filter([
            'name'      => $this->name,
            'arguments' => $this->arguments,
        ], fn (?string $value): bool => ! is_null($value));
    }
}
PK     S%W]}Qu*    2  client/src/Responses/Chat/CreateResponseChoice.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Chat;

final class CreateResponseChoice
{
    private function __construct(
        public readonly int $index,
        public readonly CreateResponseMessage $message,
        public readonly ?CreateResponseChoiceLogprobs $logprobs,
        public readonly ?string $finishReason,
    ) {}

    /**
     * @param  array{index: int, message: array{role: string, content: ?string, annotations?: array<int, array{type: string, url_citation: array{start_index: int, end_index: int, title: string, url: string}}>, function_call: ?array{name: string, arguments: string}, tool_calls: ?array<int, array{id: string, type: string, function: array{name: string, arguments: string}}>} ,logprobs?: ?array{content: ?array<int, array{token: string, logprob: float, bytes: ?array<int, int>}>}, finish_reason: string|null}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['index'],
            CreateResponseMessage::from($attributes['message']),
            isset($attributes['logprobs']) ? CreateResponseChoiceLogprobs::from($attributes['logprobs']) : null,
            $attributes['finish_reason'] ?? null,
        );
    }

    /**
     * @return array{index: int, message: array{role: string, content: string|null, annotations?: array<int, array{type: string, url_citation: array{start_index: int, end_index: int, title: string, url: string}}>, function_call?: array{name: string, arguments: string}, tool_calls?: array<int, array{id: string, type: string, function: array{name: string, arguments: string}}>}, logprobs: ?array{content: ?array<int, array{token: string, logprob: float, bytes: ?array<int, int>}>}, finish_reason: string|null}
     */
    public function toArray(): array
    {
        return [
            'index'         => $this->index,
            'message'       => $this->message->toArray(),
            'logprobs'      => $this->logprobs?->toArray(),
            'finish_reason' => $this->finishReason,
        ];
    }
}
PK     S%W]¯¬úõ  õ  1  client/src/Responses/Chat/CreateResponseUsage.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Chat;

final class CreateResponseUsage
{
    private function __construct(
        public readonly int $promptTokens,
        public readonly ?int $completionTokens,
        public readonly int $totalTokens,
        public readonly ?CreateResponseUsagePromptTokensDetails $promptTokensDetails,
        public readonly ?CreateResponseUsageCompletionTokensDetails $completionTokensDetails
    ) {}

    /**
     * @param  array{prompt_tokens: int, completion_tokens: int|null, total_tokens: int, prompt_tokens_details?:array{cached_tokens:int}, completion_tokens_details?:array{audio_tokens?:int, reasoning_tokens:int, accepted_prediction_tokens:int, rejected_prediction_tokens:int}}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['prompt_tokens'],
            $attributes['completion_tokens'] ?? null,
            $attributes['total_tokens'],
            isset($attributes['prompt_tokens_details']) ? CreateResponseUsagePromptTokensDetails::from($attributes['prompt_tokens_details']) : null,
            isset($attributes['completion_tokens_details']) ? CreateResponseUsageCompletionTokensDetails::from($attributes['completion_tokens_details']) : null
        );
    }

    /**
     * @return array{prompt_tokens: int, completion_tokens: int|null, total_tokens: int, prompt_tokens_details?:array{cached_tokens:int}}
     */
    public function toArray(): array
    {
        $result = [
            'prompt_tokens'     => $this->promptTokens,
            'completion_tokens' => $this->completionTokens,
            'total_tokens'      => $this->totalTokens,
        ];

        if ($this->promptTokensDetails) {
            $result['prompt_tokens_details'] = $this->promptTokensDetails->toArray();
        }

        if ($this->completionTokensDetails) {
            $result['completion_tokens_details'] = $this->completionTokensDetails->toArray();
        }

        return $result;
    }
}
PK     S%W]E1Y}±  ±  =  client/src/Responses/Chat/CreateResponseChoiceAnnotations.phpnu „[µü¤        <?php

namespace OpenAI\Responses\Chat;

final class CreateResponseChoiceAnnotations
{
    public function __construct(
        public readonly string $type,
        public readonly CreateResponseChoiceAnnotationsUrlCitations $urlCitations
    ) {}

    /**
     * @param  array{type: string, url_citation: array{end_index: int, start_index: int, title: string, url: string}}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['type'],
            CreateResponseChoiceAnnotationsUrlCitations::from($attributes['url_citation'])
        );
    }

    /**
     * @return array{type: string, url_citation: array{end_index: int, start_index: int, title: string, url: string}}
     */
    public function toArray(): array
    {
        return [
            'type'         => $this->type,
            'url_citation' => $this->urlCitations->toArray(),
        ];
    }
}
PK     S%W]v¨ºQ’  ’  7  client/src/Responses/Chat/CreateResponseChoiceAudio.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Chat;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type CreateResponseChoiceAudioType array{id: string, data: string, expires_at: int, transcript: string}
 *
 * @implements ResponseContract<CreateResponseChoiceAudioType>
 */
final class CreateResponseChoiceAudio implements ResponseContract
{
    /**
     * @use ArrayAccessible<CreateResponseChoiceAudioType>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public readonly string $id,
        public readonly string $data,
        public readonly int $expiresAt,
        public readonly string $transcript,
    ) {}

    /**
     * @param  CreateResponseChoiceAudioType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            id: $attributes['id'],
            data: $attributes['data'],
            expiresAt: $attributes['expires_at'],
            transcript: $attributes['transcript'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'         => $this->id,
            'data'       => $this->data,
            'expires_at' => $this->expiresAt,
            'transcript' => $this->transcript,
        ];
    }
}
PK     S%W]˜YÃÓ  Ó  <  client/src/Responses/Chat/CreateStreamedResponseToolCall.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Chat;

final class CreateStreamedResponseToolCall
{
    private function __construct(
        public readonly ?int $index,
        public readonly ?string $id,
        public readonly ?string $type,
        public readonly CreateStreamedResponseToolCallFunction $function,
    ) {}

    /**
     * @param  array{index?: int, id?: string, type?: string, function: array{name?: string, arguments: string}}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['index'] ?? null,
            $attributes['id'] ?? null,
            $attributes['type'] ?? null,
            CreateStreamedResponseToolCallFunction::from($attributes['function']),
        );
    }

    /**
     * @return array{index?: int, id?: string, type?: string, function?: array{name?: string, arguments: string}}
     */
    public function toArray(): array
    {
        return array_filter([
            'index'    => $this->index,
            'id'       => $this->id,
            'type'     => $this->type,
            'function' => $this->function->toArray(),
        ], fn (mixed $value): bool => ! is_null($value));
    }
}
PK     S%W]ÚMt  t  3  client/src/Responses/Chat/CreateResponseMessage.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Chat;

/**
 * @phpstan-import-type CreateResponseChoiceAudioType from CreateResponseChoiceAudio
 */
final class CreateResponseMessage
{
    /**
     * @param  array<int, CreateResponseToolCall>  $toolCalls
     * @param  array<int, CreateResponseChoiceAnnotations>  $annotations
     */
    private function __construct(
        public readonly string $role,
        public readonly ?string $content,
        public readonly array $annotations,
        public readonly array $toolCalls,
        public readonly ?CreateResponseFunctionCall $functionCall,
        public readonly ?CreateResponseChoiceAudio $audio = null,
    ) {}

    /**
     * @param  array{role: string, content: ?string, annotations?: array<int, array{type: string, url_citation: array{start_index: int, end_index: int, title: string, url: string}}>, function_call: ?array{name: string, arguments: string}, tool_calls: ?array<int, array{id: string, type: string, function: array{name: string, arguments: string}}>, audio?: CreateResponseChoiceAudioType}  $attributes
     */
    public static function from(array $attributes): self
    {
        $toolCalls = array_map(fn (array $result): CreateResponseToolCall => CreateResponseToolCall::from(
            $result
        ), $attributes['tool_calls'] ?? []);

        $annotations = array_map(fn (array $result): CreateResponseChoiceAnnotations => CreateResponseChoiceAnnotations::from(
            $result,
        ), $attributes['annotations'] ?? []);

        return new self(
            $attributes['role'],
            $attributes['content'] ?? null,
            $annotations,
            $toolCalls,
            isset($attributes['function_call']) ? CreateResponseFunctionCall::from($attributes['function_call']) : null,
            isset($attributes['audio']) ? CreateResponseChoiceAudio::from($attributes['audio']) : null,
        );
    }

    /**
     * @return array{role: string, content: string|null, annotations?: array<int, array{type: string, url_citation: array{start_index: int, end_index: int, title: string, url: string}}>, function_call?: array{name: string, arguments: string}, tool_calls?: array<int, array{id: string, type: string, function: array{name: string, arguments: string}}>, audio?: CreateResponseChoiceAudioType}
     */
    public function toArray(): array
    {
        $data = [
            'role'    => $this->role,
            'content' => $this->content,
        ];

        if ($this->annotations !== []) {
            $data['annotations'] = array_map(fn (CreateResponseChoiceAnnotations $annotations): array => $annotations->toArray(), $this->annotations);
        }

        if ($this->functionCall instanceof CreateResponseFunctionCall) {
            $data['function_call'] = $this->functionCall->toArray();
        }

        if ($this->toolCalls !== []) {
            $data['tool_calls'] = array_map(fn (CreateResponseToolCall $toolCall): array => $toolCall->toArray(), $this->toolCalls);
        }

        if ($this->audio instanceof CreateResponseChoiceAudio) {
            $data['audio'] = $this->audio->toArray();
        }

        return $data;
    }
}
PK     S%W]	õÂ„°
  °
  '  client/src/Responses/StreamResponse.phpnu „[µü¤        <?php

namespace OpenAI\Responses;

use Generator;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Contracts\ResponseStreamContract;
use OpenAI\Exceptions\ErrorException;
use OpenAI\Responses\Meta\MetaInformation;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\StreamInterface;

/**
 * @template TResponse
 *
 * @implements ResponseStreamContract<TResponse>
 */
final class StreamResponse implements ResponseHasMetaInformationContract, ResponseStreamContract
{
    /**
     * Creates a new Stream Response instance.
     *
     * @param  class-string<TResponse>  $responseClass
     */
    public function __construct(
        private readonly string $responseClass,
        private readonly ResponseInterface $response,
    ) {
        //
    }

    /**
     * {@inheritDoc}
     */
    public function getIterator(): Generator
    {
        while (! $this->response->getBody()->eof()) {
            $line = $this->readLine($this->response->getBody());

            $event = null;
            if (str_starts_with($line, 'event:')) {
                $event = trim(substr($line, strlen('event:')));
                $line = $this->readLine($this->response->getBody());
            }

            if (! str_starts_with($line, 'data:')) {
                continue;
            }

            $data = trim(substr($line, strlen('data:')));

            if ($data === '[DONE]') {
                break;
            }

            /** @var array{error?: array{message: string|array<int, string>, type: string, code: string}, type?: string} $response */
            $response = json_decode($data, true, flags: JSON_THROW_ON_ERROR);

            if (isset($response['error'])) {
                throw new ErrorException($response['error'], $this->response->getStatusCode());
            }

            if (isset($response['type']) && $response['type'] === 'ping') {
                continue;
            }

            if ($event !== null) {
                $response['__event'] = $event;
            }
            $response['__meta'] = $this->meta();

            yield $this->responseClass::from($response);
        }
    }

    /**
     * Read a line from the stream.
     */
    private function readLine(StreamInterface $stream): string
    {
        $buffer = '';

        while (! $stream->eof()) {
            if ('' === ($byte = $stream->read(1))) {
                return $buffer;
            }
            $buffer .= $byte;
            if ($byte === "\n") {
                break;
            }
        }

        return $buffer;
    }

    public function meta(): MetaInformation
    {
        // @phpstan-ignore-next-line
        return MetaInformation::from($this->response->getHeaders());
    }
}
PK     S%W]¿£ì°w  w  -  client/src/Responses/Meta/MetaInformation.phpnu „[µü¤        <?php

namespace OpenAI\Responses\Meta;

use OpenAI\Contracts\MetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;

/**
 * @implements MetaInformationContract<array{x-request-id?: string, openai-model?: string, openai-organization?: string, openai-processing-ms?: int, openai-version?: string, x-ratelimit-limit-requests?: int, x-ratelimit-limit-tokens?: int, x-ratelimit-remaining-requests?: int, x-ratelimit-remaining-tokens?: int, x-ratelimit-reset-requests?: string, x-ratelimit-reset-tokens?: string}>
 */
final class MetaInformation implements MetaInformationContract
{
    /**
     * @use ArrayAccessible<array{x-request-id?: string, openai-model?: string, openai-organization?: string, openai-processing-ms?: int, openai-version?: string, x-ratelimit-limit-requests?: int, x-ratelimit-limit-tokens?: int, x-ratelimit-remaining-requests?: int, x-ratelimit-remaining-tokens?: int, x-ratelimit-reset-requests?: string, x-ratelimit-reset-tokens?: string}>
     */
    use ArrayAccessible;

    private function __construct(
        public ?string $requestId,
        public readonly MetaInformationOpenAI $openai,
        public readonly ?MetaInformationRateLimit $requestLimit,
        public readonly ?MetaInformationRateLimit $tokenLimit,
    ) {}

    /**
     * @param  array{x-request-id: string[], openai-model: string[], openai-organization: string[], openai-version: string[], openai-processing-ms: string[], x-ratelimit-limit-requests: string[], x-ratelimit-remaining-requests: string[], x-ratelimit-reset-requests: string[], x-ratelimit-limit-tokens: string[], x-ratelimit-remaining-tokens: string[], x-ratelimit-reset-tokens: string[]}  $headers
     */
    public static function from(array $headers): self
    {
        $headers = array_change_key_case($headers, CASE_LOWER);

        $requestId = $headers['x-request-id'][0] ?? null;

        $openai = MetaInformationOpenAI::from([
            'model'        => $headers['openai-model'][0] ?? null,
            'organization' => $headers['openai-organization'][0] ?? null,
            'version'      => $headers['openai-version'][0] ?? null,
            'processingMs' => isset($headers['openai-processing-ms'][0]) ? (int) $headers['openai-processing-ms'][0] : null,
        ]);

        if (isset($headers['x-ratelimit-remaining-requests'][0])) {
            $requestLimit = MetaInformationRateLimit::from([
                'limit'     => isset($headers['x-ratelimit-limit-requests'][0]) ? (int) $headers['x-ratelimit-limit-requests'][0] : null,
                'remaining' => (int) $headers['x-ratelimit-remaining-requests'][0],
                'reset'     => $headers['x-ratelimit-reset-requests'][0] ?? null,
            ]);
        } else {
            $requestLimit = null;
        }

        if (isset($headers['x-ratelimit-remaining-tokens'][0])) {
            $tokenLimit = MetaInformationRateLimit::from([
                'limit'     => isset($headers['x-ratelimit-limit-tokens'][0]) ? (int) $headers['x-ratelimit-limit-tokens'][0] : null,
                'remaining' => (int) $headers['x-ratelimit-remaining-tokens'][0],
                'reset'     => $headers['x-ratelimit-reset-tokens'][0] ?? null,
            ]);
        } else {
            $tokenLimit = null;
        }

        return new self(
            $requestId,
            $openai,
            $requestLimit,
            $tokenLimit,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return array_filter([
            'openai-model'                   => $this->openai->model,
            'openai-organization'            => $this->openai->organization,
            'openai-processing-ms'           => $this->openai->processingMs,
            'openai-version'                 => $this->openai->version,
            'x-ratelimit-limit-requests'     => $this->requestLimit->limit ?? null,
            'x-ratelimit-limit-tokens'       => $this->tokenLimit->limit ?? null,
            'x-ratelimit-remaining-requests' => $this->requestLimit->remaining ?? null,
            'x-ratelimit-remaining-tokens'   => $this->tokenLimit->remaining ?? null,
            'x-ratelimit-reset-requests'     => $this->requestLimit->reset ?? null,
            'x-ratelimit-reset-tokens'       => $this->tokenLimit->reset ?? null,
            'x-request-id'                   => $this->requestId,
        ], fn (string|int|null $value): bool => ! is_null($value));
    }
}
PK     S%W]÷$¦¨  ¨  3  client/src/Responses/Meta/MetaInformationOpenAI.phpnu „[µü¤        <?php

namespace OpenAI\Responses\Meta;

final class MetaInformationOpenAI
{
    private function __construct(
        public readonly ?string $model,
        public readonly ?string $organization,
        public readonly ?string $version,
        public readonly ?int $processingMs,
    ) {}

    /**
     * @param  array{model: ?string, organization: ?string, version: ?string, processingMs: ?int}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['model'],
            $attributes['organization'],
            $attributes['version'],
            $attributes['processingMs'],
        );
    }
}
PK     S%W]õ®Y|%  %  6  client/src/Responses/Meta/MetaInformationRateLimit.phpnu „[µü¤        <?php

namespace OpenAI\Responses\Meta;

final class MetaInformationRateLimit
{
    private function __construct(
        public readonly ?int $limit,
        public readonly int $remaining,
        public readonly ?string $reset,
    ) {}

    /**
     * @param  array{limit: ?int, remaining: int, reset: ?string}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['limit'],
            $attributes['remaining'],
            $attributes['reset'],
        );
    }
}
PK     S%W]Ü Ê"
  "
  1  client/src/Responses/Images/VariationResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Images;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{created: int, data: array<int, array{url?: string, b64_json?: string}>, usage?: array{total_tokens: int, input_tokens: int, output_tokens: int, input_tokens_details: array{text_tokens: int, image_tokens: int}}}>
 */
final class VariationResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{created: int, data: array<int, array{url?: string, b64_json?: string}>, usage?: array{total_tokens: int, input_tokens: int, output_tokens: int, input_tokens_details: array{text_tokens: int, image_tokens: int}}}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<int, VariationResponseData>  $data
     */
    private function __construct(
        public readonly int $created,
        public readonly array $data,
        private readonly MetaInformation $meta,
        public readonly ?ImageResponseUsage $usage = null,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{created: int, data: array<int, array{url?: string, b64_json?: string}>, usage?: array{total_tokens: int, input_tokens: int, output_tokens: int, input_tokens_details: array{text_tokens: int, image_tokens: int}}}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        $results = array_map(fn (array $result): VariationResponseData => VariationResponseData::from(
            $result
        ), $attributes['data']);

        return new self(
            $attributes['created'],
            $results,
            $meta,
            isset($attributes['usage']) ? ImageResponseUsage::from($attributes['usage']) : null,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        $result = [
            'created' => $this->created,
            'data'    => array_map(
                static fn (VariationResponseData $result): array => $result->toArray(),
                $this->data,
            ),
        ];

        if ($this->usage !== null) {
            $result['usage'] = $this->usage->toArray();
        }

        return $result;
    }
}
PK     S%W]_'ã	
  	
  ,  client/src/Responses/Images/EditResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Images;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{created: int, data: array<int, array{url?: string, b64_json?: string}>, usage?: array{total_tokens: int, input_tokens: int, output_tokens: int, input_tokens_details: array{text_tokens: int, image_tokens: int}}}>
 */
final class EditResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{created: int, data: array<int, array{url?: string, b64_json?: string}>, usage?: array{total_tokens: int, input_tokens: int, output_tokens: int, input_tokens_details: array{text_tokens: int, image_tokens: int}}}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<int, EditResponseData>  $data
     */
    private function __construct(
        public readonly int $created,
        public readonly array $data,
        private readonly MetaInformation $meta,
        public readonly ?ImageResponseUsage $usage = null,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{created: int, data: array<int, array{url?: string, b64_json?: string}>, usage?: array{total_tokens: int, input_tokens: int, output_tokens: int, input_tokens_details: array{text_tokens: int, image_tokens: int}}}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        $results = array_map(fn (array $result): EditResponseData => EditResponseData::from(
            $result
        ), $attributes['data']);

        return new self(
            $attributes['created'],
            $results,
            $meta,
            isset($attributes['usage']) ? ImageResponseUsage::from($attributes['usage']) : null,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        $result = [
            'created' => $this->created,
            'data'    => array_map(
                static fn (EditResponseData $result): array => $result->toArray(),
                $this->data,
            ),
        ];

        if ($this->usage !== null) {
            $result['usage'] = $this->usage->toArray();
        }

        return $result;
    }
}
PK     S%W]r©    D  client/src/Responses/Images/ImageResponseUsageInputTokensDetails.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Images;

final class ImageResponseUsageInputTokensDetails
{
    private function __construct(
        public readonly int $textTokens,
        public readonly int $imageTokens,
    ) {}

    /**
     * @param  array{text_tokens: int, image_tokens: int}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['text_tokens'],
            $attributes['image_tokens'],
        );
    }

    /**
     * @return array{text_tokens: int, image_tokens: int}
     */
    public function toArray(): array
    {
        return [
            'text_tokens'  => $this->textTokens,
            'image_tokens' => $this->imageTokens,
        ];
    }
}
PK     S%W]–JÁ  Á  2  client/src/Responses/Images/CreateResponseData.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Images;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;

/**
 * @implements ResponseContract<array{url: string, revised_prompt?: string}|array{b64_json: string, revised_prompt?: string}>
 */
final class CreateResponseData implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{url: string, revised_prompt?: string}|array{b64_json: string, revised_prompt?: string}>
     */
    use ArrayAccessible;

    private function __construct(
        public readonly string $url,
        public readonly string $b64_json,
        public readonly ?string $revisedPrompt,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{url?: string, b64_json?: string, revised_prompt?: string}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['url'] ?? '',
            $attributes['b64_json'] ?? '',
            $attributes['revised_prompt'] ?? null,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        $data = $this->url !== '' && $this->url !== '0' ?
            ['url' => $this->url] :
            ['b64_json' => $this->b64_json];

        if ($this->revisedPrompt !== null) {
            $data['revised_prompt'] = $this->revisedPrompt;
        }

        return $data;
    }
}
PK     S%W]3@è?  ?  2  client/src/Responses/Images/ImageResponseUsage.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Images;

final class ImageResponseUsage
{
    private function __construct(
        public readonly int $totalTokens,
        public readonly int $inputTokens,
        public readonly int $outputTokens,
        public readonly ImageResponseUsageInputTokensDetails $inputTokensDetails,
    ) {}

    /**
     * @param  array{total_tokens: int, input_tokens: int, output_tokens: int, input_tokens_details: array{text_tokens: int, image_tokens: int}}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['total_tokens'],
            $attributes['input_tokens'],
            $attributes['output_tokens'],
            ImageResponseUsageInputTokensDetails::from($attributes['input_tokens_details']),
        );
    }

    /**
     * @return array{total_tokens: int, input_tokens: int, output_tokens: int, input_tokens_details: array{text_tokens: int, image_tokens: int}}
     */
    public function toArray(): array
    {
        return [
            'total_tokens'         => $this->totalTokens,
            'input_tokens'         => $this->inputTokens,
            'output_tokens'        => $this->outputTokens,
            'input_tokens_details' => $this->inputTokensDetails->toArray(),
        ];
    }
}
PK     S%W]ÞYæò^
  ^
  .  client/src/Responses/Images/CreateResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Images;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{created: int, data: array<int, array{url?: string, b64_json?: string, revised_prompt?: string}>, usage?: array{total_tokens: int, input_tokens: int, output_tokens: int, input_tokens_details: array{text_tokens: int, image_tokens: int}}}>
 */
final class CreateResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{created: int, data: array<int, array{url?: string, b64_json?: string, revised_prompt?: string}>, usage?: array{total_tokens: int, input_tokens: int, output_tokens: int, input_tokens_details: array{text_tokens: int, image_tokens: int}}}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<int, CreateResponseData>  $data
     */
    private function __construct(
        public readonly int $created,
        public readonly array $data,
        private readonly MetaInformation $meta,
        public readonly ?ImageResponseUsage $usage = null,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{created: int, data: array<int, array{url?: string, b64_json?: string, revised_prompt?: string}>, usage?: array{total_tokens: int, input_tokens: int, output_tokens: int, input_tokens_details: array{text_tokens: int, image_tokens: int}}}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        $results = array_map(fn (array $result): CreateResponseData => CreateResponseData::from(
            $result
        ), $attributes['data']);

        return new self(
            $attributes['created'],
            $results,
            $meta,
            isset($attributes['usage']) ? ImageResponseUsage::from($attributes['usage']) : null,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        $result = [
            'created' => $this->created,
            'data'    => array_map(
                static fn (CreateResponseData $result): array => $result->toArray(),
                $this->data,
            ),
        ];

        if ($this->usage !== null) {
            $result['usage'] = $this->usage->toArray();
        }

        return $result;
    }
}
PK     S%W]µ÷±X  X  5  client/src/Responses/Images/VariationResponseData.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Images;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;

/**
 * @implements ResponseContract<array{url: string}|array{b64_json: string}>
 */
final class VariationResponseData implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{url: string}|array{b64_json: string}>
     */
    use ArrayAccessible;

    private function __construct(
        public readonly string $url,
        public readonly string $b64_json,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{url?: string, b64_json?: string}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['url'] ?? '',
            $attributes['b64_json'] ?? '',
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return $this->url !== '' && $this->url !== '0' ?
            ['url' => $this->url] :
            ['b64_json' => $this->b64_json];
    }
}
PK     S%W]%Î^WS  S  0  client/src/Responses/Images/EditResponseData.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Images;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;

/**
 * @implements ResponseContract<array{url: string}|array{b64_json: string}>
 */
final class EditResponseData implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{url: string}|array{b64_json: string}>
     */
    use ArrayAccessible;

    private function __construct(
        public readonly string $url,
        public readonly string $b64_json,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{url?: string, b64_json?: string}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['url'] ?? '',
            $attributes['b64_json'] ?? '',
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return $this->url !== '' && $this->url !== '0' ?
            ['url' => $this->url] :
            ['b64_json' => $this->b64_json];
    }
}
PK     S%W]J2Œu£  £  N  client/src/Responses/Realtime/TranscriptionSession/InputAudioTranscription.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Realtime\TranscriptionSession;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type InputAudioTranscriptionType array{language: string, model: 'gpt-4o-transcribe'|'gpt-4o-mini-transcribe'|'whisper-1', prompt: string}
 *
 * @implements ResponseContract<InputAudioTranscriptionType>
 */
final class InputAudioTranscription implements ResponseContract
{
    /**
     * @use ArrayAccessible<InputAudioTranscriptionType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'gpt-4o-transcribe'|'gpt-4o-mini-transcribe'|"whisper-1"  $model
     */
    private function __construct(
        public readonly string $language,
        public readonly string $model,
        public readonly string $prompt,
    ) {}

    /**
     * @param  InputAudioTranscriptionType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            language: $attributes['language'],
            model: $attributes['model'],
            prompt: $attributes['prompt'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'language' => $this->language,
            'model'    => $this->model,
            'prompt'   => $this->prompt,
        ];
    }
}
PK     S%W]‰ÕÌF  F  6  client/src/Responses/Realtime/Session/ClientSecret.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Realtime\Session;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type ClientSecretType array{expires_at: int, value: string}
 *
 * @implements ResponseContract<ClientSecretType>
 */
final class ClientSecret implements ResponseContract
{
    /**
     * @use ArrayAccessible<ClientSecretType>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public readonly int $expiresAt,
        public readonly string $value,
    ) {}

    /**
     * @param  ClientSecretType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            expiresAt: $attributes['expires_at'],
            value: $attributes['value'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'expires_at' => $this->expiresAt,
            'value'      => $this->value,
        ];
    }
}
PK     S%W]øzÝè    A  client/src/Responses/Realtime/Session/InputAudioTranscription.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Realtime\Session;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type InputAudioTranscriptionType array{model: 'whisper-1'}
 *
 * @implements ResponseContract<InputAudioTranscriptionType>
 */
final class InputAudioTranscription implements ResponseContract
{
    /**
     * @use ArrayAccessible<InputAudioTranscriptionType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  "whisper-1"  $model
     */
    private function __construct(
        public readonly string $model
    ) {}

    /**
     * @param  InputAudioTranscriptionType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            model: $attributes['model'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'model' => $this->model,
        ];
    }
}
PK     S%W]j L!  !  7  client/src/Responses/Realtime/Session/TurnDetection.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Realtime\Session;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type TurnDetectionType array{prefix_padding_ms: int, silence_duration_ms: int, threshold: float, type: 'server_vad'}
 *
 * @implements ResponseContract<TurnDetectionType>
 */
final class TurnDetection implements ResponseContract
{
    /**
     * @use ArrayAccessible<TurnDetectionType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'server_vad'  $type
     */
    private function __construct(
        public readonly int $prefixPaddingMs,
        public readonly int $silenceDurationMs,
        public readonly float $threshold,
        public readonly string $type,
    ) {}

    /**
     * @param  TurnDetectionType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            prefixPaddingMs: $attributes['prefix_padding_ms'],
            silenceDurationMs: $attributes['silence_duration_ms'],
            threshold: $attributes['threshold'],
            type: $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'prefix_padding_ms'   => $this->prefixPaddingMs,
            'silence_duration_ms' => $this->silenceDurationMs,
            'threshold'           => $this->threshold,
            'type'                => $this->type,
        ];
    }
}
PK     S%W]`t±±G  G  >  client/src/Responses/Realtime/TranscriptionSessionResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Realtime;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Realtime\Session\ClientSecret;
use OpenAI\Responses\Realtime\Session\TurnDetection;
use OpenAI\Responses\Realtime\Tools\FunctionTool;
use OpenAI\Responses\Realtime\TranscriptionSession\InputAudioTranscription;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-import-type ClientSecretType from ClientSecret
 * @phpstan-import-type InputAudioTranscriptionType from InputAudioTranscription
 * @phpstan-import-type TurnDetectionType from TurnDetection
 * @phpstan-import-type FunctionToolType from FunctionTool
 *
 * @phpstan-type TranscriptionSessionType array{client_secret: ClientSecretType, input_audio_format: 'pcm16'|'g711_ulaw'|'g711_alaw', input_audio_transcription: InputAudioTranscriptionType|null, modalities: array<string>|null, turn_detection: TurnDetectionType|null}
 *
 * @implements ResponseContract<TranscriptionSessionType>
 */
final class TranscriptionSessionResponse implements ResponseContract
{
    /**
     * @use ArrayAccessible<TranscriptionSessionType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'pcm16'|'g711_ulaw'|'g711_alaw'  $inputAudioFormat
     * @param  array<string>|null  $modalities
     */
    private function __construct(
        public readonly ClientSecret $clientSecret,
        public readonly string $inputAudioFormat,
        public readonly ?InputAudioTranscription $inputAudioTranscription,
        public readonly ?array $modalities,
        public readonly ?TurnDetection $turnDetection,
    ) {}

    /**
     * @param  TranscriptionSessionType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            clientSecret: ClientSecret::from($attributes['client_secret']),
            inputAudioFormat: $attributes['input_audio_format'],
            inputAudioTranscription: isset($attributes['input_audio_transcription'])
                ? InputAudioTranscription::from($attributes['input_audio_transcription'])
                : null,
            modalities: $attributes['modalities'] ?? null,
            turnDetection: isset($attributes['turn_detection'])
                ? TurnDetection::from($attributes['turn_detection'])
                : null,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'client_secret'             => $this->clientSecret->toArray(),
            'input_audio_format'        => $this->inputAudioFormat,
            'input_audio_transcription' => $this->inputAudioTranscription?->toArray(),
            'modalities'                => $this->modalities,
            'turn_detection'            => $this->turnDetection?->toArray(),
        ];
    }
}
PK     S%W]8òÉê  ê  4  client/src/Responses/Realtime/Tools/FunctionTool.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Realtime\Tools;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type FunctionToolType array{description: string, name: string, parameters: array<string, mixed>, type: 'function'}
 *
 * @implements ResponseContract<FunctionToolType>
 */
final class FunctionTool implements ResponseContract
{
    /**
     * @use ArrayAccessible<FunctionToolType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  array<string, mixed>  $parameters
     * @param  'function'  $type
     */
    private function __construct(
        public readonly string $description,
        public readonly string $name,
        public readonly array $parameters,
        public readonly string $type,
    ) {}

    /**
     * @param  FunctionToolType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            description: $attributes['description'],
            name: $attributes['name'],
            parameters: $attributes['parameters'],
            type: $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'description' => $this->description,
            'name'        => $this->name,
            'parameters'  => $this->parameters,
            'type'        => $this->type,
        ];
    }
}
PK     S%W]mgÇá  á  1  client/src/Responses/Realtime/SessionResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Realtime;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Realtime\Session\ClientSecret;
use OpenAI\Responses\Realtime\Session\InputAudioTranscription;
use OpenAI\Responses\Realtime\Session\TurnDetection;
use OpenAI\Responses\Realtime\Tools\FunctionTool;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-import-type ClientSecretType from ClientSecret
 * @phpstan-import-type InputAudioTranscriptionType from InputAudioTranscription
 * @phpstan-import-type TurnDetectionType from TurnDetection
 * @phpstan-import-type FunctionToolType from FunctionTool
 *
 * @phpstan-type SessionType array{client_secret: ClientSecretType, input_audio_format: 'pcm16'|'g711_ulaw'|'g711_alaw', input_audio_transcription: InputAudioTranscriptionType|null, instructions: string,  max_response_output_tokens: int|'inf', modalities: array<string>, output_audio_format: 'pcm16'|'g711_ulaw'|'g711_alaw', temperature: float, tool_choice: 'auto'|'none'|'required', tools: array<FunctionToolType>, turn_detection: TurnDetectionType|null, voice: 'alloy'|'ash'|'ballad'|'coral'|'echo'|'sage'|'shimmer'|'verse'}
 *
 * @implements ResponseContract<SessionType>
 */
final class SessionResponse implements ResponseContract
{
    /**
     * @use ArrayAccessible<SessionType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'pcm16'|'g711_ulaw'|'g711_alaw'  $inputAudioFormat
     * @param  int|'inf'  $maxResponseOutputTokens
     * @param  array<string>  $modalities
     * @param  'pcm16'|'g711_ulaw'|'g711_alaw'  $outputAudioFormat
     * @param  'auto'|'none'|'required'  $toolChoice
     * @param  array<FunctionTool>  $tools
     * @param  'alloy'|'ash'|'ballad'|'coral'|'echo'|'sage'|'shimmer'|'verse'  $voice
     */
    private function __construct(
        public readonly ClientSecret $clientSecret,
        public readonly string $inputAudioFormat,
        public readonly ?InputAudioTranscription $inputAudioTranscription,
        public readonly string $instructions,
        public readonly int|string $maxResponseOutputTokens,
        public readonly array $modalities,
        public readonly string $outputAudioFormat,
        public readonly float $temperature,
        public readonly string $toolChoice,
        public readonly array $tools,
        public readonly ?TurnDetection $turnDetection,
        public readonly string $voice,
    ) {}

    /**
     * @param  SessionType  $attributes
     */
    public static function from(array $attributes): self
    {
        $tools = array_map(
            fn (array $tool): FunctionTool => match ($tool['type']) {
                'function' => FunctionTool::from($tool),
            },
            $attributes['tools']
        );

        return new self(
            clientSecret: ClientSecret::from($attributes['client_secret']),
            inputAudioFormat: $attributes['input_audio_format'],
            inputAudioTranscription: isset($attributes['input_audio_transcription'])
                ? InputAudioTranscription::from($attributes['input_audio_transcription'])
                : null,
            instructions: $attributes['instructions'],
            maxResponseOutputTokens: $attributes['max_response_output_tokens'],
            modalities: $attributes['modalities'],
            outputAudioFormat: $attributes['output_audio_format'],
            temperature: $attributes['temperature'],
            toolChoice: $attributes['tool_choice'],
            tools: $tools,
            turnDetection: isset($attributes['turn_detection'])
                ? TurnDetection::from($attributes['turn_detection'])
                : null,
            voice: $attributes['voice'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'client_secret'              => $this->clientSecret->toArray(),
            'input_audio_format'         => $this->inputAudioFormat,
            'input_audio_transcription'  => $this->inputAudioTranscription?->toArray(),
            'instructions'               => $this->instructions,
            'max_response_output_tokens' => $this->maxResponseOutputTokens,
            'modalities'                 => $this->modalities,
            'output_audio_format'        => $this->outputAudioFormat,
            'temperature'                => $this->temperature,
            'tool_choice'                => $this->toolChoice,
            'tools'                      => array_map(
                static fn (FunctionTool $tool): array => $tool->toArray(),
                $this->tools,
            ),
            'turn_detection' => $this->turnDetection?->toArray(),
            'voice'          => $this->voice,
        ];
    }
}
PK     S%W]œ)#b  b  M  client/src/Responses/VectorStores/Search/VectorStoreSearchResponseContent.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\VectorStores\Search;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{type: string, text: string}>
 */
final class VectorStoreSearchResponseContent implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{type: string, text: string}>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public readonly string $type,
        public readonly string $text,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{type: string, text: string}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['type'],
            $attributes['text'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type' => $this->type,
            'text' => $this->text,
        ];
    }
}
PK     S%W]ìê™‹  ‹  F  client/src/Responses/VectorStores/Search/VectorStoreSearchResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\VectorStores\Search;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{object: string, search_query: string|array<mixed>, data: array<int, array{file_id: string, filename: string, score: float, attributes: array<string, mixed>, content: array<int, array{type: string, text: string}>}>, has_more: bool, next_page: ?string}>
 */
final class VectorStoreSearchResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{object: string, search_query: string|array<mixed>, data: array<int, array{file_id: string, filename: string, score: float, attributes: array<string, mixed>, content: array<int, array{type: string, text: string}>}>, has_more: bool, next_page: ?string}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<int, VectorStoreSearchResponseFile>  $data
     * @param  string|array<mixed>  $searchQuery
     */
    private function __construct(
        public readonly string $object,
        public readonly string|array $searchQuery,
        public readonly array $data,
        public readonly bool $hasMore,
        public readonly ?string $nextPage,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{object: string, search_query: string|array<mixed>, data: array<int, array{file_id: string, filename: string, score: float, attributes: array<string, mixed>, content: array<int, array{type: string, text: string}>}>, has_more: bool, next_page: ?string}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        $data = array_map(
            static fn (array $result): VectorStoreSearchResponseFile => VectorStoreSearchResponseFile::from($result),
            $attributes['data']
        );

        return new self(
            $attributes['object'],
            $attributes['search_query'],
            $data,
            $attributes['has_more'],
            $attributes['next_page'],
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     *
     * @return array{object: string, search_query: string|array<mixed>, data: array<int, array{file_id: string, filename: string, score: float, attributes: array<string, mixed>, content: array<int, array{type: string, text: string}>}>, has_more: bool, next_page: ?string}
     */
    public function toArray(): array
    {
        return [
            'object'       => $this->object,
            'search_query' => $this->searchQuery,
            'data'         => array_map(
                static fn (VectorStoreSearchResponseFile $item): array => $item->toArray(),
                $this->data
            ),
            'has_more'  => $this->hasMore,
            'next_page' => $this->nextPage,
        ];
    }
}
PK     S%W]Œ)u-
	  
	  J  client/src/Responses/VectorStores/Search/VectorStoreSearchResponseFile.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\VectorStores\Search;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{file_id: string, filename: string, score: float, attributes: array<string, mixed>, content: array<int, array{type: string, text: string}>}>
 */
final class VectorStoreSearchResponseFile implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{file_id: string, filename: string, score: float, attributes: array<string, mixed>, content: array<int, array{type: string, text: string}>}>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  array<string, mixed>  $attributes
     * @param  array<int, VectorStoreSearchResponseContent>  $content
     */
    private function __construct(
        public readonly string $fileId,
        public readonly string $filename,
        public readonly float $score,
        public readonly array $attributes,
        public readonly array $content,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{file_id: string, filename: string, score: float, attributes: array<string, mixed>, content: array<int, array{type: string, text: string}>}  $attributes
     */
    public static function from(array $attributes): self
    {
        $content = array_map(
            static fn (array $content): VectorStoreSearchResponseContent => VectorStoreSearchResponseContent::from($content),
            $attributes['content'],
        );

        return new self(
            $attributes['file_id'],
            $attributes['filename'],
            $attributes['score'],
            $attributes['attributes'],
            $content,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'file_id'    => $this->fileId,
            'filename'   => $this->filename,
            'score'      => $this->score,
            'attributes' => $this->attributes,
            'content'    => array_map(
                static fn (VectorStoreSearchResponseContent $content): array => $content->toArray(),
                $this->content,
            ),
        ];
    }
}
PK     S%W]‡<(~+  +  ?  client/src/Responses/VectorStores/VectorStoreDeleteResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\VectorStores;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{id: string, object: string, deleted: bool}>
 */
final class VectorStoreDeleteResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{id: string, object: string, deleted: bool}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly string $id,
        public readonly string $object,
        public readonly bool $deleted,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{id: string, object: string, deleted: bool}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            $attributes['id'],
            $attributes['object'],
            $attributes['deleted'],
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'      => $this->id,
            'object'  => $this->object,
            'deleted' => $this->deleted,
        ];
    }
}
PK     S%W]‰7!þÒ  Ò  9  client/src/Responses/VectorStores/VectorStoreResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\VectorStores;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{id: string, object: string, created_at: int, name: ?string, usage_bytes: int, file_counts: array{in_progress: int, completed: int, failed: int, cancelled: int, total: int}, status: string, expires_after: ?array{anchor: string, days: int}, expires_at: ?int, last_active_at: ?int, metadata: array<string, string>}>
 */
final class VectorStoreResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{id: string, object: string, created_at: int, name: ?string, usage_bytes: int, file_counts: array{in_progress: int, completed: int, failed: int, cancelled: int, total: int}, status: string, expires_after: ?array{anchor: string, days: int}, expires_at: ?int, last_active_at: ?int, metadata: array<string, string>}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<string, string>  $metadata
     */
    private function __construct(
        public readonly string $id,
        public readonly string $object,
        public readonly int $createdAt,
        public readonly ?string $name,
        public readonly int $usageBytes,
        public readonly VectorStoreResponseFileCounts $fileCounts,
        public readonly string $status,
        public readonly ?VectorStoreResponseExpiresAfter $expiresAfter,
        public readonly ?int $expiresAt,
        public readonly ?int $lastActiveAt,
        public readonly array $metadata,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{id: string, object: string, created_at: int, name: ?string, usage_bytes: int, file_counts: array{in_progress: int, completed: int, failed: int, cancelled: int, total: int}, status: string, expires_after: ?array{anchor: string, days: int}, expires_at: ?int, last_active_at: ?int, metadata: array<string, string>}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            $attributes['id'],
            $attributes['object'],
            $attributes['created_at'],
            $attributes['name'],
            $attributes['usage_bytes'],
            VectorStoreResponseFileCounts::from($attributes['file_counts']),
            $attributes['status'],
            isset($attributes['expires_after']) ? VectorStoreResponseExpiresAfter::from($attributes['expires_after']) : null,
            $attributes['expires_at'],
            $attributes['last_active_at'],
            $attributes['metadata'],
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     *
     * @return array{id: string, object: string, name: string|null, status: string, usage_bytes: int, created_at: int, file_counts: array{in_progress: int, completed: int, failed: int, cancelled: int, total: int}, metadata: mixed[], expires_after: array{anchor: string, days: int}|null, expires_at: int|null, last_active_at: int|null}
     */
    public function toArray(): array
    {
        return [
            'id'             => $this->id,
            'object'         => $this->object,
            'name'           => $this->name,
            'status'         => $this->status,
            'usage_bytes'    => $this->usageBytes,
            'created_at'     => $this->createdAt,
            'file_counts'    => $this->fileCounts->toArray(),
            'metadata'       => $this->metadata,
            'expires_after'  => $this->expiresAfter?->toArray(),
            'expires_at'     => $this->expiresAt,
            'last_active_at' => $this->lastActiveAt,
        ];
    }
}
PK     S%W]p÷3q  q  C  client/src/Responses/VectorStores/VectorStoreResponseFileCounts.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\VectorStores;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{in_progress: int, completed: int, failed: int, cancelled: int, total: int}>
 */
final class VectorStoreResponseFileCounts implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{in_progress: int, completed: int, failed: int, cancelled: int, total: int}>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public readonly int $inProgress,
        public readonly int $completed,
        public readonly int $failed,
        public readonly int $cancelled,
        public readonly int $total,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{in_progress: int, completed: int, failed: int, cancelled: int, total: int}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['in_progress'],
            $attributes['completed'],
            $attributes['cancelled'],
            $attributes['failed'],
            $attributes['total'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'in_progress' => $this->inProgress,
            'completed'   => $this->completed,
            'failed'      => $this->failed,
            'cancelled'   => $this->cancelled,
            'total'       => $this->total,
        ];
    }
}
PK     S%W]NüZH  H  =  client/src/Responses/VectorStores/VectorStoreListResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\VectorStores;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{object: string, data: array<int, array{id: string, object: string, created_at: int, name: ?string, usage_bytes: int, file_counts: array{in_progress: int, completed: int, failed: int, cancelled: int, total: int}, status: string, expires_after: ?array{anchor: string, days: int}, expires_at: ?int, last_active_at: ?int, metadata: array<string, string>}>, first_id: ?string, last_id: ?string, has_more: bool}>
 */
final class VectorStoreListResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{object: string, data: array<int, array{id: string, object: string, created_at: int, name: ?string, usage_bytes: int, file_counts: array{in_progress: int, completed: int, failed: int, cancelled: int, total: int}, status: string, expires_after: ?array{anchor: string, days: int}, expires_at: ?int, last_active_at: ?int, metadata: array<string, string>}>, first_id: ?string, last_id: ?string, has_more: bool}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<int, VectorStoreResponse>  $data
     */
    private function __construct(
        public readonly string $object,
        public readonly array $data,
        public readonly ?string $firstId,
        public readonly ?string $lastId,
        public readonly bool $hasMore,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{object: string, data: array<int, array{id: string, object: string, created_at: int, name: ?string, usage_bytes: int, file_counts: array{in_progress: int, completed: int, failed: int, cancelled: int, total: int}, status: string, expires_after: ?array{anchor: string, days: int}, expires_at: ?int, last_active_at: ?int, metadata: array<string, string>}>, first_id: ?string, last_id: ?string, has_more: bool}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        $data = array_map(fn (array $result): VectorStoreResponse => VectorStoreResponse::from(
            $result,
            $meta,
        ), $attributes['data']);

        return new self(
            $attributes['object'],
            $data,
            $attributes['first_id'],
            $attributes['last_id'],
            $attributes['has_more'],
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     *
     * @return array{object: string, data: array<int, mixed[]>, first_id: string|null, last_id: string|null, has_more: bool}
     */
    public function toArray(): array
    {
        return [
            'object' => $this->object,
            'data'   => array_map(
                static fn (VectorStoreResponse $response): array => $response->toArray(),
                $this->data,
            ),
            'first_id' => $this->firstId,
            'last_id'  => $this->lastId,
            'has_more' => $this->hasMore,
        ];
    }
}
PK     S%W]o-£î^  ^  E  client/src/Responses/VectorStores/VectorStoreResponseExpiresAfter.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\VectorStores;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{anchor: string, days: int}>
 */
final class VectorStoreResponseExpiresAfter implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{anchor: string, days: int}>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public readonly string $anchor,
        public readonly int $days,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{anchor: string, days: int}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['anchor'],
            $attributes['days'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'anchor' => $this->anchor,
            'days'   => $this->days,
        ];
    }
}
PK     S%W]êiXJ9  9  G  client/src/Responses/VectorStores/Files/VectorStoreFileListResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\VectorStores\Files;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{object: string, data: array<int, array{id: string, object: string, usage_bytes: int, created_at: int, vector_store_id: string, status: string, attributes: array<string, string>, last_error: ?array{code: string, message: string}}>, first_id: ?string, last_id: ?string, has_more: bool}>
 */
final class VectorStoreFileListResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{object: string, data: array<int, array{id: string, object: string, usage_bytes: int, created_at: int, vector_store_id: string, status: string, attributes: array<string, string>, last_error: ?array{code: string, message: string}}>, first_id: ?string, last_id: ?string, has_more: bool}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<int, VectorStoreFileResponse>  $data
     */
    private function __construct(
        public readonly string $object,
        public readonly array $data,
        public readonly ?string $firstId,
        public readonly ?string $lastId,
        public readonly bool $hasMore,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{object: string, data: array<int, array{id: string, object: string, usage_bytes: int, created_at: int, vector_store_id: string, status: string, attributes: array<string, string>, last_error: ?array{code: string, message: string}, chunking_strategy: array{type: 'static', static: array{max_chunk_size_tokens: int, chunk_overlap_tokens: int}}|array{type: 'other'}}>, first_id: ?string, last_id: ?string, has_more: bool}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        $data = array_map(fn (array $result): VectorStoreFileResponse => VectorStoreFileResponse::from(
            $result,
            $meta,
        ), $attributes['data']);

        return new self(
            $attributes['object'],
            $data,
            $attributes['first_id'],
            $attributes['last_id'],
            $attributes['has_more'],
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     *
     * @return array{object: string, data: array<int, array{id: string, object: string, usage_bytes: int, created_at: int, vector_store_id: string, status: string, attributes: array<string, string>, last_error: array{code: string, message: string}|null}>, first_id: string|null, last_id: string|null, has_more: bool}
     */
    public function toArray(): array
    {
        return [
            'object' => $this->object,
            'data'   => array_map(
                static fn (VectorStoreFileResponse $response): array => $response->toArray(),
                $this->data,
            ),
            'first_id' => $this->firstId,
            'last_id'  => $this->lastId,
            'has_more' => $this->hasMore,
        ];
    }
}
PK     S%W]—tN·q  q  Y  client/src/Responses/VectorStores/Files/VectorStoreFileResponseChunkingStrategyStatic.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\VectorStores\Files;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{type: 'static', static: array{max_chunk_size_tokens: int, chunk_overlap_tokens: int}}>
 */
final class VectorStoreFileResponseChunkingStrategyStatic implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{type: 'static', static: array{max_chunk_size_tokens: int, chunk_overlap_tokens: int}}>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'static'  $type
     */
    private function __construct(
        public readonly string $type,
        public readonly int $maxChunkSizeTokens,
        public readonly int $chunkOverlapTokens,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{type: 'static', static: array{max_chunk_size_tokens: int, chunk_overlap_tokens: int}}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['type'],
            $attributes['static']['max_chunk_size_tokens'],
            $attributes['static']['chunk_overlap_tokens'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type'   => $this->type,
            'static' => [
                'max_chunk_size_tokens' => $this->maxChunkSizeTokens,
                'chunk_overlap_tokens'  => $this->chunkOverlapTokens,
            ],
        ];
    }
}
PK     S%W]ý˜®    C  client/src/Responses/VectorStores/Files/VectorStoreFileResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\VectorStores\Files;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{id: string, object: string, usage_bytes: int, created_at: int, vector_store_id: string, status: string, attributes: array<string, string>, last_error: ?array{code: string, message: string}, chunking_strategy: array{type: 'static', static: array{max_chunk_size_tokens: int, chunk_overlap_tokens: int}}|array{type: 'other'}}>
 */
final class VectorStoreFileResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{id: string, object: string, usage_bytes: int, created_at: int, vector_store_id: string, status: string, attributes: array<string, string>, last_error: ?array{code: string, message: string}, chunking_strategy: array{type: 'static', static: array{max_chunk_size_tokens: int, chunk_overlap_tokens: int}}|array{type: 'other'}}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<string, string>  $attributes
     */
    private function __construct(
        public readonly string $id,
        public readonly string $object,
        public readonly int $usageBytes,
        public readonly int $createdAt,
        public readonly string $vectorStoreId,
        public readonly string $status,
        public readonly array $attributes,
        public readonly ?VectorStoreFileResponseLastError $lastError,
        public readonly VectorStoreFileResponseChunkingStrategyStatic|VectorStoreFileResponseChunkingStrategyOther $chunkingStrategy,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{id: string, object: string, usage_bytes: int, created_at: int, vector_store_id: string, status: string, attributes: ?array<string, string>, last_error: ?array{code: string, message: string}, chunking_strategy: array{type: 'static', static: array{max_chunk_size_tokens: int, chunk_overlap_tokens: int}}|array{type: 'other'}}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            $attributes['id'],
            $attributes['object'],
            $attributes['usage_bytes'],
            $attributes['created_at'],
            $attributes['vector_store_id'],
            $attributes['status'],
            $attributes['attributes'] ?? [],
            isset($attributes['last_error']) ? VectorStoreFileResponseLastError::from($attributes['last_error']) : null,
            $attributes['chunking_strategy']['type'] === 'static' ? VectorStoreFileResponseChunkingStrategyStatic::from($attributes['chunking_strategy']) : VectorStoreFileResponseChunkingStrategyOther::from($attributes['chunking_strategy']),
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'                => $this->id,
            'object'            => $this->object,
            'usage_bytes'       => $this->usageBytes,
            'created_at'        => $this->createdAt,
            'vector_store_id'   => $this->vectorStoreId,
            'status'            => $this->status,
            'attributes'        => $this->attributes,
            'last_error'        => $this->lastError instanceof VectorStoreFileResponseLastError ? $this->lastError->toArray() : null,
            'chunking_strategy' => $this->chunkingStrategy->toArray(),
        ];
    }
}
PK     S%W]¢}I 
  
  X  client/src/Responses/VectorStores/Files/VectorStoreFileResponseChunkingStrategyOther.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\VectorStores\Files;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{type: 'other'}>
 */
final class VectorStoreFileResponseChunkingStrategyOther implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{type: 'other'}>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'other'  $type
     */
    private function __construct(
        public readonly string $type,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{type: 'other'}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type' => $this->type,
        ];
    }
}
PK     S%W]2ý{]y  y  L  client/src/Responses/VectorStores/Files/VectorStoreFileResponseLastError.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\VectorStores\Files;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{code: string, message: string}>
 */
final class VectorStoreFileResponseLastError implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{code: string, message: string}>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public readonly string $code,
        public readonly string $message,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{code: string, message: string}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['code'],
            $attributes['message'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'code'    => $this->code,
            'message' => $this->message,
        ];
    }
}
PK     S%W]W=…«5  5  I  client/src/Responses/VectorStores/Files/VectorStoreFileDeleteResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\VectorStores\Files;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{id: string, object: string, deleted: bool}>
 */
final class VectorStoreFileDeleteResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{id: string, object: string, deleted: bool}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly string $id,
        public readonly string $object,
        public readonly bool $deleted,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{id: string, object: string, deleted: bool}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            $attributes['id'],
            $attributes['object'],
            $attributes['deleted'],
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'      => $this->id,
            'object'  => $this->object,
            'deleted' => $this->deleted,
        ];
    }
}
PK     S%W]è= ^
  
  N  client/src/Responses/VectorStores/FileBatches/VectorStoreFileBatchResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\VectorStores\FileBatches;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Responses\VectorStores\VectorStoreResponseFileCounts;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{id: string, object: string, created_at: int, vector_store_id: string, status: string, file_counts: array{in_progress: int, completed: int, failed: int, cancelled: int, total: int}}>
 */
final class VectorStoreFileBatchResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{id: string, object: string, created_at: int, vector_store_id: string, status: string, file_counts: array{in_progress: int, completed: int, failed: int, cancelled: int, total: int}}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly string $id,
        public readonly string $object,
        public readonly int $createdAt,
        public readonly string $vectorStoreId,
        public readonly string $status,
        public readonly VectorStoreResponseFileCounts $fileCounts,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{id: string, object: string, created_at: int, vector_store_id: string, status: string, file_counts: array{in_progress: int, completed: int, failed: int, cancelled: int, total: int}}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            $attributes['id'],
            $attributes['object'],
            $attributes['created_at'],
            $attributes['vector_store_id'],
            $attributes['status'],
            VectorStoreResponseFileCounts::from($attributes['file_counts']),
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'              => $this->id,
            'object'          => $this->object,
            'created_at'      => $this->createdAt,
            'vector_store_id' => $this->vectorStoreId,
            'status'          => $this->status,
            'file_counts'     => $this->fileCounts->toArray(),
        ];
    }
}
PK     S%W]ÂçÉ	  É	  9  client/src/Responses/FineTuning/ListJobEventsResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\FineTuning;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{object: string, data: array<int, array{object: string, id: string, created_at: int, level: string, message: string, data: array{step: int, train_loss: float, train_mean_token_accuracy: float}|null, type: string}>, has_more: bool}>
 */
final class ListJobEventsResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{object: string, data: array<int, array{object: string, id: string, created_at: int, level: string, message: string, data: array{step: int, train_loss: float, train_mean_token_accuracy: float}|null, type: string}>, has_more: bool}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<int, ListJobEventsResponseEvent>  $data
     */
    private function __construct(
        public readonly string $object,
        public readonly array $data,
        public readonly bool $hasMore,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{object: string, data: array<int, array{object: string, id: string, created_at: int, level: string, message: string, data: array{step: int, train_loss: float, train_mean_token_accuracy: float}|null, type: string}>, has_more: bool}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        $data = array_map(fn (array $result): ListJobEventsResponseEvent => ListJobEventsResponseEvent::from(
            $result
        ), $attributes['data']);

        return new self(
            $attributes['object'],
            $data,
            $attributes['has_more'],
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'object' => $this->object,
            'data'   => array_map(
                static fn (ListJobEventsResponseEvent $response): array => $response->toArray(),
                $this->data,
            ),
            'has_more' => $this->hasMore,
        ];
    }
}
PK     S%W]ù¦Qù’  ’  7  client/src/Responses/FineTuning/RetrieveJobResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\FineTuning;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{id: string, object: string, model: string, created_at: int, finished_at: ?int, fine_tuned_model: ?string, hyperparameters: array{n_epochs: int|string, batch_size: int|string|null, learning_rate_multiplier: float|string|null}, organization_id: string, result_files: array<int, string>, status: string, validation_file: ?string, training_file: string, trained_tokens: ?int, error: ?array{code: string, param: ?string, message: string}}>
 */
final class RetrieveJobResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{id: string, object: string, model: string, created_at: int, finished_at: ?int, fine_tuned_model: ?string, hyperparameters: array{n_epochs: int|string, batch_size: int|string|null, learning_rate_multiplier: float|string|null}, organization_id: string, result_files: array<int, string>, status: string, validation_file: ?string, training_file: string, trained_tokens: ?int, error: ?array{code: string, param: ?string, message: string}}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<int, string>  $resultFiles
     */
    private function __construct(
        public readonly string $id,
        public readonly string $object,
        public readonly string $model,
        public readonly int $createdAt,
        public readonly ?int $finishedAt,
        public readonly ?string $fineTunedModel,
        public readonly RetrieveJobResponseHyperparameters $hyperparameters,
        public readonly string $organizationId,
        public readonly array $resultFiles,
        public readonly string $status,
        public readonly ?string $validationFile,
        public readonly string $trainingFile,
        public readonly ?int $trainedTokens,
        public readonly ?RetrieveJobResponseError $error,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{id: string, object: string, model: string, created_at: int, finished_at: ?int, fine_tuned_model: ?string, hyperparameters: array{n_epochs: int|string, batch_size: int|string|null, learning_rate_multiplier: float|string|null}, organization_id: string, result_files: array<int, string>, status: string, validation_file: ?string, training_file: string, trained_tokens: ?int, error: ?array{code?: string, param?: ?string, message?: string}}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            $attributes['id'],
            $attributes['object'],
            $attributes['model'],
            $attributes['created_at'],
            $attributes['finished_at'],
            $attributes['fine_tuned_model'],
            RetrieveJobResponseHyperparameters::from($attributes['hyperparameters']),
            $attributes['organization_id'],
            $attributes['result_files'],
            $attributes['status'],
            $attributes['validation_file'],
            $attributes['training_file'],
            $attributes['trained_tokens'],
            (
                isset($attributes['error']) &&
                isset($attributes['error']['code']) &&
                isset($attributes['error']['param']) &&
                isset($attributes['error']['message'])
            ) ? RetrieveJobResponseError::from($attributes['error']) : null,
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'               => $this->id,
            'object'           => $this->object,
            'model'            => $this->model,
            'created_at'       => $this->createdAt,
            'finished_at'      => $this->finishedAt,
            'fine_tuned_model' => $this->fineTunedModel,
            'hyperparameters'  => $this->hyperparameters->toArray(),
            'organization_id'  => $this->organizationId,
            'result_files'     => $this->resultFiles,
            'status'           => $this->status,
            'validation_file'  => $this->validationFile,
            'training_file'    => $this->trainingFile,
            'trained_tokens'   => $this->trainedTokens,
            'error'            => $this->error?->toArray(),
        ];
    }
}
PK     S%W]dq¦ã  ã  >  client/src/Responses/FineTuning/ListJobEventsResponseEvent.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\FineTuning;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Enums\FineTuning\FineTuningEventLevel;
use OpenAI\Responses\Concerns\ArrayAccessible;

/**
 * @implements ResponseContract<array{object: string, id: string, created_at: int, level: string, message: string, data: array{step: int, train_loss: float, train_mean_token_accuracy: float}|null, type: string}>
 */
final class ListJobEventsResponseEvent implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{object: string, id: string, created_at: int, level: string, message: string, data: array{step: int, train_loss: float, train_mean_token_accuracy: float}|null, type: string}>
     */
    use ArrayAccessible;

    private function __construct(
        public readonly string $object,
        public readonly string $id,
        public readonly int $createdAt,
        public readonly FineTuningEventLevel $level,
        public readonly string $message,
        public readonly ?ListJobEventsResponseEventData $data,
        public readonly string $type,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{object: string, id: string, created_at: int, level: string, message: string, data: array{step: int, train_loss: float, train_mean_token_accuracy: float}|null, type: string}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['object'],
            $attributes['id'],
            $attributes['created_at'],
            FineTuningEventLevel::from($attributes['level']),
            $attributes['message'],
            $attributes['data'] ? ListJobEventsResponseEventData::from($attributes['data']) : null,
            $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'object'     => $this->object,
            'id'         => $this->id,
            'created_at' => $this->createdAt,
            'level'      => $this->level->value,
            'message'    => $this->message,
            'data'       => $this->data?->toArray(),
            'type'       => $this->type,
        ];
    }
}
PK     S%W]Ýè˜Ë  Ë  4  client/src/Responses/FineTuning/ListJobsResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\FineTuning;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{object: string, data: array<int, array{id: string, object: string, model: string, created_at: int, finished_at: ?int, fine_tuned_model: ?string, hyperparameters: array{n_epochs: int|string, batch_size: int|string|null, learning_rate_multiplier: float|string|null}, organization_id: string, result_files: array<int, string>, status: string, validation_file: ?string, training_file: string, trained_tokens: ?int, error: ?array{code: string, param: ?string, message: string}}>, has_more: bool}>
 */
final class ListJobsResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{object: string, data: array<int, array{id: string, object: string, model: string, created_at: int, finished_at: ?int, fine_tuned_model: ?string, hyperparameters: array{n_epochs: int|string, batch_size: int|string|null, learning_rate_multiplier: float|string|null}, organization_id: string, result_files: array<int, string>, status: string, validation_file: ?string, training_file: string, trained_tokens: ?int, error: ?array{code: string, param: ?string, message: string}}>, has_more: bool}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<int, RetrieveJobResponse>  $data
     */
    private function __construct(
        public readonly string $object,
        public readonly array $data,
        public readonly bool $hasMore,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{object: string, data: array<int, array{id: string, object: string, model: string, created_at: int, finished_at: ?int, fine_tuned_model: ?string, hyperparameters: array{n_epochs: int|string, batch_size: int|string|null, learning_rate_multiplier: float|string|null}, organization_id: string, result_files: array<int, string>, status: string, validation_file: ?string, training_file: string, trained_tokens: ?int, error: ?array{code: string, param: ?string, message: string}}>, has_more: bool}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        $data = array_map(fn (array $result): RetrieveJobResponse => RetrieveJobResponse::from(
            $result,
            $meta,
        ), $attributes['data']);

        return new self(
            $attributes['object'],
            $data,
            $attributes['has_more'],
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'object' => $this->object,
            'data'   => array_map(
                static fn (RetrieveJobResponse $response): array => $response->toArray(),
                $this->data,
            ),
            'has_more' => $this->hasMore,
        ];
    }
}
PK     S%W]NsNô  ô  F  client/src/Responses/FineTuning/RetrieveJobResponseHyperparameters.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\FineTuning;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;

/**
 * @implements ResponseContract<array{n_epochs: int|string, batch_size: int|string|null, learning_rate_multiplier: float|string|null}>
 */
final class RetrieveJobResponseHyperparameters implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{n_epochs: int|string, batch_size: int|string|null, learning_rate_multiplier: float|string|null}>
     */
    use ArrayAccessible;

    private function __construct(
        public readonly int|string $nEpochs,
        public readonly int|string|null $batchSize,
        public readonly float|string|null $learningRateMultiplier,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{n_epochs: int|string, batch_size: int|string|null, learning_rate_multiplier: float|string|null}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['n_epochs'],
            $attributes['batch_size'],
            $attributes['learning_rate_multiplier'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'n_epochs'                 => $this->nEpochs,
            'batch_size'               => $this->batchSize,
            'learning_rate_multiplier' => $this->learningRateMultiplier,
        ];
    }
}
PK     S%W]WÀáÈ  È  <  client/src/Responses/FineTuning/RetrieveJobResponseError.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\FineTuning;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;

/**
 * @implements ResponseContract<array{code: string, param: ?string, message: string}>
 */
final class RetrieveJobResponseError implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{code: string, param: ?string, message: string}>
     */
    use ArrayAccessible;

    private function __construct(
        public readonly string $code,
        public readonly ?string $param,
        public readonly string $message,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{code: string, param: ?string, message: string}  $attributes
     */
    public static function from(array $attributes): ?self
    {
        return new self(
            $attributes['code'],
            $attributes['param'],
            $attributes['message'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'code'    => $this->code,
            'param'   => $this->param,
            'message' => $this->message,
        ];
    }
}
PK     S%W]ˆÐS†m  m  B  client/src/Responses/FineTuning/ListJobEventsResponseEventData.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\FineTuning;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;

/**
 * @implements ResponseContract<array{step: int, train_loss: float, train_mean_token_accuracy: float}>
 */
final class ListJobEventsResponseEventData implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{step: int, train_loss: float, train_mean_token_accuracy: float}>
     */
    use ArrayAccessible;

    private function __construct(
        public readonly int $step,
        public readonly float $trainLoss,
        public readonly float $trainMeanTokenAccuracy,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{step: int, train_loss: float, train_mean_token_accuracy: float}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['step'],
            $attributes['train_loss'],
            $attributes['train_mean_token_accuracy'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'step'                      => $this->step,
            'train_loss'                => $this->trainLoss,
            'train_mean_token_accuracy' => $this->trainMeanTokenAccuracy,
        ];
    }
}
PK     S%W]ŽËÊÅ    ;  client/src/Responses/Embeddings/CreateResponseEmbedding.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Embeddings;

final class CreateResponseEmbedding
{
    /**
     * @param  array<int, float>  $embedding
     */
    private function __construct(
        public readonly string $object,
        public readonly ?int $index,
        public readonly array $embedding,
    ) {}

    /**
     * @param  array{object: string, index?: int, embedding: array<int, float>}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['object'],
            $attributes['index'] ?? null,
            $attributes['embedding'],
        );
    }

    /**
     * @return array{object: string, index?: int, embedding: array<int, float>}
     */
    public function toArray(): array
    {
        return array_filter([
            'object'    => $this->object,
            'index'     => $this->index,
            'embedding' => $this->embedding,
        ], fn (mixed $value): bool => ! is_null($value));
    }
}
PK     S%W]¨|-9
  9
  2  client/src/Responses/Embeddings/CreateResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Embeddings;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{object: string, model?: string|null, data: array<int, array{object: string, embedding: array<int, float>, index?: int}>, usage?: array{prompt_tokens: int, total_tokens: int}}>
 */
final class CreateResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{object: string, model?: string|null, data: array<int, array{object: string, embedding: array<int, float>, index?: int}>, usage?: array{prompt_tokens: int, total_tokens: int}}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<int, CreateResponseEmbedding>  $embeddings
     */
    private function __construct(
        public readonly string $object,
        public readonly ?string $model,
        public readonly array $embeddings,
        public readonly ?CreateResponseUsage $usage,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{object: string, model?: string|null, data: array<int, array{object: string, embedding: array<int, float>, index?: int}>, usage?: array{prompt_tokens: int, total_tokens: int}}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        $embeddings = array_map(fn (array $result): CreateResponseEmbedding => CreateResponseEmbedding::from(
            $result
        ), $attributes['data']);

        return new self(
            $attributes['object'],
            $attributes['model'] ?? null,
            $embeddings,
            isset($attributes['usage']) ? CreateResponseUsage::from($attributes['usage']) : null,
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return array_filter([
            'object' => $this->object,
            'model'  => $this->model ?? null,
            'data'   => array_map(
                static fn (CreateResponseEmbedding $result): array => $result->toArray(),
                $this->embeddings,
            ),
            'usage' => $this->usage?->toArray(),
        ], fn (mixed $value): bool => ! is_null($value));
    }
}
PK     S%W]ÝAEƒ    7  client/src/Responses/Embeddings/CreateResponseUsage.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Embeddings;

final class CreateResponseUsage
{
    private function __construct(
        public readonly int $promptTokens,
        public readonly int $totalTokens,
    ) {}

    /**
     * @param  array{prompt_tokens: int, total_tokens: int}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['prompt_tokens'],
            $attributes['total_tokens'],
        );
    }

    /**
     * @return array{prompt_tokens: int, total_tokens: int}
     */
    public function toArray(): array
    {
        return [
            'prompt_tokens' => $this->promptTokens,
            'total_tokens'  => $this->totalTokens,
        ];
    }
}
PK     S%W]³#¹zw  w  @  client/src/Responses/Responses/ToolChoice/FunctionToolChoice.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\ToolChoice;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type FunctionToolChoiceType array{name: string, type: 'function'}
 *
 * @implements ResponseContract<FunctionToolChoiceType>
 */
final class FunctionToolChoice implements ResponseContract
{
    /**
     * @use ArrayAccessible<FunctionToolChoiceType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'function'  $type
     */
    private function __construct(
        public readonly string $name,
        public readonly string $type,
    ) {}

    /**
     * @param  FunctionToolChoiceType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            name: $attributes['name'],
            type: $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'name' => $this->name,
            'type' => $this->type,
        ];
    }
}
PK     S%W]A@ì M  M  >  client/src/Responses/Responses/ToolChoice/HostedToolChoice.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\ToolChoice;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type HostedToolChoiceType array{type: 'file_search'|'web_search_preview'|'computer_use_preview'}
 *
 * @implements ResponseContract<HostedToolChoiceType>
 */
final class HostedToolChoice implements ResponseContract
{
    /**
     * @use ArrayAccessible<HostedToolChoiceType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'file_search'|'web_search_preview'|'computer_use_preview'  $type
     */
    private function __construct(
        public readonly string $type,
    ) {}

    /**
     * @param  HostedToolChoiceType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            type: $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type' => $this->type,
        ];
    }
}
PK     S%W]Ûç­þ}  }  I  client/src/Responses/Responses/Input/ComputerToolCallOutputScreenshot.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Input;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type ComputerToolCallOutputScreenshotType array{type: 'computer_screenshot', file_id: string, image_url: string}
 *
 * @implements ResponseContract<ComputerToolCallOutputScreenshotType>
 */
final class ComputerToolCallOutputScreenshot implements ResponseContract
{
    /**
     * @use ArrayAccessible<ComputerToolCallOutputScreenshotType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'computer_screenshot'  $type
     */
    private function __construct(
        public readonly string $type,
        public readonly string $fileId,
        public readonly string $imageUrl,
    ) {}

    /**
     * @param  ComputerToolCallOutputScreenshotType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            type: $attributes['type'],
            fileId: $attributes['file_id'],
            imageUrl: $attributes['image_url'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type'      => $this->type,
            'file_id'   => $this->fileId,
            'image_url' => $this->imageUrl,
        ];
    }
}
PK     S%W]ÏØŽE½
  ½
  5  client/src/Responses/Responses/Input/InputMessage.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Input;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-import-type ContentInputTextType from InputMessageContentInputText
 * @phpstan-import-type ContentInputImageType from InputMessageContentInputImage
 * @phpstan-import-type ContentInputFileType from InputMessageContentInputFile
 *
 * @phpstan-type InputMessageType array{content: array<int, ContentInputTextType|ContentInputImageType|ContentInputFileType>, id: string, role: 'user'|'system'|'developer', status: 'in_progress'|'completed'|'incomplete', type: 'message'}
 *
 * @implements ResponseContract<InputMessageType>
 */
final class InputMessage implements ResponseContract
{
    /**
     * @use ArrayAccessible<InputMessageType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  array<int, InputMessageContentInputText|InputMessageContentInputImage|InputMessageContentInputFile>  $content
     * @param  'user'|'system'|'developer'  $role
     * @param  'in_progress'|'completed'|'incomplete'  $status
     * @param  'message'  $type
     */
    private function __construct(
        public readonly array $content,
        public readonly string $id,
        public readonly string $role,
        public readonly string $status,
        public readonly string $type,
    ) {}

    /**
     * @param  InputMessageType  $attributes
     */
    public static function from(array $attributes): self
    {
        $content = array_map(
            fn (array $item): InputMessageContentInputText|InputMessageContentInputImage|InputMessageContentInputFile => match ($item['type']) {
                'input_text'  => InputMessageContentInputText::from($item),
                'input_image' => InputMessageContentInputImage::from($item),
                'input_file'  => InputMessageContentInputFile::from($item),
            },
            $attributes['content'],
        );

        return new self(
            content: $content,
            id: $attributes['id'],
            role: $attributes['role'],
            status: $attributes['status'],
            type: $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'content' => array_map(
                fn (InputMessageContentInputText|InputMessageContentInputImage|InputMessageContentInputFile $item): array => $item->toArray(),
                $this->content,
            ),
            'id'     => $this->id,
            'role'   => $this->role,
            'status' => $this->status,
            'type'   => $this->type,
        ];
    }
}
PK     S%W]—œXRâ  â  @  client/src/Responses/Responses/Input/AcknowledgedSafetyCheck.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Input;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type AcknowledgedSafetyCheckType array{code: string, id: string, message: string}
 *
 * @implements ResponseContract<AcknowledgedSafetyCheckType>
 */
final class AcknowledgedSafetyCheck implements ResponseContract
{
    /**
     * @use ArrayAccessible<AcknowledgedSafetyCheckType>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public readonly string $code,
        public readonly string $id,
        public readonly string $message,
    ) {}

    /**
     * @param  AcknowledgedSafetyCheckType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            code: $attributes['code'],
            id: $attributes['id'],
            message: $attributes['message'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'code'    => $this->code,
            'id'      => $this->id,
            'message' => $this->message,
        ];
    }
}
PK     S%W]n—ßEw  w  E  client/src/Responses/Responses/Input/InputMessageContentInputText.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Input;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type ContentInputTextType array{text: string, type: 'input_text'}
 *
 * @implements ResponseContract<ContentInputTextType>
 */
final class InputMessageContentInputText implements ResponseContract
{
    /**
     * @use ArrayAccessible<ContentInputTextType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'input_text'  $type
     */
    private function __construct(
        public readonly string $text,
        public readonly string $type
    ) {}

    /**
     * @param  ContentInputTextType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            text: $attributes['text'],
            type: $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'text' => $this->text,
            'type' => $this->type,
        ];
    }
}
PK     S%W]³À>ž  ž  ?  client/src/Responses/Responses/Input/FunctionToolCallOutput.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Input;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type FunctionToolCallOutputType array{call_id: string, id: string, output: string, type: 'function_call_output', status: 'in_progress'|'completed'|'incompleted'}
 *
 * @implements ResponseContract<FunctionToolCallOutputType>
 */
final class FunctionToolCallOutput implements ResponseContract
{
    /**
     * @use ArrayAccessible<FunctionToolCallOutputType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'function_call_output'  $type
     * @param  'in_progress'|'completed'|'incompleted'  $status
     */
    private function __construct(
        public readonly string $callId,
        public readonly string $id,
        public readonly string $output,
        public readonly string $type,
        public readonly string $status,
    ) {}

    /**
     * @param  FunctionToolCallOutputType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            callId: $attributes['call_id'],
            id: $attributes['id'],
            output: $attributes['output'],
            type: $attributes['type'],
            status: $attributes['status'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'call_id' => $this->callId,
            'id'      => $this->id,
            'output'  => $this->output,
            'type'    => $this->type,
            'status'  => $this->status,
        ];
    }
}
PK     S%W]ƒ¸¹MÙ
  Ù
  ?  client/src/Responses/Responses/Input/ComputerToolCallOutput.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Input;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-import-type ComputerToolCallOutputScreenshotType from ComputerToolCallOutputScreenshot
 * @phpstan-import-type AcknowledgedSafetyCheckType from AcknowledgedSafetyCheck
 *
 * @phpstan-type ComputerToolCallOutputType array{call_id: string, id: string, output: ComputerToolCallOutputScreenshotType, type: 'computer_call_output', acknowledged_safety_checks: array<int, AcknowledgedSafetyCheckType>, status: 'in_progress'|'completed'|'incomplete'}
 *
 * @implements ResponseContract<ComputerToolCallOutputType>
 */
final class ComputerToolCallOutput implements ResponseContract
{
    /**
     * @use ArrayAccessible<ComputerToolCallOutputType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'computer_call_output'  $type
     * @param  array<int, AcknowledgedSafetyCheck>  $acknowledgedSafetyChecks
     * @param  'in_progress'|'completed'|'incomplete'  $status
     */
    private function __construct(
        public readonly string $callId,
        public readonly string $id,
        public readonly ComputerToolCallOutputScreenshot $output,
        public readonly string $type,
        public readonly array $acknowledgedSafetyChecks,
        public readonly string $status,
    ) {}

    /**
     * @param  ComputerToolCallOutputType  $attributes
     */
    public static function from(array $attributes): self
    {
        $acknowledgedSafetyChecks = array_map(
            fn (array $acknowledgedSafetyCheck) => AcknowledgedSafetyCheck::from($acknowledgedSafetyCheck),
            $attributes['acknowledged_safety_checks'],
        );

        return new self(
            callId: $attributes['call_id'],
            id: $attributes['id'],
            output: ComputerToolCallOutputScreenshot::from($attributes['output']),
            type: $attributes['type'],
            acknowledgedSafetyChecks: $acknowledgedSafetyChecks,
            status: $attributes['status'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'call_id'                    => $this->callId,
            'id'                         => $this->id,
            'output'                     => $this->output->toArray(),
            'type'                       => $this->type,
            'acknowledged_safety_checks' => array_map(
                fn (AcknowledgedSafetyCheck $acknowledgedSafetyCheck) => $acknowledgedSafetyCheck->toArray(),
                $this->acknowledgedSafetyChecks,
            ),
            'status' => $this->status,
        ];
    }
}
PK     S%W]ÖzÇ  Ç  F  client/src/Responses/Responses/Input/InputMessageContentInputImage.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Input;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type ContentInputImageType array{type: 'input_image', detail: string, file_id: string|null, image_url: string|null}
 *
 * @implements ResponseContract<ContentInputImageType>
 */
final class InputMessageContentInputImage implements ResponseContract
{
    /**
     * @use ArrayAccessible<ContentInputImageType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'input_image'  $type
     */
    private function __construct(
        public readonly string $type,
        public readonly string $detail,
        public readonly ?string $fileId,
        public readonly ?string $imageUrl,
    ) {}

    /**
     * @param  ContentInputImageType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            type: $attributes['type'],
            detail: $attributes['detail'],
            fileId: $attributes['file_id'],
            imageUrl: $attributes['image_url'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type'      => $this->type,
            'detail'    => $this->detail,
            'file_id'   => $this->fileId,
            'image_url' => $this->imageUrl,
        ];
    }
}
PK     S%W]tª}Õ¾  ¾  E  client/src/Responses/Responses/Input/InputMessageContentInputFile.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Input;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type ContentInputFileType array{type: 'input_file', file_data: string, file_id: string, filename: string}
 *
 * @implements ResponseContract<ContentInputFileType>
 */
final class InputMessageContentInputFile implements ResponseContract
{
    /**
     * @use ArrayAccessible<ContentInputFileType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'input_file'  $type
     */
    private function __construct(
        public readonly string $type,
        public readonly string $fileData,
        public readonly string $fileId,
        public readonly string $filename,
    ) {}

    /**
     * @param  ContentInputFileType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            type: $attributes['type'],
            fileData: $attributes['file_data'],
            fileId: $attributes['file_id'],
            filename: $attributes['filename'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type'      => $this->type,
            'file_data' => $this->fileData,
            'file_id'   => $this->fileId,
            'filename'  => $this->filename,
        ];
    }
}
PK     S%W]/"–”t  t  @  client/src/Responses/Responses/Streaming/ImageGenerationPart.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Streaming;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type ImageGenerationPartType array{output_index: int, item_id: string, sequence_number: int}
 *
 * @implements ResponseContract<ImageGenerationPartType>
 */
final class ImageGenerationPart implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<ImageGenerationPartType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly int $outputIndex,
        public readonly string $itemId,
        public readonly int $sequenceNumber,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  ImageGenerationPartType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            outputIndex: $attributes['output_index'],
            itemId: $attributes['item_id'],
            sequenceNumber: $attributes['sequence_number'],
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'output_index'    => $this->outputIndex,
            'item_id'         => $this->itemId,
            'sequence_number' => $this->sequenceNumber,
        ];
    }
}
PK     S%W]…–çÉ    E  client/src/Responses/Responses/Streaming/ReasoningSummaryTextDone.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Streaming;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type ReasoningSummaryTextDoneType array{item_id: string, output_index: int, summary_index: int, text: string}
 *
 * @implements ResponseContract<ReasoningSummaryTextDoneType>
 */
final class ReasoningSummaryTextDone implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<ReasoningSummaryTextDoneType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly string $itemId,
        public readonly int $outputIndex,
        public readonly int $summaryIndex,
        public readonly string $text,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  ReasoningSummaryTextDoneType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            itemId: $attributes['item_id'],
            outputIndex: $attributes['output_index'],
            summaryIndex: $attributes['summary_index'],
            text: $attributes['text'],
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'item_id'       => $this->itemId,
            'output_index'  => $this->outputIndex,
            'summary_index' => $this->summaryIndex,
            'text'          => $this->text,
        ];
    }
}
PK     S%W]ZÕîQ  Q  D  client/src/Responses/Responses/Streaming/CodeInterpreterCodeDone.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Streaming;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type CodeInterpreterCodeDoneType array{code: string, item_id: string, output_index: int}
 *
 * @implements ResponseContract<CodeInterpreterCodeDoneType>
 */
final class CodeInterpreterCodeDone implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<CodeInterpreterCodeDoneType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly string $code,
        public readonly string $itemId,
        public readonly int $outputIndex,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  CodeInterpreterCodeDoneType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            code: $attributes['code'],
            itemId: $attributes['item_id'],
            outputIndex: $attributes['output_index'],
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'code'         => $this->code,
            'item_id'      => $this->itemId,
            'output_index' => $this->outputIndex,
        ];
    }
}
PK     S%W]¦OkÒ  Ò  ;  client/src/Responses/Responses/Streaming/OutputTextDone.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Streaming;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type OutputTextDoneType array{content_index: int, item_id: string, output_index: int, text: string}
 *
 * @implements ResponseContract<OutputTextDoneType>
 */
final class OutputTextDone implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<OutputTextDoneType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly int $contentIndex,
        public readonly string $itemId,
        public readonly int $outputIndex,
        public readonly string $text,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  OutputTextDoneType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            contentIndex: $attributes['content_index'],
            itemId: $attributes['item_id'],
            outputIndex: $attributes['output_index'],
            text: $attributes['text'],
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'content_index' => $this->contentIndex,
            'item_id'       => $this->itemId,
            'output_index'  => $this->outputIndex,
            'text'          => $this->text,
        ];
    }
}
PK     S%W]Ä[  [  E  client/src/Responses/Responses/Streaming/CodeInterpreterCodeDelta.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Streaming;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type CodeInterpreterCodeDeltaType array{delta: string, item_id: string, output_index: int}
 *
 * @implements ResponseContract<CodeInterpreterCodeDeltaType>
 */
final class CodeInterpreterCodeDelta implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<CodeInterpreterCodeDeltaType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly string $delta,
        public readonly string $itemId,
        public readonly int $outputIndex,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  CodeInterpreterCodeDeltaType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            delta: $attributes['delta'],
            itemId: $attributes['item_id'],
            outputIndex: $attributes['output_index'],
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'delta'        => $this->delta,
            'item_id'      => $this->itemId,
            'output_index' => $this->outputIndex,
        ];
    }
}
PK     S%W]m|‰  ‰  7  client/src/Responses/Responses/Streaming/OutputItem.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Streaming;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Responses\Responses\Output\OutputCodeInterpreterToolCall;
use OpenAI\Responses\Responses\Output\OutputComputerToolCall;
use OpenAI\Responses\Responses\Output\OutputFileSearchToolCall;
use OpenAI\Responses\Responses\Output\OutputFunctionToolCall;
use OpenAI\Responses\Responses\Output\OutputImageGenerationToolCall;
use OpenAI\Responses\Responses\Output\OutputMcpApprovalRequest;
use OpenAI\Responses\Responses\Output\OutputMcpCall;
use OpenAI\Responses\Responses\Output\OutputMcpListTools;
use OpenAI\Responses\Responses\Output\OutputMessage;
use OpenAI\Responses\Responses\Output\OutputReasoning;
use OpenAI\Responses\Responses\Output\OutputWebSearchToolCall;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-import-type OutputComputerToolCallType from OutputComputerToolCall
 * @phpstan-import-type OutputFileSearchToolCallType from OutputFileSearchToolCall
 * @phpstan-import-type OutputFunctionToolCallType from OutputFunctionToolCall
 * @phpstan-import-type OutputMessageType from OutputMessage
 * @phpstan-import-type OutputReasoningType from OutputReasoning
 * @phpstan-import-type OutputWebSearchToolCallType from OutputWebSearchToolCall
 * @phpstan-import-type OutputImageGenerationToolCallType from OutputImageGenerationToolCall
 * @phpstan-import-type OutputMcpListToolsType from OutputMcpListTools
 * @phpstan-import-type OutputMcpApprovalRequestType from OutputMcpApprovalRequest
 * @phpstan-import-type OutputMcpCallType from OutputMcpCall
 * @phpstan-import-type OutputCodeInterpreterToolCallType from OutputCodeInterpreterToolCall
 *
 * @phpstan-type OutputItemType array{item: OutputCodeInterpreterToolCallType|OutputComputerToolCallType|OutputFileSearchToolCallType|OutputFunctionToolCallType|OutputMessageType|OutputReasoningType|OutputWebSearchToolCallType|OutputMcpListToolsType|OutputMcpApprovalRequestType|OutputMcpCallType|OutputImageGenerationToolCallType, output_index: int}
 *
 * @implements ResponseContract<OutputItemType>
 */
final class OutputItem implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<OutputItemType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly int $outputIndex,
        public readonly OutputMessage|OutputCodeInterpreterToolCall|OutputFileSearchToolCall|OutputFunctionToolCall|OutputWebSearchToolCall|OutputComputerToolCall|OutputReasoning|OutputMcpListTools|OutputMcpApprovalRequest|OutputMcpCall|OutputImageGenerationToolCall $item,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  OutputItemType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        $item = match ($attributes['item']['type']) {
            'message'               => OutputMessage::from($attributes['item']),
            'file_search_call'      => OutputFileSearchToolCall::from($attributes['item']),
            'function_call'         => OutputFunctionToolCall::from($attributes['item']),
            'web_search_call'       => OutputWebSearchToolCall::from($attributes['item']),
            'computer_call'         => OutputComputerToolCall::from($attributes['item']),
            'reasoning'             => OutputReasoning::from($attributes['item']),
            'image_generation_call' => OutputImageGenerationToolCall::from($attributes['item']),
            'mcp_list_tools'        => OutputMcpListTools::from($attributes['item']),
            'mcp_approval_request'  => OutputMcpApprovalRequest::from($attributes['item']),
            'mcp_call'              => OutputMcpCall::from($attributes['item']),
            'code_interpreter_call' => OutputCodeInterpreterToolCall::from($attributes['item']),
        };

        return new self(
            outputIndex: $attributes['output_index'],
            item: $item,
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'output_index' => $this->outputIndex,
            'item'         => $this->item->toArray(),
        ];
    }
}
PK     S%W]ðøŽ_û  û  4  client/src/Responses/Responses/Streaming/McpCall.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Streaming;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type McpCallType array{sequence_number: int}
 *
 * @implements ResponseContract<McpCallType>
 */
final class McpCall implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<McpCallType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly int $sequenceNumber,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  McpCallType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            sequenceNumber: $attributes['sequence_number'],
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'sequence_number' => $this->sequenceNumber,
        ];
    }
}
PK     S%W]øÏÝ>e  e  G  client/src/Responses/Responses/Streaming/FunctionCallArgumentsDelta.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Streaming;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type FunctionCallArgumentsDeltaType array{delta: string, item_id: string, output_index: int}
 *
 * @implements ResponseContract<FunctionCallArgumentsDeltaType>
 */
final class FunctionCallArgumentsDelta implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<FunctionCallArgumentsDeltaType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly string $delta,
        public readonly string $itemId,
        public readonly int $outputIndex,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  FunctionCallArgumentsDeltaType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            delta: $attributes['delta'],
            itemId: $attributes['item_id'],
            outputIndex: $attributes['output_index'],
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'delta'        => $this->delta,
            'item_id'      => $this->itemId,
            'output_index' => $this->outputIndex,
        ];
    }
}
PK     S%W]?·k“Ò  Ò  8  client/src/Responses/Responses/Streaming/RefusalDone.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Streaming;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type RefusalDoneType array{content_index: int, item_id: string, output_index: int, refusal: string}
 *
 * @implements ResponseContract<RefusalDoneType>
 */
final class RefusalDone implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<RefusalDoneType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly int $contentIndex,
        public readonly string $itemId,
        public readonly int $outputIndex,
        public readonly string $refusal,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  RefusalDoneType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            contentIndex: $attributes['content_index'],
            itemId: $attributes['item_id'],
            outputIndex: $attributes['output_index'],
            refusal: $attributes['refusal'],
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'content_index' => $this->contentIndex,
            'item_id'       => $this->itemId,
            'output_index'  => $this->outputIndex,
            'refusal'       => $this->refusal,
        ];
    }
}
PK     S%W]…ýqúž  ž  ;  client/src/Responses/Responses/Streaming/FileSearchCall.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Streaming;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type FileSearchCallType array{item_id: string, output_index: int}
 *
 * @implements ResponseContract<FileSearchCallType>
 */
final class FileSearchCall implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<FileSearchCallType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly string $itemId,
        public readonly int $outputIndex,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  FileSearchCallType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            itemId: $attributes['item_id'],
            outputIndex: $attributes['output_index'],
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'item_id'      => $this->itemId,
            'output_index' => $this->outputIndex,
        ];
    }
}
PK     S%W]©¸T[  [  C  client/src/Responses/Responses/Streaming/McpListToolsInProgress.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Streaming;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type McpListToolsType array{sequence_number: int, output_index: int, item_id: string}
 *
 * @implements ResponseContract<McpListToolsType>
 */
final class McpListToolsInProgress implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<McpListToolsType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly int $sequenceNumber,
        public readonly int $outputIndex,
        public readonly string $itemId,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  McpListToolsType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            sequenceNumber: $attributes['sequence_number'],
            outputIndex: $attributes['output_index'],
            itemId: $attributes['item_id'],
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'sequence_number' => $this->sequenceNumber,
            'output_index'    => $this->outputIndex,
            'item_id'         => $this->itemId,
        ];
    }
}
PK     S%W]†ú     F  client/src/Responses/Responses/Streaming/ReasoningSummaryTextDelta.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Streaming;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type ReasoningSummaryTextDeltaType array{delta: string, item_id: string, output_index: int, summary_index: int}
 *
 * @implements ResponseContract<ReasoningSummaryTextDeltaType>
 */
final class ReasoningSummaryTextDelta implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<ReasoningSummaryTextDeltaType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly string $delta,
        public readonly string $itemId,
        public readonly int $outputIndex,
        public readonly int $summaryIndex,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  ReasoningSummaryTextDeltaType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            delta: $attributes['delta'],
            itemId: $attributes['item_id'],
            outputIndex: $attributes['output_index'],
            summaryIndex: $attributes['summary_index'],
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'delta'         => $this->delta,
            'item_id'       => $this->itemId,
            'output_index'  => $this->outputIndex,
            'summary_index' => $this->summaryIndex,
        ];
    }
}
PK     S%W]`Y_Ý  Ý  2  client/src/Responses/Responses/Streaming/Error.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Streaming;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type ErrorType array{code: string|null, message: string, param: string|null}
 *
 * @implements ResponseContract<ErrorType>
 */
final class Error implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<ErrorType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly ?string $code,
        public readonly string $message,
        public readonly ?string $param,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  ErrorType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            code: $attributes['code'],
            message: $attributes['message'],
            param: $attributes['param'],
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'code'    => $this->code,
            'message' => $this->message,
            'param'   => $this->param,
        ];
    }
}
PK     S%W]Š‚xØÍ  Í  9  client/src/Responses/Responses/Streaming/RefusalDelta.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Streaming;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type RefusalDeltaType array{content_index: int, delta: string, item_id: string, output_index: int}
 *
 * @implements ResponseContract<RefusalDeltaType>
 */
final class RefusalDelta implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<RefusalDeltaType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly int $contentIndex,
        public readonly string $delta,
        public readonly string $itemId,
        public readonly int $outputIndex,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  RefusalDeltaType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            contentIndex: $attributes['content_index'],
            delta: $attributes['delta'],
            itemId: $attributes['item_id'],
            outputIndex: $attributes['output_index'],
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'content_index' => $this->contentIndex,
            'delta'         => $this->delta,
            'item_id'       => $this->itemId,
            'output_index'  => $this->outputIndex,
        ];
    }
}
PK     S%W]ûŸ…_t  t  F  client/src/Responses/Responses/Streaming/FunctionCallArgumentsDone.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Streaming;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type FunctionCallArgumentsDoneType array{arguments: string, item_id: string, output_index: int}
 *
 * @implements ResponseContract<FunctionCallArgumentsDoneType>
 */
final class FunctionCallArgumentsDone implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<FunctionCallArgumentsDoneType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly string $arguments,
        public readonly string $itemId,
        public readonly int $outputIndex,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  FunctionCallArgumentsDoneType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            arguments: $attributes['arguments'],
            itemId: $attributes['item_id'],
            outputIndex: $attributes['output_index'],
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'arguments'    => $this->arguments,
            'item_id'      => $this->itemId,
            'output_index' => $this->outputIndex,
        ];
    }
}
PK     S%W]wkÐa<  <  F  client/src/Responses/Responses/Streaming/OutputTextAnnotationAdded.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Streaming;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Responses\Responses\Output\OutputMessageContentOutputTextAnnotationsContainerFile;
use OpenAI\Responses\Responses\Output\OutputMessageContentOutputTextAnnotationsFileCitation;
use OpenAI\Responses\Responses\Output\OutputMessageContentOutputTextAnnotationsFilePath;
use OpenAI\Responses\Responses\Output\OutputMessageContentOutputTextAnnotationsUrlCitation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-import-type ContainerFileType from OutputMessageContentOutputTextAnnotationsContainerFile
 * @phpstan-import-type FileCitationType from OutputMessageContentOutputTextAnnotationsFileCitation
 * @phpstan-import-type FilePathType from OutputMessageContentOutputTextAnnotationsFilePath
 * @phpstan-import-type UrlCitationType from OutputMessageContentOutputTextAnnotationsUrlCitation
 *
 * @phpstan-type OutputTextAnnotationAddedType array{annotation: ContainerFileType|FileCitationType|FilePathType|UrlCitationType, annotation_index: int, content_index: int, item_id: string, output_index: int}
 *
 * @implements ResponseContract<OutputTextAnnotationAddedType>
 */
final class OutputTextAnnotationAdded implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<OutputTextAnnotationAddedType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly OutputMessageContentOutputTextAnnotationsContainerFile|OutputMessageContentOutputTextAnnotationsFileCitation|OutputMessageContentOutputTextAnnotationsFilePath|OutputMessageContentOutputTextAnnotationsUrlCitation $annotation,
        public readonly int $annotationIndex,
        public readonly int $contentIndex,
        public readonly string $itemId,
        public readonly int $outputIndex,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  OutputTextAnnotationAddedType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        $annotation = match ($attributes['annotation']['type']) {
            'file_citation'           => OutputMessageContentOutputTextAnnotationsFileCitation::from($attributes['annotation']),
            'file_path'               => OutputMessageContentOutputTextAnnotationsFilePath::from($attributes['annotation']),
            'url_citation'            => OutputMessageContentOutputTextAnnotationsUrlCitation::from($attributes['annotation']),
            'container_file_citation' => OutputMessageContentOutputTextAnnotationsContainerFile::from($attributes['annotation']),
        };

        return new self(
            annotation: $annotation,
            annotationIndex: $attributes['annotation_index'],
            contentIndex: $attributes['content_index'],
            itemId: $attributes['item_id'],
            outputIndex: $attributes['output_index'],
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'annotation'       => $this->annotation->toArray(),
            'annotation_index' => $this->annotationIndex,
            'content_index'    => $this->contentIndex,
            'item_id'          => $this->itemId,
            'output_index'     => $this->outputIndex,
        ];
    }
}
PK     S%W]$©üâ!	  !	  8  client/src/Responses/Responses/Streaming/ContentPart.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Streaming;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Responses\Responses\Output\OutputMessageContentOutputText;
use OpenAI\Responses\Responses\Output\OutputMessageContentRefusal;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-import-type OutputTextType from OutputMessageContentOutputText
 * @phpstan-import-type ContentRefusalType from OutputMessageContentRefusal
 *
 * @phpstan-type ContentPartType array{content_index: int, item_id: string, output_index: int, part: OutputTextType|ContentRefusalType}
 *
 * @implements ResponseContract<ContentPartType>
 */
final class ContentPart implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<ContentPartType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly int $contentIndex,
        public readonly string $itemId,
        public readonly int $outputIndex,
        public readonly OutputMessageContentOutputText|OutputMessageContentRefusal $part,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  ContentPartType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        $part = match ($attributes['part']['type']) {
            'output_text' => OutputMessageContentOutputText::from($attributes['part']),
            'refusal'     => OutputMessageContentRefusal::from($attributes['part']),
        };

        return new self(
            contentIndex: $attributes['content_index'],
            itemId: $attributes['item_id'],
            outputIndex: $attributes['output_index'],
            part: $part,
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'content_index' => $this->contentIndex,
            'item_id'       => $this->itemId,
            'output_index'  => $this->outputIndex,
            'part'          => $this->part->toArray(),
        ];
    }
}
PK     S%W]‡ûg¶È  È  <  client/src/Responses/Responses/Streaming/OutputTextDelta.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Streaming;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type OutputTextType array{content_index: int, delta: string, item_id: string, output_index: int}
 *
 * @implements ResponseContract<OutputTextType>
 */
final class OutputTextDelta implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<OutputTextType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly int $contentIndex,
        public readonly string $delta,
        public readonly string $itemId,
        public readonly int $outputIndex,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  OutputTextType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            contentIndex: $attributes['content_index'],
            delta: $attributes['delta'],
            itemId: $attributes['item_id'],
            outputIndex: $attributes['output_index'],
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'content_index' => $this->contentIndex,
            'delta'         => $this->delta,
            'item_id'       => $this->itemId,
            'output_index'  => $this->outputIndex,
        ];
    }
}
PK     S%W]?!Ð<  <  H  client/src/Responses/Responses/Streaming/ImageGenerationPartialImage.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Streaming;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type ImageGenerationPartialImageType array{output_index: int, item_id: string, sequence_number: int, partial_image_index: int, partial_image_b64: string}
 *
 * @implements ResponseContract<ImageGenerationPartialImageType>
 */
final class ImageGenerationPartialImage implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<ImageGenerationPartialImageType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly int $outputIndex,
        public readonly string $itemId,
        public readonly int $sequenceNumber,
        public readonly int $partialImageIndex,
        public readonly string $partialImageB64,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  ImageGenerationPartialImageType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            outputIndex: $attributes['output_index'],
            itemId: $attributes['item_id'],
            sequenceNumber: $attributes['sequence_number'],
            partialImageIndex: $attributes['partial_image_index'],
            partialImageB64: $attributes['partial_image_b64'],
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'output_index'        => $this->outputIndex,
            'item_id'             => $this->itemId,
            'sequence_number'     => $this->sequenceNumber,
            'partial_image_index' => $this->partialImageIndex,
            'partial_image_b64'   => $this->partialImageB64,
        ];
    }
}
PK     S%W]SØQh    B  client/src/Responses/Responses/Streaming/McpCallArgumentsDelta.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Streaming;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type McpCallArgumentsDoneType array{sequence_number: int, output_index: int, item_id: string, delta: string}
 *
 * @implements ResponseContract<McpCallArgumentsDoneType>
 */
final class McpCallArgumentsDelta implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<McpCallArgumentsDoneType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly int $sequenceNumber,
        public readonly int $outputIndex,
        public readonly string $itemId,
        public readonly string $delta,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  McpCallArgumentsDoneType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            sequenceNumber: $attributes['sequence_number'],
            outputIndex: $attributes['output_index'],
            itemId: $attributes['item_id'],
            delta: $attributes['delta'],
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'sequence_number' => $this->sequenceNumber,
            'output_index'    => $this->outputIndex,
            'item_id'         => $this->itemId,
            'delta'           => $this->delta,
        ];
    }
}
PK     S%W]ÇÛdÁ  Á  A  client/src/Responses/Responses/Streaming/ReasoningSummaryPart.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Streaming;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Responses\Responses\Output\OutputReasoningSummary;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-import-type ReasoningSummaryType from OutputReasoningSummary
 *
 * @phpstan-type ReasoningSummaryPartType array{item_id: string, output_index: int, part: ReasoningSummaryType, summary_index: int}
 *
 * @implements ResponseContract<ReasoningSummaryPartType>
 */
final class ReasoningSummaryPart implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<ReasoningSummaryPartType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly string $itemId,
        public readonly int $outputIndex,
        public readonly OutputReasoningSummary $part,
        public readonly int $summaryIndex,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  ReasoningSummaryPartType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            itemId: $attributes['item_id'],
            outputIndex: $attributes['output_index'],
            part: OutputReasoningSummary::from($attributes['part']),
            summaryIndex: $attributes['summary_index'],
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'item_id'       => $this->itemId,
            'output_index'  => $this->outputIndex,
            'part'          => $this->part->toArray(),
            'summary_index' => $this->summaryIndex,
        ];
    }
}
PK     S%W]WÙ·  ·  @  client/src/Responses/Responses/Streaming/CodeInterpreterCall.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Streaming;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type CodeInterpreterCallType array{item_id: string, output_index: int}
 *
 * @implements ResponseContract<CodeInterpreterCallType>
 */
final class CodeInterpreterCall implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<CodeInterpreterCallType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly string $itemId,
        public readonly int $outputIndex,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  CodeInterpreterCallType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            itemId: $attributes['item_id'],
            outputIndex: $attributes['output_index'],
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'item_id'      => $this->itemId,
            'output_index' => $this->outputIndex,
        ];
    }
}
PK     S%W]™…Í#    A  client/src/Responses/Responses/Streaming/McpCallArgumentsDone.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Streaming;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type McpCallArgumentsDoneType array{sequence_number: int, output_index: int, item_id: string, arguments: string}
 *
 * @implements ResponseContract<McpCallArgumentsDoneType>
 */
final class McpCallArgumentsDone implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<McpCallArgumentsDoneType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly int $sequenceNumber,
        public readonly int $outputIndex,
        public readonly string $itemId,
        public readonly string $arguments,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  McpCallArgumentsDoneType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            sequenceNumber: $attributes['sequence_number'],
            outputIndex: $attributes['output_index'],
            itemId: $attributes['item_id'],
            arguments: $attributes['arguments'],
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'sequence_number' => $this->sequenceNumber,
            'output_index'    => $this->outputIndex,
            'item_id'         => $this->itemId,
            'arguments'       => $this->arguments,
        ];
    }
}
PK     S%W]ÙÛF™  ™  :  client/src/Responses/Responses/Streaming/WebSearchCall.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Streaming;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type WebSearchCallType array{item_id: string, output_index: int}
 *
 * @implements ResponseContract<WebSearchCallType>
 */
final class WebSearchCall implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<WebSearchCallType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly string $itemId,
        public readonly int $outputIndex,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  WebSearchCallType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            itemId: $attributes['item_id'],
            outputIndex: $attributes['output_index'],
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'item_id'      => $this->itemId,
            'output_index' => $this->outputIndex,
        ];
    }
}
PK     S%W]«X    9  client/src/Responses/Responses/Streaming/McpListTools.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Streaming;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type McpListToolsType array{sequence_number: int}
 *
 * @implements ResponseContract<McpListToolsType>
 */
final class McpListTools implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<McpListToolsType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly int $sequenceNumber,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  McpListToolsType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            sequenceNumber: $attributes['sequence_number'],
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'sequence_number' => $this->sequenceNumber,
        ];
    }
}
PK     S%W]ÇLÔô  ô  G  client/src/Responses/Responses/CreateResponseUsageInputTokenDetails.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type InputTokenDetailsType array{cached_tokens: int}
 *
 * @implements ResponseContract<InputTokenDetailsType>
 */
final class CreateResponseUsageInputTokenDetails implements ResponseContract
{
    /**
     * @use ArrayAccessible<InputTokenDetailsType>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public readonly int $cachedTokens,
    ) {}

    /**
     * @param  InputTokenDetailsType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            cachedTokens: $attributes['cached_tokens'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'cached_tokens' => $this->cachedTokens,
        ];
    }
}
PK     S%W]ø©)qš  š  1  client/src/Responses/Responses/ListInputItems.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Responses\Responses\Input\ComputerToolCallOutput;
use OpenAI\Responses\Responses\Input\FunctionToolCallOutput;
use OpenAI\Responses\Responses\Input\InputMessage;
use OpenAI\Responses\Responses\Output\OutputComputerToolCall;
use OpenAI\Responses\Responses\Output\OutputFileSearchToolCall;
use OpenAI\Responses\Responses\Output\OutputFunctionToolCall;
use OpenAI\Responses\Responses\Output\OutputMessage;
use OpenAI\Responses\Responses\Output\OutputWebSearchToolCall;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-import-type InputMessageType from InputMessage
 * @phpstan-import-type OutputMessageType from OutputMessage
 * @phpstan-import-type OutputFileSearchToolCallType from OutputFileSearchToolCall
 * @phpstan-import-type OutputComputerToolCallType from OutputComputerToolCall
 * @phpstan-import-type ComputerToolCallOutputType from ComputerToolCallOutput
 * @phpstan-import-type OutputWebSearchToolCallType from OutputWebSearchToolCall
 * @phpstan-import-type OutputFunctionToolCallType from OutputFunctionToolCall
 * @phpstan-import-type FunctionToolCallOutputType from FunctionToolCallOutput
 *
 * @phpstan-type ListInputItemsType array{data: array<int, InputMessageType|OutputMessageType|OutputFileSearchToolCallType|OutputComputerToolCallType|ComputerToolCallOutputType|OutputWebSearchToolCallType|OutputFunctionToolCallType|FunctionToolCallOutputType>, first_id: string, has_more: bool, last_id: string, object: 'list'}
 *
 * @implements ResponseContract<ListInputItemsType>
 */
final class ListInputItems implements ResponseContract, ResponseHasMetaInformationContract
{
    /** @use ArrayAccessible<ListInputItemsType> */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<int, InputMessage|OutputMessage|OutputFileSearchToolCall|OutputComputerToolCall|ComputerToolCallOutput|OutputWebSearchToolCall|OutputFunctionToolCall|FunctionToolCallOutput>  $data
     * @param  'list'  $object
     */
    private function __construct(
        public readonly string $object,
        public readonly array $data,
        public readonly string $firstId,
        public readonly string $lastId,
        public readonly bool $hasMore,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  ListInputItemsType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        $data = array_map(
            fn (array $item): InputMessage|OutputMessage|OutputFileSearchToolCall|OutputComputerToolCall|ComputerToolCallOutput|OutputWebSearchToolCall|OutputFunctionToolCall|FunctionToolCallOutput => match ($item['type']) {
                'message'              => $item['role'] === 'assistant' ? OutputMessage::from($item) : InputMessage::from($item),
                'file_search_call'     => OutputFileSearchToolCall::from($item),
                'function_call'        => OutputFunctionToolCall::from($item),
                'function_call_output' => FunctionToolCallOutput::from($item),
                'web_search_call'      => OutputWebSearchToolCall::from($item),
                'computer_call'        => OutputComputerToolCall::from($item),
                'computer_call_output' => ComputerToolCallOutput::from($item),
            },
            $attributes['data'],
        );

        return new self(
            object: $attributes['object'],
            data: $data,
            firstId: $attributes['first_id'],
            lastId: $attributes['last_id'],
            hasMore: $attributes['has_more'],
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'object' => $this->object,
            'data'   => array_map(
                fn (InputMessage|OutputMessage|OutputFileSearchToolCall|OutputComputerToolCall|ComputerToolCallOutput|OutputWebSearchToolCall|OutputFunctionToolCall|FunctionToolCallOutput $item): array => $item->toArray(),
                $this->data,
            ),
            'first_id' => $this->firstId,
            'last_id'  => $this->lastId,
            'has_more' => $this->hasMore,
        ];
    }
}
PK     S%W]T‹%Xq  q  8  client/src/Responses/Responses/ReferencePromptObject.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type ReferencePromptObjectType array{id: string, variables?: array<string, string>|null, version?: string|null}
 *
 * @implements ResponseContract<ReferencePromptObjectType>
 */
final class ReferencePromptObject implements ResponseContract
{
    /**
     * @use ArrayAccessible<ReferencePromptObjectType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  array<string, string>|null  $variables
     */
    private function __construct(
        public readonly string $id,
        public readonly ?array $variables = null,
        public readonly ?string $version = null,
    ) {}

    /**
     * @param  ReferencePromptObjectType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            id: $attributes['id'],
            variables: $attributes['variables'] ?? null,
            version: $attributes['version'] ?? null,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'        => $this->id,
            'variables' => $this->variables,
            'version'   => $this->version,
        ];
    }
}
PK     S%W]Œ¥Î²ë  ë  1  client/src/Responses/Responses/DeleteResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type DeleteResponseType array{id: string, object: string, deleted: bool}
 *
 * @implements ResponseContract<DeleteResponseType>
 */
final class DeleteResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<DeleteResponseType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly string $id,
        public readonly string $object,
        public readonly bool $deleted,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  DeleteResponseType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            id: $attributes['id'],
            object: $attributes['object'],
            deleted: $attributes['deleted'],
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'      => $this->id,
            'object'  => $this->object,
            'deleted' => $this->deleted,
        ];
    }
}
PK     S%W]N²Ä¤    H  client/src/Responses/Responses/CreateResponseUsageOutputTokenDetails.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type OutputTokenDetailsType array{reasoning_tokens: int}
 *
 * @implements ResponseContract<OutputTokenDetailsType>
 */
final class CreateResponseUsageOutputTokenDetails implements ResponseContract
{
    /**
     * @use ArrayAccessible<OutputTokenDetailsType>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public readonly int $reasoningTokens,
    ) {}

    /**
     * @param  OutputTokenDetailsType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            reasoningTokens: $attributes['reasoning_tokens'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'reasoning_tokens' => $this->reasoningTokens,
        ];
    }
}
PK     S%W]yµ…æ,5  ,5  3  client/src/Responses/Responses/RetrieveResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Responses\Responses\Output\OutputCodeInterpreterToolCall;
use OpenAI\Responses\Responses\Output\OutputComputerToolCall;
use OpenAI\Responses\Responses\Output\OutputFileSearchToolCall;
use OpenAI\Responses\Responses\Output\OutputFunctionToolCall;
use OpenAI\Responses\Responses\Output\OutputImageGenerationToolCall;
use OpenAI\Responses\Responses\Output\OutputMcpApprovalRequest;
use OpenAI\Responses\Responses\Output\OutputMcpCall;
use OpenAI\Responses\Responses\Output\OutputMcpListTools;
use OpenAI\Responses\Responses\Output\OutputMessage;
use OpenAI\Responses\Responses\Output\OutputReasoning;
use OpenAI\Responses\Responses\Output\OutputWebSearchToolCall;
use OpenAI\Responses\Responses\Tool\CodeInterpreterTool;
use OpenAI\Responses\Responses\Tool\ComputerUseTool;
use OpenAI\Responses\Responses\Tool\FileSearchTool;
use OpenAI\Responses\Responses\Tool\FunctionTool;
use OpenAI\Responses\Responses\Tool\ImageGenerationTool;
use OpenAI\Responses\Responses\Tool\RemoteMcpTool;
use OpenAI\Responses\Responses\Tool\WebSearchTool;
use OpenAI\Responses\Responses\ToolChoice\FunctionToolChoice;
use OpenAI\Responses\Responses\ToolChoice\HostedToolChoice;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-import-type ResponseFormatType from CreateResponseFormat
 * @phpstan-import-type OutputComputerToolCallType from OutputComputerToolCall
 * @phpstan-import-type OutputFileSearchToolCallType from OutputFileSearchToolCall
 * @phpstan-import-type OutputFunctionToolCallType from OutputFunctionToolCall
 * @phpstan-import-type OutputMessageType from OutputMessage
 * @phpstan-import-type OutputReasoningType from OutputReasoning
 * @phpstan-import-type OutputWebSearchToolCallType from OutputWebSearchToolCall
 * @phpstan-import-type OutputImageGenerationToolCallType from OutputImageGenerationToolCall
 * @phpstan-import-type OutputMcpListToolsType from OutputMcpListTools
 * @phpstan-import-type OutputMcpApprovalRequestType from OutputMcpApprovalRequest
 * @phpstan-import-type OutputMcpCallType from OutputMcpCall
 * @phpstan-import-type OutputImageGenerationToolCallType from OutputImageGenerationToolCall
 * @phpstan-import-type OutputCodeInterpreterToolCallType from OutputCodeInterpreterToolCall
 * @phpstan-import-type ComputerUseToolType from ComputerUseTool
 * @phpstan-import-type FileSearchToolType from FileSearchTool
 * @phpstan-import-type ImageGenerationToolType from ImageGenerationTool
 * @phpstan-import-type RemoteMcpToolType from RemoteMcpTool
 * @phpstan-import-type FunctionToolType from FunctionTool
 * @phpstan-import-type WebSearchToolType from WebSearchTool
 * @phpstan-import-type CodeInterpreterToolType from CodeInterpreterTool
 * @phpstan-import-type ErrorType from CreateResponseError
 * @phpstan-import-type IncompleteDetailsType from CreateResponseIncompleteDetails
 * @phpstan-import-type UsageType from CreateResponseUsage
 * @phpstan-import-type FunctionToolChoiceType from FunctionToolChoice
 * @phpstan-import-type HostedToolChoiceType from HostedToolChoice
 * @phpstan-import-type ReasoningType from CreateResponseReasoning
 * @phpstan-import-type ReferencePromptObjectType from ReferencePromptObject
 *
 * @phpstan-type InstructionsType array<int, mixed>|string|null
 * @phpstan-type ToolChoiceType 'none'|'auto'|'required'|FunctionToolChoiceType|HostedToolChoiceType
 * @phpstan-type ToolsType array<int, ComputerUseToolType|FileSearchToolType|FunctionToolType|WebSearchToolType|ImageGenerationToolType|RemoteMcpToolType|CodeInterpreterToolType>
 * @phpstan-type OutputType array<int, OutputComputerToolCallType|OutputFileSearchToolCallType|OutputFunctionToolCallType|OutputMessageType|OutputReasoningType|OutputWebSearchToolCallType|OutputMcpListToolsType|OutputMcpApprovalRequestType|OutputMcpCallType|OutputImageGenerationToolCallType|OutputCodeInterpreterToolCallType>
 * @phpstan-type RetrieveResponseType array{id: string, object: 'response', created_at: int, status: 'completed'|'failed'|'in_progress'|'incomplete', error: ErrorType|null, incomplete_details: IncompleteDetailsType|null, instructions: InstructionsType, max_output_tokens: int|null, model: string, output: OutputType, parallel_tool_calls: bool, previous_response_id: string|null, prompt: ReferencePromptObjectType|null, reasoning: ReasoningType|null, store: bool, temperature: float|null, text: ResponseFormatType, tool_choice: ToolChoiceType, tools: ToolsType, top_p: float|null, truncation: 'auto'|'disabled'|null, usage: UsageType|null, user: string|null, metadata: array<string, string>|null}
 *
 * @implements ResponseContract<RetrieveResponseType>
 */
final class RetrieveResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<RetrieveResponseType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  'response'  $object
     * @param  'completed'|'failed'|'in_progress'|'incomplete'  $status
     * @param  array<int, mixed>|string|null  $instructions
     * @param  array<int, OutputMessage|OutputComputerToolCall|OutputFileSearchToolCall|OutputWebSearchToolCall|OutputFunctionToolCall|OutputReasoning|OutputMcpListTools|OutputMcpApprovalRequest|OutputMcpCall|OutputImageGenerationToolCall|OutputCodeInterpreterToolCall>  $output
     * @param  array<int, ComputerUseTool|FileSearchTool|FunctionTool|WebSearchTool|ImageGenerationTool|RemoteMcpTool|CodeInterpreterTool>  $tools
     * @param  'auto'|'disabled'|null  $truncation
     * @param  array<string, string>  $metadata
     */
    private function __construct(
        public readonly string $id,
        public readonly string $object,
        public readonly int $createdAt,
        public readonly string $status,
        public readonly ?CreateResponseError $error,
        public readonly ?CreateResponseIncompleteDetails $incompleteDetails,
        public readonly array|string|null $instructions,
        public readonly ?int $maxOutputTokens,
        public readonly string $model,
        public readonly array $output,
        public readonly bool $parallelToolCalls,
        public readonly ?string $previousResponseId,
        public readonly ?ReferencePromptObject $prompt,
        public readonly ?CreateResponseReasoning $reasoning,
        public readonly bool $store,
        public readonly ?float $temperature,
        public readonly CreateResponseFormat $text,
        public readonly string|FunctionToolChoice|HostedToolChoice $toolChoice,
        public readonly array $tools,
        public readonly ?float $topP,
        public readonly ?string $truncation,
        public readonly ?CreateResponseUsage $usage,
        public readonly ?string $user,
        public array $metadata,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  RetrieveResponseType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        $output = array_map(
            fn (array $output): OutputMessage|OutputComputerToolCall|OutputFileSearchToolCall|OutputWebSearchToolCall|OutputFunctionToolCall|OutputReasoning|OutputMcpListTools|OutputMcpApprovalRequest|OutputMcpCall|OutputImageGenerationToolCall|OutputCodeInterpreterToolCall => match ($output['type']) {
                'message'               => OutputMessage::from($output),
                'file_search_call'      => OutputFileSearchToolCall::from($output),
                'function_call'         => OutputFunctionToolCall::from($output),
                'web_search_call'       => OutputWebSearchToolCall::from($output),
                'computer_call'         => OutputComputerToolCall::from($output),
                'reasoning'             => OutputReasoning::from($output),
                'mcp_list_tools'        => OutputMcpListTools::from($output),
                'mcp_approval_request'  => OutputMcpApprovalRequest::from($output),
                'mcp_call'              => OutputMcpCall::from($output),
                'image_generation_call' => OutputImageGenerationToolCall::from($output),
                'code_interpreter_call' => OutputCodeInterpreterToolCall::from($output),
            },
            $attributes['output'],
        );

        $toolChoice = is_array($attributes['tool_choice'])
            ? match ($attributes['tool_choice']['type']) {
                'file_search', 'web_search_preview', 'computer_use_preview' => HostedToolChoice::from($attributes['tool_choice']),
                'function' => FunctionToolChoice::from($attributes['tool_choice']),
            }
        : $attributes['tool_choice'];

        $tools = array_map(
            fn (array $tool): ComputerUseTool|FileSearchTool|FunctionTool|WebSearchTool|ImageGenerationTool|RemoteMcpTool|CodeInterpreterTool => match ($tool['type']) {
                'file_search' => FileSearchTool::from($tool),
                'web_search_preview', 'web_search_preview_2025_03_11' => WebSearchTool::from($tool),
                'function'             => FunctionTool::from($tool),
                'computer_use_preview' => ComputerUseTool::from($tool),
                'image_generation'     => ImageGenerationTool::from($tool),
                'mcp'                  => RemoteMcpTool::from($tool),
                'code_interpreter'     => CodeInterpreterTool::from($tool),
            },
            $attributes['tools'],
        );

        return new self(
            id: $attributes['id'],
            object: $attributes['object'],
            createdAt: $attributes['created_at'],
            status: $attributes['status'],
            error: isset($attributes['error'])
                ? CreateResponseError::from($attributes['error'])
                : null,
            incompleteDetails: isset($attributes['incomplete_details'])
                ? CreateResponseIncompleteDetails::from($attributes['incomplete_details'])
                : null,
            instructions: $attributes['instructions'],
            maxOutputTokens: $attributes['max_output_tokens'],
            model: $attributes['model'],
            output: $output,
            parallelToolCalls: $attributes['parallel_tool_calls'],
            previousResponseId: $attributes['previous_response_id'],
            prompt: isset($attributes['prompt'])
                ? ReferencePromptObject::from($attributes['prompt'])
                : null,
            reasoning: isset($attributes['reasoning'])
                ? CreateResponseReasoning::from($attributes['reasoning'])
                : null,
            store: $attributes['store'],
            temperature: $attributes['temperature'],
            text: CreateResponseFormat::from($attributes['text']),
            toolChoice: $toolChoice,
            tools: $tools,
            topP: $attributes['top_p'],
            truncation: $attributes['truncation'],
            usage: isset($attributes['usage'])
                ? CreateResponseUsage::from($attributes['usage'])
                : null,
            user: $attributes['user'] ?? null,
            metadata: $attributes['metadata'] ?? [],
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        // https://github.com/phpstan/phpstan/issues/8438
        // @phpstan-ignore-next-line
        return [
            'id'                 => $this->id,
            'object'             => $this->object,
            'created_at'         => $this->createdAt,
            'status'             => $this->status,
            'error'              => $this->error?->toArray(),
            'incomplete_details' => $this->incompleteDetails?->toArray(),
            'instructions'       => $this->instructions,
            'max_output_tokens'  => $this->maxOutputTokens,
            'metadata'           => $this->metadata ?? [],
            'model'              => $this->model,
            'output'             => array_map(
                fn (OutputMessage|OutputComputerToolCall|OutputFileSearchToolCall|OutputWebSearchToolCall|OutputFunctionToolCall|OutputReasoning|OutputMcpListTools|OutputMcpCall|OutputMcpApprovalRequest|OutputImageGenerationToolCall|OutputCodeInterpreterToolCall $output): array => $output->toArray(),
                $this->output
            ),
            'parallel_tool_calls'  => $this->parallelToolCalls,
            'previous_response_id' => $this->previousResponseId,
            'prompt'               => $this->prompt?->toArray(),
            'reasoning'            => $this->reasoning?->toArray(),
            'store'                => $this->store,
            'temperature'          => $this->temperature,
            'text'                 => $this->text->toArray(),
            'tool_choice'          => is_string($this->toolChoice)
                ? $this->toolChoice
                : $this->toolChoice->toArray(),
            'tools' => array_map(
                fn (ComputerUseTool|FileSearchTool|FunctionTool|WebSearchTool|ImageGenerationTool|RemoteMcpTool|CodeInterpreterTool $tool): array => $tool->toArray(),
                $this->tools
            ),
            'top_p'      => $this->topP,
            'truncation' => $this->truncation,
            'usage'      => $this->usage?->toArray(),
            'user'       => $this->user,
        ];
    }
}
PK     S%W]›ž%Ñ’  ’  9  client/src/Responses/Responses/CreateStreamedResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Exceptions\UnknownEventException;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Responses\Streaming\CodeInterpreterCall;
use OpenAI\Responses\Responses\Streaming\CodeInterpreterCodeDelta;
use OpenAI\Responses\Responses\Streaming\CodeInterpreterCodeDone;
use OpenAI\Responses\Responses\Streaming\ContentPart;
use OpenAI\Responses\Responses\Streaming\Error;
use OpenAI\Responses\Responses\Streaming\FileSearchCall;
use OpenAI\Responses\Responses\Streaming\FunctionCallArgumentsDelta;
use OpenAI\Responses\Responses\Streaming\FunctionCallArgumentsDone;
use OpenAI\Responses\Responses\Streaming\ImageGenerationPart;
use OpenAI\Responses\Responses\Streaming\ImageGenerationPartialImage;
use OpenAI\Responses\Responses\Streaming\McpCall;
use OpenAI\Responses\Responses\Streaming\McpCallArgumentsDelta;
use OpenAI\Responses\Responses\Streaming\McpCallArgumentsDone;
use OpenAI\Responses\Responses\Streaming\McpListTools;
use OpenAI\Responses\Responses\Streaming\McpListToolsInProgress;
use OpenAI\Responses\Responses\Streaming\OutputItem;
use OpenAI\Responses\Responses\Streaming\OutputTextAnnotationAdded;
use OpenAI\Responses\Responses\Streaming\OutputTextDelta;
use OpenAI\Responses\Responses\Streaming\OutputTextDone;
use OpenAI\Responses\Responses\Streaming\ReasoningSummaryPart;
use OpenAI\Responses\Responses\Streaming\ReasoningSummaryTextDelta;
use OpenAI\Responses\Responses\Streaming\ReasoningSummaryTextDone;
use OpenAI\Responses\Responses\Streaming\RefusalDelta;
use OpenAI\Responses\Responses\Streaming\RefusalDone;
use OpenAI\Responses\Responses\Streaming\WebSearchCall;
use OpenAI\Testing\Responses\Concerns\FakeableForStreamedResponse;

/**
 * @phpstan-type CreateStreamedResponseType array{event: string, data: array<string, mixed>}
 *
 * @implements ResponseContract<CreateStreamedResponseType>
 */
final class CreateStreamedResponse implements ResponseContract
{
    /**
     * @use ArrayAccessible<CreateStreamedResponseType>
     */
    use ArrayAccessible;

    use FakeableForStreamedResponse;

    private function __construct(
        public readonly string $event,
        public readonly CreateResponse|OutputItem|ContentPart|OutputTextDelta|OutputTextAnnotationAdded|OutputTextDone|RefusalDelta|RefusalDone|FunctionCallArgumentsDelta|FunctionCallArgumentsDone|FileSearchCall|WebSearchCall|CodeInterpreterCall|CodeInterpreterCodeDelta|CodeInterpreterCodeDone|ReasoningSummaryPart|ReasoningSummaryTextDelta|ReasoningSummaryTextDone|McpListTools|McpListToolsInProgress|McpCall|McpCallArgumentsDelta|McpCallArgumentsDone|ImageGenerationPart|ImageGenerationPartialImage|Error $response,
    ) {}

    /**
     * @param  array<string, mixed>  $attributes
     */
    public static function from(array $attributes): self
    {
        $event = $attributes['type'] ?? throw new UnknownEventException('Missing event type in streamed response');
        $meta = $attributes['__meta'];
        unset($attributes['__meta']);

        $response = match ($event) {
            'response.created',
            'response.in_progress',
            'response.completed',
            'response.failed',
            'response.incomplete' => CreateResponse::from($attributes['response'], $meta), // @phpstan-ignore-line
            'response.output_item.added',
            'response.output_item.done' => OutputItem::from($attributes, $meta), // @phpstan-ignore-line
            'response.content_part.added',
            'response.content_part.done'             => ContentPart::from($attributes, $meta), // @phpstan-ignore-line
            'response.output_text.delta'             => OutputTextDelta::from($attributes, $meta), // @phpstan-ignore-line
            'response.output_text.done'              => OutputTextDone::from($attributes, $meta), // @phpstan-ignore-line
            'response.output_text.annotation.added'  => OutputTextAnnotationAdded::from($attributes, $meta), // @phpstan-ignore-line
            'response.refusal.delta'                 => RefusalDelta::from($attributes, $meta), // @phpstan-ignore-line
            'response.refusal.done'                  => RefusalDone::from($attributes, $meta), // @phpstan-ignore-line
            'response.function_call_arguments.delta' => FunctionCallArgumentsDelta::from($attributes, $meta), // @phpstan-ignore-line
            'response.function_call_arguments.done'  => FunctionCallArgumentsDone::from($attributes, $meta), // @phpstan-ignore-line
            'response.file_search_call.in_progress',
            'response.file_search_call.searching',
            'response.file_search_call.completed' => FileSearchCall::from($attributes, $meta), // @phpstan-ignore-line
            'response.web_search_call.in_progress',
            'response.web_search_call.searching',
            'response.web_search_call.completed' => WebSearchCall::from($attributes, $meta), // @phpstan-ignore-line
            'response.code_interpreter_call.in_progress',
            'response.code_interpreter_call.running',
            'response.code_interpreter_call.interpreting',
            'response.code_interpreter_call.completed'  => CodeInterpreterCall::from($attributes, $meta), // @phpstan-ignore-line
            'response.code_interpreter_call_code.delta' => CodeInterpreterCodeDelta::from($attributes, $meta), // @phpstan-ignore-line
            'response.code_interpreter_call_code.done'  => CodeInterpreterCodeDone::from($attributes, $meta), // @phpstan-ignore-line
            'response.reasoning_summary_part.added',
            'response.reasoning_summary_part.done'  => ReasoningSummaryPart::from($attributes, $meta), // @phpstan-ignore-line
            'response.reasoning_summary_text.delta' => ReasoningSummaryTextDelta::from($attributes, $meta), // @phpstan-ignore-line
            'response.reasoning_summary_text.done'  => ReasoningSummaryTextDone::from($attributes, $meta), // @phpstan-ignore-line
            'response.mcp_list_tools.in_progress'   => McpListToolsInProgress::from($attributes, $meta), // @phpstan-ignore-line
            'response.mcp_list_tools.failed',
            'response.mcp_list_tools.completed' => McpListTools::from($attributes, $meta), // @phpstan-ignore-line
            'response.mcp_call.in_progress',
            'response.mcp_call.failed',
            'response.mcp_call.completed' => McpCall::from($attributes, $meta), // @phpstan-ignore-line
            'response.mcp_call.arguments.delta',
            'response.mcp_call_arguments.delta' => McpCallArgumentsDelta::from($attributes, $meta), // @phpstan-ignore-line
            'response.mcp_call.arguments.done',
            'response.mcp_call_arguments.done' => McpCallArgumentsDone::from($attributes, $meta), // @phpstan-ignore-line
            'response.image_generation_call.completed',
            'response.image_generation_call.generating',
            'response.image_generation_call.in_progress'   => ImageGenerationPart::from($attributes, $meta), // @phpstan-ignore-line
            'response.image_generation_call.partial_image' => ImageGenerationPartialImage::from($attributes, $meta), // @phpstan-ignore-line
            'error'                                        => Error::from($attributes, $meta), // @phpstan-ignore-line
            default                                        => throw new UnknownEventException('Unknown Responses streaming event: ' . $event),
        };

        return new self(
            event: $event, // @phpstan-ignore-line
            response: $response,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'event' => $this->event,
            'data'  => $this->response->toArray(),
        ];
    }
}
PK     S%W]g©ª    7  client/src/Responses/Responses/Tool/ComputerUseTool.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Tool;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type ComputerUseToolType array{display_height: int, display_width: int, environment: string, type: 'computer_use_preview'}
 *
 * @implements ResponseContract<ComputerUseToolType>
 */
final class ComputerUseTool implements ResponseContract
{
    /**
     * @use ArrayAccessible<ComputerUseToolType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'computer_use_preview'  $type
     */
    private function __construct(
        public readonly int $displayHeight,
        public readonly int $displayWidth,
        public readonly string $environment,
        public readonly string $type,
    ) {}

    /**
     * @param  ComputerUseToolType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            displayHeight: $attributes['display_height'],
            displayWidth: $attributes['display_width'],
            environment: $attributes['environment'],
            type: $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'display_height' => $this->displayHeight,
            'display_width'  => $this->displayWidth,
            'environment'    => $this->environment,
            'type'           => $this->type,
        ];
    }
}
PK     S%W] mŸ;Y  Y  @  client/src/Responses/Responses/Tool/FileSearchCompoundFilter.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Tool;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-import-type ComparisonFilterType from FileSearchComparisonFilter
 *
 * @phpstan-type CompoundFilterType array{filters: array<int, ComparisonFilterType>, type: 'and'|'or'}
 *
 * @implements ResponseContract<CompoundFilterType>
 */
final class FileSearchCompoundFilter implements ResponseContract
{
    /**
     * @use ArrayAccessible<CompoundFilterType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  array<int, FileSearchComparisonFilter>  $filters
     * @param  'and'|'or'  $type
     */
    private function __construct(
        public readonly array $filters,
        public readonly string $type,
    ) {}

    /**
     * @param  CompoundFilterType  $attributes
     */
    public static function from(array $attributes): self
    {
        $filters = array_map(
            static fn (array $filter): FileSearchComparisonFilter => FileSearchComparisonFilter::from($filter),
            $attributes['filters'],
        );

        return new self(
            filters: $filters,
            type: $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'filters' => array_map(
                static fn (FileSearchComparisonFilter $filter): array => $filter->toArray(),
                $this->filters,
            ),
            'type' => $this->type,
        ];
    }
}
PK     S%W]EB´>  >  ;  client/src/Responses/Responses/Tool/CodeInterpreterTool.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Tool;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-import-type CodeInterpreterContainerAutoType from CodeInterpreterContainerAuto
 *
 * @phpstan-type CodeInterpreterToolType array{container: string|CodeInterpreterContainerAutoType, type: 'code_interpreter'}
 *
 * @implements ResponseContract<CodeInterpreterToolType>
 */
final class CodeInterpreterTool implements ResponseContract
{
    /**
     * @use ArrayAccessible<CodeInterpreterToolType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'code_interpreter'  $type
     */
    private function __construct(
        public readonly string|CodeInterpreterContainerAuto $container,
        public readonly string $type,
    ) {}

    /**
     * @param  CodeInterpreterToolType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            container: is_string($attributes['container'])
                ? $attributes['container']
                : CodeInterpreterContainerAuto::from($attributes['container']),
            type: $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'container' => $this->container instanceof CodeInterpreterContainerAuto
                ? $this->container->toArray()
                : $this->container,
            'type' => $this->type,
        ];
    }
}
PK     S%W]^‹þ//  /  =  client/src/Responses/Responses/Tool/WebSearchUserLocation.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Tool;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type UserLocationType array{type: 'approximate', city: string|null, country: string, region: string|null, timezone: string|null}
 *
 * @implements ResponseContract<UserLocationType>
 */
final class WebSearchUserLocation implements ResponseContract
{
    /**
     * @use ArrayAccessible<UserLocationType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'approximate'  $type
     */
    private function __construct(
        public readonly string $type,
        public readonly ?string $city,
        public readonly string $country,
        public readonly ?string $region,
        public readonly ?string $timezone,
    ) {}

    /**
     * @param  UserLocationType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            type: $attributes['type'],
            city: $attributes['city'],
            country: $attributes['country'],
            region: $attributes['region'],
            timezone: $attributes['timezone'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type'     => $this->type,
            'city'     => $this->city,
            'country'  => $this->country,
            'region'   => $this->region,
            'timezone' => $this->timezone,
        ];
    }
}
PK     S%W]p3ªî      5  client/src/Responses/Responses/Tool/RemoteMcpTool.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Tool;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-import-type McpToolNamesFilterType from McpToolNamesFilter
 *
 * @phpstan-type RemoteMcpToolType array{type: 'mcp', server_label: string, server_url: string, require_approval: 'never'|'always'|array<'never'|'always', McpToolNamesFilterType>|null, allowed_tools: array<int, string>|McpToolNamesFilterType|null, headers: array<string, string>|null}
 *
 * @implements ResponseContract<RemoteMcpToolType>
 */
final class RemoteMcpTool implements ResponseContract
{
    /**
     * @use ArrayAccessible<RemoteMcpToolType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'mcp'  $type
     * @param  'never'|'always'|array<'never'|'always', McpToolNamesFilter>|null  $requireApproval
     * @param  array<int, string>|McpToolNamesFilter|null  $allowedTools
     * @param  array<string, string>|null  $headers
     */
    private function __construct(
        public readonly string $type,
        public readonly string $serverLabel,
        public readonly string $serverUrl,
        public readonly string|array|null $requireApproval = null,
        public readonly array|McpToolNamesFilter|null $allowedTools = null,
        public readonly ?array $headers = null,
    ) {}

    /**
     * @param  RemoteMcpToolType  $attributes
     */
    public static function from(array $attributes): self
    {
        $requireApproval = $attributes['require_approval'] ?? null;
        if (is_array($requireApproval)) {
            $requireApproval = array_map(function (array $approvalAttributes): McpToolNamesFilter {
                return McpToolNamesFilter::from($approvalAttributes);
            }, $requireApproval);
        }

        $allowedTools = $attributes['allowed_tools'] ?? null;
        if ($allowedTools !== null && isset($allowedTools['tool_names']) && is_array($allowedTools['tool_names'])) {
            $allowedTools = McpToolNamesFilter::from($allowedTools);
        }

        return new self(
            type: $attributes['type'],
            serverLabel: $attributes['server_label'],
            serverUrl: $attributes['server_url'],
            requireApproval: $requireApproval,
            allowedTools: $allowedTools, // @phpstan-ignore-line
            headers: $attributes['headers'] ?? null,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        $requireApproval = $this->requireApproval;
        if (is_array($requireApproval)) {
            $requireApproval = array_map(function (McpToolNamesFilter $approvalFilter): array {
                return $approvalFilter->toArray();
            }, $requireApproval);
        }

        $allowedTools = $this->allowedTools;
        if ($allowedTools instanceof McpToolNamesFilter) {
            $allowedTools = $allowedTools->toArray();
        }

        return [
            'type'             => $this->type,
            'server_label'     => $this->serverLabel,
            'server_url'       => $this->serverUrl,
            'require_approval' => $requireApproval,
            'allowed_tools'    => $allowedTools,
            'headers'          => $this->headers,
        ];
    }
}
PK     S%W]éuMÍæ  æ  5  client/src/Responses/Responses/Tool/WebSearchTool.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Tool;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-import-type UserLocationType from WebSearchUserLocation
 *
 * @phpstan-type WebSearchToolType array{type: 'web_search_preview'|'web_search_preview_2025_03_11', search_context_size: 'low'|'medium'|'high', user_location: ?UserLocationType}
 *
 * @implements ResponseContract<WebSearchToolType>
 */
final class WebSearchTool implements ResponseContract
{
    /**
     * @use ArrayAccessible<WebSearchToolType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'web_search_preview'|'web_search_preview_2025_03_11'  $type
     * @param  'low'|'medium'|'high'  $searchContextSize
     */
    private function __construct(
        public readonly string $type,
        public readonly string $searchContextSize,
        public readonly ?WebSearchUserLocation $userLocation,
    ) {}

    /**
     * @param  WebSearchToolType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            type: $attributes['type'],
            searchContextSize: $attributes['search_context_size'],
            userLocation: isset($attributes['user_location'])
                ? WebSearchUserLocation::from($attributes['user_location'])
                : null,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type'                => $this->type,
            'search_context_size' => $this->searchContextSize,
            'user_location'       => $this->userLocation?->toArray(),
        ];
    }
}
PK     S%W]„iŸÿ  ÿ  D  client/src/Responses/Responses/Tool/CodeInterpreterContainerAuto.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Tool;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type CodeInterpreterContainerAutoType array{file_ids?: array<int, string>|null, type: 'auto'}
 *
 * @implements ResponseContract<CodeInterpreterContainerAutoType>
 */
final class CodeInterpreterContainerAuto implements ResponseContract
{
    /**
     * @use ArrayAccessible<CodeInterpreterContainerAutoType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  array<int, string>|null  $fileIds
     * @param  'auto'  $type
     */
    private function __construct(
        public readonly ?array $fileIds,
        public readonly string $type,
    ) {}

    /**
     * @param  CodeInterpreterContainerAutoType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            fileIds: $attributes['file_ids'] ?? null,
            type: $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'file_ids' => $this->fileIds,
            'type'     => $this->type,
        ];
    }
}
PK     S%W]ˆž
•é	  é	  6  client/src/Responses/Responses/Tool/FileSearchTool.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Tool;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-import-type RankingOptionType from FileSearchRankingOption
 * @phpstan-import-type ComparisonFilterType from FileSearchComparisonFilter
 * @phpstan-import-type CompoundFilterType from FileSearchCompoundFilter
 *
 * @phpstan-type FileSearchToolType array{type: 'file_search', vector_store_ids: array<int, string>, filters: ComparisonFilterType|CompoundFilterType|null, max_num_results: int, ranking_options: RankingOptionType}
 *
 * @implements ResponseContract<FileSearchToolType>
 */
final class FileSearchTool implements ResponseContract
{
    /**
     * @use ArrayAccessible<FileSearchToolType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  array<int, string>  $vectorStoreIds
     * @param  'file_search'  $type
     */
    private function __construct(
        public readonly string $type,
        public readonly array $vectorStoreIds,
        public readonly FileSearchComparisonFilter|FileSearchCompoundFilter|null $filters,
        public readonly int $maxNumResults,
        public readonly FileSearchRankingOption $rankingOptions,
    ) {}

    /**
     * @param  FileSearchToolType  $attributes
     */
    public static function from(array $attributes): self
    {
        $filters = null;

        if (isset($attributes['filters']['type'])) {
            $filters = match ($attributes['filters']['type']) {
                'eq', 'ne', 'gt', 'gte', 'lt', 'lte' => FileSearchComparisonFilter::from($attributes['filters']),
                'and', 'or' => FileSearchCompoundFilter::from($attributes['filters']),
            };
        }

        return new self(
            type: $attributes['type'],
            vectorStoreIds: $attributes['vector_store_ids'],
            filters: $filters,
            maxNumResults: $attributes['max_num_results'],
            rankingOptions: FileSearchRankingOption::from($attributes['ranking_options']),
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type'             => $this->type,
            'vector_store_ids' => $this->vectorStoreIds,
            'filters'          => $this->filters?->toArray(),
            'max_num_results'  => $this->maxNumResults,
            'ranking_options'  => $this->rankingOptions->toArray(),
        ];
    }
}
PK     S%W]a<xc    ?  client/src/Responses/Responses/Tool/FileSearchRankingOption.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Tool;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type RankingOptionType array{ranker: string, score_threshold: float}
 *
 * @implements ResponseContract<RankingOptionType>
 */
final class FileSearchRankingOption implements ResponseContract
{
    /**
     * @use ArrayAccessible<RankingOptionType>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public readonly string $ranker,
        public readonly float $scoreThreshold,
    ) {}

    /**
     * @param  RankingOptionType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            ranker: $attributes['ranker'],
            scoreThreshold: $attributes['score_threshold'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'ranker'          => $this->ranker,
            'score_threshold' => $this->scoreThreshold,
        ];
    }
}
PK     S%W]¤‰óZi  i  ;  client/src/Responses/Responses/Tool/ImageGenerationTool.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Tool;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-import-type InputImageMaskType from ImageGenerationInputImageMask
 *
 * @phpstan-type ImageGenerationToolType array{type: 'image_generation', background: 'transparent'|'opaque'|'auto', input_image_mask: InputImageMaskType|null, model?: ?string, moderation: string, output_compression: integer, output_format: 'png'|'webp'|'jpeg', partial_images: ?int, quality: 'low'|'medium'|'high'|'auto', size: '1024x1024'|'1024x1536'|'1536x1024'|'auto'}
 *
 * @implements ResponseContract<ImageGenerationToolType>
 */
final class ImageGenerationTool implements ResponseContract
{
    /**
     * @use ArrayAccessible<ImageGenerationToolType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'image_generation'  $type
     * @param  'transparent'|'opaque'|'auto'  $background
     * @param  'jpeg'|'png'|'webp'  $outputFormat
     * @param  'low'|'medium'|'high'|'auto'  $quality
     * @param  "1024x1024"|"1024x1536"|"1536x1024"|'auto'  $size
     */
    private function __construct(
        public readonly string $type,
        public readonly string $background,
        public readonly ?ImageGenerationInputImageMask $inputImageMask,
        public readonly ?string $model,
        public readonly string $moderation,
        public readonly int $outputCompression,
        public readonly string $outputFormat,
        public readonly int $partialImages,
        public readonly string $quality,
        public readonly string $size,
    ) {}

    /**
     * @param  ImageGenerationToolType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            type: $attributes['type'],
            background: $attributes['background'],
            inputImageMask: isset($attributes['input_image_mask'])
                ? ImageGenerationInputImageMask::from($attributes['input_image_mask'])
                : null,
            model: $attributes['model'] ?? null,
            moderation: $attributes['moderation'],
            outputCompression: $attributes['output_compression'],
            outputFormat: $attributes['output_format'],
            partialImages: $attributes['partial_images'] ?? 0,
            quality: $attributes['quality'],
            size: $attributes['size'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type'               => $this->type,
            'background'         => $this->background,
            'input_image_mask'   => $this->inputImageMask?->toArray(),
            'model'              => $this->model,
            'moderation'         => $this->moderation,
            'output_compression' => $this->outputCompression,
            'output_format'      => $this->outputFormat,
            'partial_images'     => $this->partialImages,
            'quality'            => $this->quality,
            'size'               => $this->size,
        ];
    }
}
PK     S%W]U/†  †  4  client/src/Responses/Responses/Tool/FunctionTool.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Tool;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type FunctionToolType array{name: string, parameters: array<string, mixed>, strict: bool, type: 'function', description: ?string}
 *
 * @implements ResponseContract<FunctionToolType>
 */
final class FunctionTool implements ResponseContract
{
    /**
     * @use ArrayAccessible<FunctionToolType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  array<string, mixed>  $parameters
     * @param  'function'  $type
     */
    private function __construct(
        public readonly string $name,
        public readonly array $parameters,
        public readonly bool $strict,
        public readonly string $type,
        public readonly ?string $description = null,
    ) {}

    /**
     * @param  FunctionToolType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            name: $attributes['name'],
            parameters: $attributes['parameters'],
            strict: $attributes['strict'],
            type: $attributes['type'],
            description: $attributes['description'] ?? null,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'name'        => $this->name,
            'parameters'  => $this->parameters,
            'strict'      => $this->strict,
            'type'        => $this->type,
            'description' => $this->description,
        ];
    }
}
PK     S%W]ƒª€z    E  client/src/Responses/Responses/Tool/ImageGenerationInputImageMask.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Tool;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type InputImageMaskType array{file_id: string|null, image_url: string|null}
 *
 * @implements ResponseContract<InputImageMaskType>
 */
final class ImageGenerationInputImageMask implements ResponseContract
{
    /**
     * @use ArrayAccessible<InputImageMaskType>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public readonly ?string $fileId,
        public readonly ?string $imageUrl,
    ) {}

    /**
     * @param  InputImageMaskType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            fileId: $attributes['file_id'] ?? null,
            imageUrl: $attributes['image_url'] ?? null,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'file_id'   => $this->fileId,
            'image_url' => $this->imageUrl,
        ];
    }
}
PK     S%W]këiw.  .  B  client/src/Responses/Responses/Tool/FileSearchComparisonFilter.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Tool;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type ComparisonFilterType array{key: string, type: 'eq'|'ne'|'gt'|'gte'|'lt'|'lte', value: string|int|bool}
 *
 * @implements ResponseContract<ComparisonFilterType>
 */
final class FileSearchComparisonFilter implements ResponseContract
{
    /**
     * @use ArrayAccessible<ComparisonFilterType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'eq'|'ne'|'gt'|'gte'|'lt'|'lte'  $type
     */
    private function __construct(
        public readonly string $key,
        public readonly string $type,
        public readonly string|int|bool $value,
    ) {}

    /**
     * @param  ComparisonFilterType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            key: $attributes['key'],
            type: $attributes['type'],
            value: $attributes['value'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'key'   => $this->key,
            'type'  => $this->type,
            'value' => $this->value,
        ];
    }
}
PK     S%W]m9%(  (  :  client/src/Responses/Responses/Tool/McpToolNamesFilter.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Tool;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type McpToolNamesFilterType array{tool_names: array<int, string>}
 *
 * @implements ResponseContract<McpToolNamesFilterType>
 */
final class McpToolNamesFilter implements ResponseContract
{
    /**
     * @use ArrayAccessible<McpToolNamesFilterType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  array<int, string>  $toolNames
     */
    private function __construct(
        public readonly array $toolNames,
    ) {}

    /**
     * @param  McpToolNamesFilterType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            toolNames: $attributes['tool_names'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'tool_names' => $this->toolNames,
        ];
    }
}
PK     S%W]Rˆ‚    6  client/src/Responses/Responses/CreateResponseError.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type ErrorType array{code: string, message: string}
 *
 * @implements ResponseContract<ErrorType>
 */
final class CreateResponseError implements ResponseContract
{
    /**
     * @use ArrayAccessible<ErrorType>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public readonly string $code,
        public readonly string $message
    ) {}

    /**
     * @param  ErrorType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            code: $attributes['code'],
            message: $attributes['message'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'code'    => $this->code,
            'message' => $this->message,
        ];
    }
}
PK     S%W]ùŠ¼    7  client/src/Responses/Responses/CreateResponseFormat.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Responses\Format\JsonObjectFormat;
use OpenAI\Responses\Responses\Format\JsonSchemaFormat;
use OpenAI\Responses\Responses\Format\TextFormat;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-import-type JsonObjectFormatType from JsonObjectFormat
 * @phpstan-import-type JsonSchemaFormatType from JsonSchemaFormat
 * @phpstan-import-type TextFormatType from TextFormat
 *
 * @phpstan-type ResponseFormatType array{format: TextFormatType|JsonObjectFormatType|JsonSchemaFormatType}
 *
 * @implements ResponseContract<ResponseFormatType>
 */
final class CreateResponseFormat implements ResponseContract
{
    /**
     * @use ArrayAccessible<ResponseFormatType>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public readonly TextFormat|JsonSchemaFormat|JsonObjectFormat $format
    ) {}

    /**
     * @param  ResponseFormatType  $attributes
     */
    public static function from(array $attributes): self
    {
        $format = match ($attributes['format']['type']) {
            'text'        => TextFormat::from($attributes['format']),
            'json_schema' => JsonSchemaFormat::from($attributes['format']),
            'json_object' => JsonObjectFormat::from($attributes['format']),
        };

        return new self(
            format: $format
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'format' => $this->format->toArray(),
        ];
    }
}
PK     S%W]XŠ  Š  :  client/src/Responses/Responses/CreateResponseReasoning.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type ReasoningType array{effort: ?string, generate_summary: ?string}
 *
 * @implements ResponseContract<ReasoningType>
 */
final class CreateResponseReasoning implements ResponseContract
{
    /**
     * @use ArrayAccessible<ReasoningType>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public readonly ?string $effort,
        public readonly ?string $generate_summary,
    ) {}

    /**
     * @param  ReasoningType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            effort: $attributes['effort'] ?? null,
            generate_summary: $attributes['generate_summary'] ?? null,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'effort'           => $this->effort,
            'generate_summary' => $this->generate_summary,
        ];
    }
}
PK     S%W]S«‚7  ‚7  1  client/src/Responses/Responses/CreateResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Responses\Responses\Output\OutputCodeInterpreterToolCall;
use OpenAI\Responses\Responses\Output\OutputComputerToolCall;
use OpenAI\Responses\Responses\Output\OutputFileSearchToolCall;
use OpenAI\Responses\Responses\Output\OutputFunctionToolCall;
use OpenAI\Responses\Responses\Output\OutputImageGenerationToolCall;
use OpenAI\Responses\Responses\Output\OutputMcpApprovalRequest;
use OpenAI\Responses\Responses\Output\OutputMcpCall;
use OpenAI\Responses\Responses\Output\OutputMcpListTools;
use OpenAI\Responses\Responses\Output\OutputMessage;
use OpenAI\Responses\Responses\Output\OutputMessageContentOutputText;
use OpenAI\Responses\Responses\Output\OutputReasoning;
use OpenAI\Responses\Responses\Output\OutputWebSearchToolCall;
use OpenAI\Responses\Responses\Tool\CodeInterpreterTool;
use OpenAI\Responses\Responses\Tool\ComputerUseTool;
use OpenAI\Responses\Responses\Tool\FileSearchTool;
use OpenAI\Responses\Responses\Tool\FunctionTool;
use OpenAI\Responses\Responses\Tool\ImageGenerationTool;
use OpenAI\Responses\Responses\Tool\RemoteMcpTool;
use OpenAI\Responses\Responses\Tool\WebSearchTool;
use OpenAI\Responses\Responses\ToolChoice\FunctionToolChoice;
use OpenAI\Responses\Responses\ToolChoice\HostedToolChoice;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-import-type ResponseFormatType from CreateResponseFormat
 * @phpstan-import-type OutputComputerToolCallType from OutputComputerToolCall
 * @phpstan-import-type OutputFileSearchToolCallType from OutputFileSearchToolCall
 * @phpstan-import-type OutputFunctionToolCallType from OutputFunctionToolCall
 * @phpstan-import-type OutputMessageType from OutputMessage
 * @phpstan-import-type OutputReasoningType from OutputReasoning
 * @phpstan-import-type OutputWebSearchToolCallType from OutputWebSearchToolCall
 * @phpstan-import-type OutputMcpListToolsType from OutputMcpListTools
 * @phpstan-import-type OutputMcpApprovalRequestType from OutputMcpApprovalRequest
 * @phpstan-import-type OutputMcpCallType from OutputMcpCall
 * @phpstan-import-type OutputImageGenerationToolCallType from OutputImageGenerationToolCall
 * @phpstan-import-type OutputCodeInterpreterToolCallType from OutputCodeInterpreterToolCall
 * @phpstan-import-type ComputerUseToolType from ComputerUseTool
 * @phpstan-import-type FileSearchToolType from FileSearchTool
 * @phpstan-import-type ImageGenerationToolType from ImageGenerationTool
 * @phpstan-import-type RemoteMcpToolType from RemoteMcpTool
 * @phpstan-import-type FunctionToolType from FunctionTool
 * @phpstan-import-type WebSearchToolType from WebSearchTool
 * @phpstan-import-type CodeInterpreterToolType from CodeInterpreterTool
 * @phpstan-import-type ErrorType from CreateResponseError
 * @phpstan-import-type IncompleteDetailsType from CreateResponseIncompleteDetails
 * @phpstan-import-type UsageType from CreateResponseUsage
 * @phpstan-import-type FunctionToolChoiceType from FunctionToolChoice
 * @phpstan-import-type HostedToolChoiceType from HostedToolChoice
 * @phpstan-import-type ReasoningType from CreateResponseReasoning
 * @phpstan-import-type ReferencePromptObjectType from ReferencePromptObject
 *
 * @phpstan-type InstructionsType array<int, mixed>|string|null
 * @phpstan-type ToolChoiceType 'none'|'auto'|'required'|FunctionToolChoiceType|HostedToolChoiceType
 * @phpstan-type ToolsType array<int, ComputerUseToolType|FileSearchToolType|FunctionToolType|WebSearchToolType|ImageGenerationToolType|RemoteMcpToolType|CodeInterpreterToolType>
 * @phpstan-type OutputType array<int, OutputComputerToolCallType|OutputFileSearchToolCallType|OutputFunctionToolCallType|OutputMessageType|OutputReasoningType|OutputWebSearchToolCallType|OutputMcpListToolsType|OutputMcpApprovalRequestType|OutputMcpCallType|OutputImageGenerationToolCallType|OutputCodeInterpreterToolCallType>
 * @phpstan-type CreateResponseType array{id: string, object: 'response', created_at: int, status: 'completed'|'failed'|'in_progress'|'incomplete', error: ErrorType|null, incomplete_details: IncompleteDetailsType|null, instructions: InstructionsType, max_output_tokens: int|null, model: string, output: OutputType, output_text: string|null, parallel_tool_calls: bool, previous_response_id: string|null, prompt: ReferencePromptObjectType|null, reasoning: ReasoningType|null, store: bool, temperature: float|null, text: ResponseFormatType, tool_choice: ToolChoiceType, tools: ToolsType, top_p: float|null, truncation: 'auto'|'disabled'|null, usage: UsageType|null, user: string|null, metadata: array<string, string>|null}
 *
 * @implements ResponseContract<CreateResponseType>
 */
final class CreateResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<CreateResponseType>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  'response'  $object
     * @param  'completed'|'failed'|'in_progress'|'incomplete'  $status
     * @param  array<int, mixed>|string|null  $instructions
     * @param  array<int, OutputMessage|OutputComputerToolCall|OutputFileSearchToolCall|OutputWebSearchToolCall|OutputFunctionToolCall|OutputReasoning|OutputMcpListTools|OutputMcpApprovalRequest|OutputMcpCall|OutputImageGenerationToolCall|OutputCodeInterpreterToolCall>  $output
     * @param  array<int, ComputerUseTool|FileSearchTool|FunctionTool|WebSearchTool|ImageGenerationTool|RemoteMcpTool|ImageGenerationTool|CodeInterpreterTool>  $tools
     * @param  'auto'|'disabled'|null  $truncation
     * @param  array<string, string>  $metadata
     */
    private function __construct(
        public readonly string $id,
        public readonly string $object,
        public readonly int $createdAt,
        public readonly string $status,
        public readonly ?CreateResponseError $error,
        public readonly ?CreateResponseIncompleteDetails $incompleteDetails,
        public readonly array|string|null $instructions,
        public readonly ?int $maxOutputTokens,
        public readonly string $model,
        public readonly array $output,
        public readonly ?string $outputText,
        public readonly bool $parallelToolCalls,
        public readonly ?string $previousResponseId,
        public readonly ?ReferencePromptObject $prompt,
        public readonly ?CreateResponseReasoning $reasoning,
        public readonly bool $store,
        public readonly ?float $temperature,
        public readonly CreateResponseFormat $text,
        public readonly string|FunctionToolChoice|HostedToolChoice $toolChoice,
        public readonly array $tools,
        public readonly ?float $topP,
        public readonly ?string $truncation,
        public readonly ?CreateResponseUsage $usage,
        public readonly ?string $user,
        public readonly array $metadata,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * @param  CreateResponseType  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        $output = array_map(
            fn (array $output): OutputMessage|OutputComputerToolCall|OutputFileSearchToolCall|OutputWebSearchToolCall|OutputFunctionToolCall|OutputReasoning|OutputMcpListTools|OutputMcpApprovalRequest|OutputMcpCall|OutputImageGenerationToolCall|OutputCodeInterpreterToolCall => match ($output['type']) {
                'message'               => OutputMessage::from($output),
                'file_search_call'      => OutputFileSearchToolCall::from($output),
                'function_call'         => OutputFunctionToolCall::from($output),
                'web_search_call'       => OutputWebSearchToolCall::from($output),
                'computer_call'         => OutputComputerToolCall::from($output),
                'reasoning'             => OutputReasoning::from($output),
                'mcp_list_tools'        => OutputMcpListTools::from($output),
                'mcp_approval_request'  => OutputMcpApprovalRequest::from($output),
                'mcp_call'              => OutputMcpCall::from($output),
                'image_generation_call' => OutputImageGenerationToolCall::from($output),
                'code_interpreter_call' => OutputCodeInterpreterToolCall::from($output),
            },
            $attributes['output'],
        );

        $toolChoice = is_array($attributes['tool_choice'])
            ? match ($attributes['tool_choice']['type']) {
                'file_search', 'web_search_preview', 'computer_use_preview' => HostedToolChoice::from($attributes['tool_choice']),
                'function' => FunctionToolChoice::from($attributes['tool_choice']),
            }
        : $attributes['tool_choice'];

        $tools = array_map(
            fn (array $tool): ComputerUseTool|FileSearchTool|FunctionTool|WebSearchTool|ImageGenerationTool|RemoteMcpTool|CodeInterpreterTool => match ($tool['type']) {
                'file_search' => FileSearchTool::from($tool),
                'web_search_preview', 'web_search_preview_2025_03_11' => WebSearchTool::from($tool),
                'function'             => FunctionTool::from($tool),
                'computer_use_preview' => ComputerUseTool::from($tool),
                'image_generation'     => ImageGenerationTool::from($tool),
                'mcp'                  => RemoteMcpTool::from($tool),
                'code_interpreter'     => CodeInterpreterTool::from($tool),
            },
            $attributes['tools'],
        );

        // Remake the sdk only property output_text.
        $texts = [];
        foreach ($output as $item) {
            if ($item instanceof OutputMessage) {
                foreach ($item->content as $content) {
                    if ($content instanceof OutputMessageContentOutputText) {
                        $texts[] = $content->text;
                    }
                }
            }
        }

        return new self(
            id: $attributes['id'],
            object: $attributes['object'],
            createdAt: $attributes['created_at'],
            status: $attributes['status'],
            error: isset($attributes['error'])
                ? CreateResponseError::from($attributes['error'])
                : null,
            incompleteDetails: isset($attributes['incomplete_details'])
                ? CreateResponseIncompleteDetails::from($attributes['incomplete_details'])
                : null,
            instructions: $attributes['instructions'],
            maxOutputTokens: $attributes['max_output_tokens'],
            model: $attributes['model'],
            output: $output,
            outputText: empty($texts) ? null : implode(' ', $texts),
            parallelToolCalls: $attributes['parallel_tool_calls'],
            previousResponseId: $attributes['previous_response_id'],
            prompt: isset($attributes['prompt'])
                ? ReferencePromptObject::from($attributes['prompt'])
                : null,
            reasoning: isset($attributes['reasoning'])
                ? CreateResponseReasoning::from($attributes['reasoning'])
                : null,
            store: $attributes['store'],
            temperature: $attributes['temperature'],
            text: CreateResponseFormat::from($attributes['text']),
            toolChoice: $toolChoice,
            tools: $tools,
            topP: $attributes['top_p'],
            truncation: $attributes['truncation'],
            usage: isset($attributes['usage'])
                ? CreateResponseUsage::from($attributes['usage'])
                : null,
            user: $attributes['user'] ?? null,
            metadata: $attributes['metadata'] ?? [],
            meta: $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        // https://github.com/phpstan/phpstan/issues/8438
        // @phpstan-ignore-next-line
        return [
            'id'                 => $this->id,
            'object'             => $this->object,
            'created_at'         => $this->createdAt,
            'status'             => $this->status,
            'error'              => $this->error?->toArray(),
            'incomplete_details' => $this->incompleteDetails?->toArray(),
            'instructions'       => $this->instructions,
            'max_output_tokens'  => $this->maxOutputTokens,
            'metadata'           => $this->metadata ?? [],
            'model'              => $this->model,
            'output'             => array_map(
                fn (OutputMessage|OutputComputerToolCall|OutputFileSearchToolCall|OutputWebSearchToolCall|OutputFunctionToolCall|OutputReasoning|OutputMcpListTools|OutputMcpApprovalRequest|OutputMcpCall|OutputImageGenerationToolCall|OutputCodeInterpreterToolCall $output): array => $output->toArray(),
                $this->output
            ),
            'parallel_tool_calls'  => $this->parallelToolCalls,
            'previous_response_id' => $this->previousResponseId,
            'prompt'               => $this->prompt?->toArray(),
            'reasoning'            => $this->reasoning?->toArray(),
            'store'                => $this->store,
            'temperature'          => $this->temperature,
            'text'                 => $this->text->toArray(),
            'tool_choice'          => is_string($this->toolChoice)
                ? $this->toolChoice
                : $this->toolChoice->toArray(),
            'tools' => array_map(
                fn (ComputerUseTool|FileSearchTool|FunctionTool|WebSearchTool|ImageGenerationTool|RemoteMcpTool|CodeInterpreterTool $tool): array => $tool->toArray(),
                $this->tools
            ),
            'top_p'       => $this->topP,
            'truncation'  => $this->truncation,
            'usage'       => $this->usage?->toArray(),
            'user'        => $this->user,
            'output_text' => $this->outputText,
        ];
    }
}
PK     S%W]àÎ  Î  B  client/src/Responses/Responses/CreateResponseIncompleteDetails.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type IncompleteDetailsType array{reason: string}
 *
 * @implements ResponseContract<IncompleteDetailsType>
 */
final class CreateResponseIncompleteDetails implements ResponseContract
{
    /**
     * @use ArrayAccessible<IncompleteDetailsType>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public readonly string $reason,
    ) {}

    /**
     * @param  IncompleteDetailsType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            reason: $attributes['reason'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'reason' => $this->reason,
        ];
    }
}
PK     S%W]']1ZN  N  6  client/src/Responses/Responses/CreateResponseUsage.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-import-type InputTokenDetailsType from CreateResponseUsageInputTokenDetails
 * @phpstan-import-type OutputTokenDetailsType from CreateResponseUsageOutputTokenDetails
 *
 * @phpstan-type UsageType array{input_tokens: int, input_tokens_details: InputTokenDetailsType, output_tokens: int, output_tokens_details: OutputTokenDetailsType, total_tokens: int}
 *
 * @implements ResponseContract<UsageType>
 */
final class CreateResponseUsage implements ResponseContract
{
    /**
     * @use ArrayAccessible<UsageType>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public readonly int $inputTokens,
        public readonly CreateResponseUsageInputTokenDetails $inputTokensDetails,
        public readonly int $outputTokens,
        public readonly CreateResponseUsageOutputTokenDetails $outputTokensDetails,
        public readonly int $totalTokens,
    ) {}

    /**
     * @param  UsageType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            inputTokens: $attributes['input_tokens'],
            inputTokensDetails: CreateResponseUsageInputTokenDetails::from($attributes['input_tokens_details']),
            outputTokens: $attributes['output_tokens'],
            outputTokensDetails: CreateResponseUsageOutputTokenDetails::from($attributes['output_tokens_details']),
            totalTokens: $attributes['total_tokens'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'input_tokens'          => $this->inputTokens,
            'input_tokens_details'  => $this->inputTokensDetails->toArray(),
            'output_tokens'         => $this->outputTokens,
            'output_tokens_details' => $this->outputTokensDetails->toArray(),
            'total_tokens'          => $this->totalTokens,
        ];
    }
}
PK     S%W]L=Šw  w  @  client/src/Responses/Responses/Output/OutputReasoningSummary.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Output;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type ReasoningSummaryType array{text: string, type: 'summary_text'}
 *
 * @implements ResponseContract<ReasoningSummaryType>
 */
final class OutputReasoningSummary implements ResponseContract
{
    /**
     * @use ArrayAccessible<ReasoningSummaryType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'summary_text'  $type
     */
    private function __construct(
        public readonly string $text,
        public readonly string $type,
    ) {}

    /**
     * @param  ReasoningSummaryType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            text: $attributes['text'],
            type: $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'text' => $this->text,
            'type' => $this->type,
        ];
    }
}
PK     S%W]¡€&Â@  @  @  client/src/Responses/Responses/Output/OutputComputerToolCall.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Output;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Responses\Output\ComputerAction\OutputComputerActionClick as Click;
use OpenAI\Responses\Responses\Output\ComputerAction\OutputComputerActionDoubleClick as DoubleClick;
use OpenAI\Responses\Responses\Output\ComputerAction\OutputComputerActionDrag as Drag;
use OpenAI\Responses\Responses\Output\ComputerAction\OutputComputerActionKeyPress as KeyPress;
use OpenAI\Responses\Responses\Output\ComputerAction\OutputComputerActionMove as Move;
use OpenAI\Responses\Responses\Output\ComputerAction\OutputComputerActionScreenshot as Screenshot;
use OpenAI\Responses\Responses\Output\ComputerAction\OutputComputerActionScroll as Scroll;
use OpenAI\Responses\Responses\Output\ComputerAction\OutputComputerActionType as Type;
use OpenAI\Responses\Responses\Output\ComputerAction\OutputComputerActionWait as Wait;
use OpenAI\Responses\Responses\Output\ComputerAction\OutputComputerPendingSafetyCheck;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-import-type ClickType from Click
 * @phpstan-import-type DoubleClickType from DoubleClick
 * @phpstan-import-type DragType from Drag
 * @phpstan-import-type KeyPressType from KeyPress
 * @phpstan-import-type MoveType from Move
 * @phpstan-import-type ScreenshotType from Screenshot
 * @phpstan-import-type ScrollType from Scroll
 * @phpstan-import-type TypeType from Type
 * @phpstan-import-type WaitType from Wait
 * @phpstan-import-type PendingSafetyCheckType from OutputComputerPendingSafetyCheck
 *
 * @phpstan-type OutputComputerToolCallType array{action: ClickType|DoubleClickType|DragType|KeyPressType|MoveType|ScreenshotType|ScrollType|TypeType|WaitType, call_id: string, id: string, pending_safety_checks: array<int, PendingSafetyCheckType>, status: 'in_progress'|'completed'|'incomplete', type: 'computer_call'}
 *
 * @implements ResponseContract<OutputComputerToolCallType>
 */
final class OutputComputerToolCall implements ResponseContract
{
    /**
     * @use ArrayAccessible<OutputComputerToolCallType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  array<int, OutputComputerPendingSafetyCheck>  $pendingSafetyChecks
     * @param  'in_progress'|'completed'|'incomplete'  $status
     * @param  'computer_call'  $type
     */
    private function __construct(
        public readonly Click|DoubleClick|Drag|KeyPress|Move|Screenshot|Scroll|Type|Wait $action,
        public readonly string $callId,
        public readonly string $id,
        public readonly array $pendingSafetyChecks,
        public readonly string $status,
        public readonly string $type,
    ) {}

    /**
     * @param  OutputComputerToolCallType  $attributes
     */
    public static function from(array $attributes): self
    {
        $action = match ($attributes['action']['type']) {
            'click'        => Click::from($attributes['action']),
            'double_click' => DoubleClick::from($attributes['action']),
            'drag'         => Drag::from($attributes['action']),
            'keypress'     => KeyPress::from($attributes['action']),
            'move'         => Move::from($attributes['action']),
            'screenshot'   => Screenshot::from($attributes['action']),
            'scroll'       => Scroll::from($attributes['action']),
            'type'         => Type::from($attributes['action']),
            'wait'         => Wait::from($attributes['action']),
        };

        $pendingSafetyChecks = array_map(
            fn (array $safetyCheck): OutputComputerPendingSafetyCheck => OutputComputerPendingSafetyCheck::from($safetyCheck),
            $attributes['pending_safety_checks']
        );

        return new self(
            action: $action,
            callId: $attributes['call_id'],
            id: $attributes['id'],
            pendingSafetyChecks: $pendingSafetyChecks,
            status: $attributes['status'],
            type: $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type'                  => $this->type,
            'call_id'               => $this->callId,
            'id'                    => $this->id,
            'action'                => $this->action->toArray(),
            'pending_safety_checks' => array_map(
                fn (OutputComputerPendingSafetyCheck $safetyCheck): array => $safetyCheck->toArray(),
                $this->pendingSafetyChecks,
            ),
            'status' => $this->status,
        ];
    }
}
PK     S%W]žm˜Š	  Š	  7  client/src/Responses/Responses/Output/OutputMessage.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Output;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-import-type OutputTextType from OutputMessageContentOutputText
 * @phpstan-import-type ContentRefusalType from OutputMessageContentRefusal
 *
 * @phpstan-type OutputMessageType array{content: array<int, OutputTextType|ContentRefusalType>, id: string, role: 'assistant', status: 'in_progress'|'completed'|'incomplete', type: 'message'}
 *
 * @implements ResponseContract<OutputMessageType>
 */
final class OutputMessage implements ResponseContract
{
    /**
     * @use ArrayAccessible<OutputMessageType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  array<int, OutputMessageContentOutputText|OutputMessageContentRefusal>  $content
     * @param  'assistant'  $role
     * @param  'in_progress'|'completed'|'incomplete'  $status
     * @param  'message'  $type
     */
    private function __construct(
        public readonly array $content,
        public readonly string $id,
        public readonly string $role,
        public readonly string $status,
        public readonly string $type,
    ) {}

    /**
     * @param  OutputMessageType  $attributes
     */
    public static function from(array $attributes): self
    {
        $content = array_map(
            fn (array $item): OutputMessageContentOutputText|OutputMessageContentRefusal => match ($item['type']) {
                'output_text' => OutputMessageContentOutputText::from($item),
                'refusal'     => OutputMessageContentRefusal::from($item),
            },
            $attributes['content'],
        );

        return new self(
            content: $content,
            id: $attributes['id'],
            role: $attributes['role'],
            status: $attributes['status'],
            type: $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'content' => array_map(
                fn (OutputMessageContentOutputText|OutputMessageContentRefusal $item): array => $item->toArray(),
                $this->content,
            ),
            'id'     => $this->id,
            'role'   => $this->role,
            'status' => $this->status,
            'type'   => $this->type,
        ];
    }
}
PK     S%W]–¥R\+  +  @  client/src/Responses/Responses/Output/OutputFunctionToolCall.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Output;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type OutputFunctionToolCallType array{arguments: string, call_id: string, name: string, type: 'function_call', id: string, status: 'in_progress'|'completed'|'incomplete'}
 *
 * @implements ResponseContract<OutputFunctionToolCallType>
 */
final class OutputFunctionToolCall implements ResponseContract
{
    /**
     * @use ArrayAccessible<OutputFunctionToolCallType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'function_call'  $type
     * @param  'in_progress'|'completed'|'incomplete'  $status
     */
    private function __construct(
        public readonly string $arguments,
        public readonly string $callId,
        public readonly string $name,
        public readonly string $type,
        public readonly string $id,
        public readonly string $status,
    ) {}

    /**
     * @param  OutputFunctionToolCallType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            arguments: $attributes['arguments'],
            callId: $attributes['call_id'],
            name: $attributes['name'],
            type: $attributes['type'],
            id: $attributes['id'],
            status: $attributes['status'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'arguments' => $this->arguments,
            'call_id'   => $this->callId,
            'name'      => $this->name,
            'type'      => $this->type,
            'id'        => $this->id,
            'status'    => $this->status,
        ];
    }
}
PK     S%W]Ð¾ïü£  £  H  client/src/Responses/Responses/Output/OutputFileSearchToolCallResult.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Output;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type OutputFileSearchToolCallResultType array{attributes: array<string, string>, file_id: string, filename: string, score: float, text: string}
 *
 * @implements ResponseContract<OutputFileSearchToolCallResultType>
 */
final class OutputFileSearchToolCallResult implements ResponseContract
{
    /**
     * @use ArrayAccessible<OutputFileSearchToolCallResultType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  array<string, string>  $attributes
     */
    private function __construct(
        public readonly array $attributes,
        public readonly string $fileId,
        public readonly string $filename,
        public readonly float $score,
        public readonly string $text,
    ) {}

    /**
     * @param  OutputFileSearchToolCallResultType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            attributes: $attributes['attributes'],
            fileId: $attributes['file_id'],
            filename: $attributes['filename'],
            score: $attributes['score'],
            text: $attributes['text'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'attributes' => $this->attributes,
            'file_id'    => $this->fileId,
            'filename'   => $this->filename,
            'score'      => $this->score,
            'text'       => $this->text,
        ];
    }
}
PK     S%W]²ô²OL  L  `  client/src/Responses/Responses/Output/OutputMessageContentOutputTextAnnotationsContainerFile.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Output;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type ContainerFileType array{file_id: string, type: 'container_file_citation', text?: string, start_index?: int, end_index?: int}
 *
 * @implements ResponseContract<ContainerFileType>
 */
final class OutputMessageContentOutputTextAnnotationsContainerFile implements ResponseContract
{
    /**
     * @use ArrayAccessible<ContainerFileType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'container_file_citation'  $type
     */
    private function __construct(
        public readonly string $fileId,
        public readonly string $type,
        public readonly ?string $text,
        public readonly ?int $startIndex,
        public readonly ?int $endIndex,
    ) {}

    /**
     * @param  ContainerFileType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            fileId: $attributes['file_id'],
            type: $attributes['type'],
            text: $attributes['text'] ?? null,
            startIndex: $attributes['start_index'] ?? null,
            endIndex: $attributes['end_index'] ?? null,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        $result = [
            'file_id' => $this->fileId,
            'type'    => $this->type,
        ];

        if ($this->text !== null) {
            $result['text'] = $this->text;
        }

        if ($this->startIndex !== null) {
            $result['start_index'] = $this->startIndex;
        }

        if ($this->endIndex !== null) {
            $result['end_index'] = $this->endIndex;
        }

        return $result;
    }
}
PK     S%W]Uq«  «  9  client/src/Responses/Responses/Output/OutputReasoning.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Output;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-import-type ReasoningSummaryType from OutputReasoningSummary
 *
 * @phpstan-type OutputReasoningType array{id: string, summary: array<int, ReasoningSummaryType>, type: 'reasoning', encrypted_content: string|null, status?: 'in_progress'|'completed'|'incomplete'|null}
 *
 * @implements ResponseContract<OutputReasoningType>
 */
final class OutputReasoning implements ResponseContract
{
    /**
     * @use ArrayAccessible<OutputReasoningType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  array<int, OutputReasoningSummary>  $summary
     * @param  'reasoning'  $type
     * @param  'in_progress'|'completed'|'incomplete'|null  $status
     */
    private function __construct(
        public readonly string $id,
        public readonly array $summary,
        public readonly string $type,
        public readonly ?string $encryptedContent,
        public readonly ?string $status,
    ) {}

    /**
     * @param  OutputReasoningType  $attributes
     */
    public static function from(array $attributes): self
    {
        $summary = array_map(
            static fn (array $summary): OutputReasoningSummary => OutputReasoningSummary::from($summary),
            $attributes['summary'],
        );

        return new self(
            id: $attributes['id'],
            summary: $summary,
            type: $attributes['type'],
            encryptedContent: $attributes['encrypted_content'] ?? null,
            status: $attributes['status'] ?? null,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'      => $this->id,
            'summary' => array_map(
                static fn (OutputReasoningSummary $summary): array => $summary->toArray(),
                $this->summary,
            ),
            'type'              => $this->type,
            'encrypted_content' => $this->encryptedContent,
            'status'            => $this->status,
        ];
    }
}
PK     S%W]Ÿäûœ  œ  Q  client/src/Responses/Responses/Output/ComputerAction/OutputComputerActionMove.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Output\ComputerAction;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type MoveType array{type: 'move', x: int, y: int}
 *
 * @implements ResponseContract<MoveType>
 */
final class OutputComputerActionMove implements ResponseContract
{
    /**
     * @use ArrayAccessible<MoveType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'move'  $type
     */
    private function __construct(
        public readonly string $type,
        public readonly int $x,
        public readonly int $y,
    ) {}

    /**
     * @param  MoveType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            type: $attributes['type'],
            x: $attributes['x'],
            y: $attributes['y'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type' => $this->type,
            'x'    => $this->x,
            'y'    => $this->y,
        ];
    }
}
PK     S%W]Ú2³ô  ô  W  client/src/Responses/Responses/Output/ComputerAction/OutputComputerActionScreenshot.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Output\ComputerAction;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type ScreenshotType array{type: 'screenshot'}
 *
 * @implements ResponseContract<ScreenshotType>
 */
final class OutputComputerActionScreenshot implements ResponseContract
{
    /**
     * @use ArrayAccessible<ScreenshotType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'screenshot'  $type
     */
    private function __construct(
        public readonly string $type,
    ) {}

    /**
     * @param  ScreenshotType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            type: $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type' => $this->type,
        ];
    }
}
PK     S%W]¦!î¥Ð  Ð  S  client/src/Responses/Responses/Output/ComputerAction/OutputComputerActionScroll.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Output\ComputerAction;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type ScrollType array{scroll_x: int, scroll_y: int, type: 'scroll', x: int, y: int}
 *
 * @implements ResponseContract<ScrollType>
 */
final class OutputComputerActionScroll implements ResponseContract
{
    /**
     * @use ArrayAccessible<ScrollType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'scroll'  $type
     */
    private function __construct(
        public readonly int $scrollX,
        public readonly int $scrollY,
        public readonly string $type,
        public readonly int $x,
        public readonly int $y,
    ) {}

    /**
     * @param  ScrollType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            scrollX: $attributes['scroll_x'],
            scrollY: $attributes['scroll_y'],
            type: $attributes['type'],
            x: $attributes['x'],
            y: $attributes['y'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'scroll_x' => $this->scrollX,
            'scroll_y' => $this->scrollY,
            'type'     => $this->type,
            'x'        => $this->x,
            'y'        => $this->y,
        ];
    }
}
PK     S%W]dN’ZH  H  Q  client/src/Responses/Responses/Output/ComputerAction/OutputComputerActionType.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Output\ComputerAction;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type TypeType array{text: string, type: 'type'}
 *
 * @implements ResponseContract<TypeType>
 */
final class OutputComputerActionType implements ResponseContract
{
    /**
     * @use ArrayAccessible<TypeType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'type'  $type
     */
    private function __construct(
        public readonly string $text,
        public readonly string $type,
    ) {}

    /**
     * @param  TypeType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            text: $attributes['text'],
            type: $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'text' => $this->text,
            'type' => $this->type,
        ];
    }
}
PK     S%W]1#½hç  ç  Y  client/src/Responses/Responses/Output/ComputerAction/OutputComputerPendingSafetyCheck.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Output\ComputerAction;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type PendingSafetyCheckType array{code: string, id: string, message: string}
 *
 * @implements ResponseContract<PendingSafetyCheckType>
 */
final class OutputComputerPendingSafetyCheck implements ResponseContract
{
    /**
     * @use ArrayAccessible<PendingSafetyCheckType>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public readonly string $code,
        public readonly string $id,
        public readonly string $message,
    ) {}

    /**
     * @param  PendingSafetyCheckType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            code: $attributes['code'],
            id: $attributes['id'],
            message: $attributes['message'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'code'    => $this->code,
            'id'      => $this->id,
            'message' => $this->message,
        ];
    }
}
PK     S%W]¡¥‚Ê  Ê  Q  client/src/Responses/Responses/Output/ComputerAction/OutputComputerActionWait.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Output\ComputerAction;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type WaitType array{type: 'wait'}
 *
 * @implements ResponseContract<WaitType>
 */
final class OutputComputerActionWait implements ResponseContract
{
    /**
     * @use ArrayAccessible<WaitType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'wait'  $type
     */
    private function __construct(
        public readonly string $type,
    ) {}

    /**
     * @param  WaitType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            type: $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type' => $this->type,
        ];
    }
}
PK     S%W]í+ìË×  ×  X  client/src/Responses/Responses/Output/ComputerAction/OutputComputerActionDoubleClick.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Output\ComputerAction;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type DoubleClickType array{type: 'double_click', x: float, y: float}
 *
 * @implements ResponseContract<DoubleClickType>
 */
final class OutputComputerActionDoubleClick implements ResponseContract
{
    /**
     * @use ArrayAccessible<DoubleClickType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'double_click'  $type
     */
    private function __construct(
        public readonly string $type,
        public readonly float $x,
        public readonly float $y,
    ) {}

    /**
     * @param  DoubleClickType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            type: $attributes['type'],
            x: $attributes['x'],
            y: $attributes['y'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type' => $this->type,
            'x'    => $this->x,
            'y'    => $this->y,
        ];
    }
}
PK     S%W]¼37˜  ˜  U  client/src/Responses/Responses/Output/ComputerAction/OutputComputerActionKeyPress.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Output\ComputerAction;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type KeyPressType array{keys: array<int, string>, type: 'keypress'}
 *
 * @implements ResponseContract<KeyPressType>
 */
final class OutputComputerActionKeyPress implements ResponseContract
{
    /**
     * @use ArrayAccessible<KeyPressType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  array<int, string>  $keys
     * @param  'keypress'  $type
     */
    private function __construct(
        public readonly array $keys,
        public readonly string $type,
    ) {}

    /**
     * @param  KeyPressType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            keys: $attributes['keys'],
            type: $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'keys' => $this->keys,
            'type' => $this->type,
        ];
    }
}
PK     S%W]?w”õ  õ  Q  client/src/Responses/Responses/Output/ComputerAction/OutputComputerActionDrag.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Output\ComputerAction;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-import-type DragPathType from OutputComputerDragPath
 *
 * @phpstan-type DragType array{path: array<int, DragPathType>, type: 'drag'}
 *
 * @implements ResponseContract<DragType>
 */
final class OutputComputerActionDrag implements ResponseContract
{
    /**
     * @use ArrayAccessible<DragType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  array<int, OutputComputerDragPath>  $path
     * @param  'drag'  $type
     */
    private function __construct(
        public readonly array $path,
        public readonly string $type,
    ) {}

    /**
     * @param  DragType  $attributes
     */
    public static function from(array $attributes): self
    {
        $paths = array_map(
            static fn (array $path): OutputComputerDragPath => OutputComputerDragPath::from($path),
            $attributes['path'],
        );

        return new self(
            path: $paths,
            type: $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'path' => array_map(
                static fn (OutputComputerDragPath $path): array => $path->toArray(),
                $this->path,
            ),
            'type' => $this->type,
        ];
    }
}
PK     S%W]Í=”  ”  R  client/src/Responses/Responses/Output/ComputerAction/OutputComputerActionClick.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Output\ComputerAction;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type ClickType array{button: 'left'|'right'|'wheel'|'back'|'forward', type: 'click', x: int, y: int}
 *
 * @implements ResponseContract<ClickType>
 */
final class OutputComputerActionClick implements ResponseContract
{
    /**
     * @use ArrayAccessible<ClickType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'left'|'right'|'wheel'|'back'|'forward'  $button
     * @param  'click'  $type
     */
    private function __construct(
        public readonly string $button,
        public readonly string $type,
        public readonly int $x,
        public readonly int $y,
    ) {}

    /**
     * @param  ClickType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            button: $attributes['button'],
            type: $attributes['type'],
            x: $attributes['x'],
            y: $attributes['y'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'button' => $this->button,
            'type'   => $this->type,
            'x'      => $this->x,
            'y'      => $this->y,
        ];
    }
}
PK     S%W]c\ù  ù  O  client/src/Responses/Responses/Output/ComputerAction/OutputComputerDragPath.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Output\ComputerAction;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type DragPathType array{x: int, y: int}
 *
 * @implements ResponseContract<DragPathType>
 */
final class OutputComputerDragPath implements ResponseContract
{
    /**
     * @use ArrayAccessible<DragPathType>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public readonly int $x,
        public readonly int $y,
    ) {}

    /**
     * @param  DragPathType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            x: $attributes['x'],
            y: $attributes['y'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'x' => $this->x,
            'y' => $this->y,
        ];
    }
}
PK     S%W]w,ü„ä
  ä
  G  client/src/Responses/Responses/Output/OutputCodeInterpreterToolCall.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Output;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Responses\Output\CodeInterpreter\CodeFileOutput;
use OpenAI\Responses\Responses\Output\CodeInterpreter\CodeTextOutput;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-import-type CodeFileOutputType from CodeFileOutput
 * @phpstan-import-type CodeTextOutputType from CodeTextOutput
 *
 * @phpstan-type OutputType array<int, CodeFileOutputType|CodeTextOutputType>|null
 * @phpstan-type OutputCodeInterpreterToolCallType array{code: string, id: string, outputs: OutputType, status: string, type: 'code_interpreter_call', container_id: string}
 *
 * @implements ResponseContract<OutputCodeInterpreterToolCallType>
 */
final class OutputCodeInterpreterToolCall implements ResponseContract
{
    /**
     * @use ArrayAccessible<OutputCodeInterpreterToolCallType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  array<int, CodeFileOutput|CodeTextOutput>|null  $outputs
     * @param  'code_interpreter_call'  $type
     */
    private function __construct(
        public readonly string $code,
        public readonly string $id,
        public readonly ?array $outputs,
        public readonly string $status,
        public readonly string $type,
        public readonly string $containerId,
    ) {}

    /**
     * @param  OutputCodeInterpreterToolCallType  $attributes
     */
    public static function from(array $attributes): self
    {
        $outputs = null;

        if (is_array($attributes['outputs'])) {
            $outputs = array_map(
                static fn (array $output): CodeFileOutput|CodeTextOutput => match ($output['type']) {
                    'files' => CodeFileOutput::from($output),
                    'logs'  => CodeTextOutput::from($output),
                },
                $attributes['outputs']
            );
        }

        return new self(
            code: $attributes['code'],
            id: $attributes['id'],
            outputs: $outputs,
            status: $attributes['status'],
            type: $attributes['type'],
            containerId: $attributes['container_id'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'code'    => $this->code,
            'id'      => $this->id,
            'outputs' => $this->outputs
                ? array_map(static fn (CodeFileOutput|CodeTextOutput $output): array => $output->toArray(), $this->outputs)
                : null,
            'status'       => $this->status,
            'type'         => $this->type,
            'container_id' => $this->containerId,
        ];
    }
}
PK     S%W]òî·¥E  E  H  client/src/Responses/Responses/Output/OutputMessageContentOutputText.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Output;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Responses\Output\OutputMessageContentOutputTextAnnotationsContainerFile as AnnotationContainerFile;
use OpenAI\Responses\Responses\Output\OutputMessageContentOutputTextAnnotationsFileCitation as AnnotationFileCitation;
use OpenAI\Responses\Responses\Output\OutputMessageContentOutputTextAnnotationsFilePath as AnnotationFilePath;
use OpenAI\Responses\Responses\Output\OutputMessageContentOutputTextAnnotationsUrlCitation as AnnotationUrlCitation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-import-type ContainerFileType from OutputMessageContentOutputTextAnnotationsContainerFile
 * @phpstan-import-type FileCitationType from OutputMessageContentOutputTextAnnotationsFileCitation
 * @phpstan-import-type FilePathType from OutputMessageContentOutputTextAnnotationsFilePath
 * @phpstan-import-type UrlCitationType from OutputMessageContentOutputTextAnnotationsUrlCitation
 *
 * @phpstan-type OutputTextType array{annotations: array<int, ContainerFileType|FileCitationType|FilePathType|UrlCitationType>, text: string, type: 'output_text'}
 *
 * @implements ResponseContract<OutputTextType>
 */
final class OutputMessageContentOutputText implements ResponseContract
{
    /**
     * @use ArrayAccessible<OutputTextType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  array<int, AnnotationContainerFile|AnnotationFileCitation|AnnotationFilePath|AnnotationUrlCitation>  $annotations
     * @param  'output_text'  $type
     */
    private function __construct(
        public readonly array $annotations,
        public readonly string $text,
        public readonly string $type
    ) {}

    /**
     * @param  OutputTextType  $attributes
     */
    public static function from(array $attributes): self
    {
        $annotations = array_map(
            fn (array $annotation): AnnotationFileCitation|AnnotationFilePath|AnnotationUrlCitation|AnnotationContainerFile => match ($annotation['type']) {
                'file_citation'           => AnnotationFileCitation::from($annotation),
                'file_path'               => AnnotationFilePath::from($annotation),
                'url_citation'            => AnnotationUrlCitation::from($annotation),
                'container_file_citation' => AnnotationContainerFile::from($annotation),
            },
            $attributes['annotations'],
        );

        return new self(
            annotations: $annotations,
            text: $attributes['text'],
            type: $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'annotations' => array_map(
                fn (AnnotationContainerFile|AnnotationFileCitation|AnnotationFilePath|AnnotationUrlCitation $annotation): array => $annotation->toArray(),
                $this->annotations,
            ),
            'text' => $this->text,
            'type' => $this->type,
        ];
    }
}
PK     S%W]Y‚i~    B  client/src/Responses/Responses/Output/OutputMcpApprovalRequest.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Output;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type OutputMcpApprovalRequestType array{id: string, server_label: string, name: string, arguments: string, type: 'mcp_approval_request'}
 *
 * @implements ResponseContract<OutputMcpApprovalRequestType>
 */
final class OutputMcpApprovalRequest implements ResponseContract
{
    /**
     * @use ArrayAccessible<OutputMcpApprovalRequestType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'mcp_approval_request'  $type
     */
    private function __construct(
        public readonly string $id,
        public readonly string $serverLabel,
        public readonly string $name,
        public readonly string $arguments,
        public readonly string $type,
    ) {}

    /**
     * @param  OutputMcpApprovalRequestType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            id: $attributes['id'],
            serverLabel: $attributes['server_label'],
            name: $attributes['name'],
            arguments: $attributes['arguments'],
            type: $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'           => $this->id,
            'server_label' => $this->serverLabel,
            'type'         => $this->type,
            'arguments'    => $this->arguments,
            'name'         => $this->name,
        ];
    }
}
PK     S%W]4mþçg  g  H  client/src/Responses/Responses/Output/CodeInterpreter/CodeTextOutput.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Output\CodeInterpreter;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type CodeTextOutputType array{logs: string, type: 'logs'}
 *
 * @implements ResponseContract<CodeTextOutputType>
 */
final class CodeTextOutput implements ResponseContract
{
    /**
     * @use ArrayAccessible<CodeTextOutputType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'logs'  $type
     */
    private function __construct(
        public readonly string $logs,
        public readonly string $type,
    ) {}

    /**
     * @param  CodeTextOutputType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            logs: $attributes['logs'],
            type: $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type' => $this->type,
            'logs' => $this->logs,
        ];
    }
}
PK     S%W]y'      H  client/src/Responses/Responses/Output/CodeInterpreter/CodeFileOutput.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Output\CodeInterpreter;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-import-type CodeFileObjectType from CodeFileObject
 *
 * @phpstan-type CodeFileOutputType array{files: array<int, CodeFileObjectType>, type: 'files'}
 *
 * @implements ResponseContract<CodeFileOutputType>
 */
final class CodeFileOutput implements ResponseContract
{
    /**
     * @use ArrayAccessible<CodeFileOutputType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  array<int, CodeFileObject>  $files
     * @param  'files'  $type
     */
    private function __construct(
        public readonly array $files,
        public readonly string $type,
    ) {}

    /**
     * @param  CodeFileOutputType  $attributes
     */
    public static function from(array $attributes): self
    {
        $files = array_map(
            static fn (array $file): CodeFileObject => CodeFileObject::from($file),
            $attributes['files']
        );

        return new self(
            files: $files,
            type: $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type'  => $this->type,
            'files' => array_map(
                static fn (CodeFileObject $file): array => $file->toArray(),
                $this->files
            ),
        ];
    }
}
PK     S%W]»“äf  f  H  client/src/Responses/Responses/Output/CodeInterpreter/CodeFileObject.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Output\CodeInterpreter;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type CodeFileObjectType array{file_id: string, mime_type: string}
 *
 * @implements ResponseContract<CodeFileObjectType>
 */
final class CodeFileObject implements ResponseContract
{
    /**
     * @use ArrayAccessible<CodeFileObjectType>
     */
    use ArrayAccessible;

    use Fakeable;

    private function __construct(
        public readonly string $fileId,
        public readonly string $mimeType,
    ) {}

    /**
     * @param  CodeFileObjectType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            fileId: $attributes['file_id'],
            mimeType: $attributes['mime_type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'file_id'   => $this->fileId,
            'mime_type' => $this->mimeType,
        ];
    }
}
PK     S%W]ªx£âl  l  _  client/src/Responses/Responses/Output/OutputMessageContentOutputTextAnnotationsFileCitation.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Output;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type FileCitationType array{file_id: string, index: int, type: 'file_citation'}
 *
 * @implements ResponseContract<FileCitationType>
 */
final class OutputMessageContentOutputTextAnnotationsFileCitation implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{file_id: string, index: int, type: 'file_citation'}>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'file_citation'  $type
     */
    private function __construct(
        public readonly string $fileId,
        public readonly int $index,
        public readonly string $type,
    ) {}

    /**
     * @param  array{file_id: string, index: int, type: 'file_citation'}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            fileId: $attributes['file_id'],
            index: $attributes['index'],
            type: $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'file_id' => $this->fileId,
            'index'   => $this->index,
            'type'    => $this->type,
        ];
    }
}
PK     S%W]Øa¬Þþ  þ  [  client/src/Responses/Responses/Output/OutputMessageContentOutputTextAnnotationsFilePath.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Output;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type FilePathType array{file_id: string, index: int, type: 'file_path'}
 *
 * @implements ResponseContract<FilePathType>
 */
final class OutputMessageContentOutputTextAnnotationsFilePath implements ResponseContract
{
    /**
     * @use ArrayAccessible<FilePathType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'file_path'  $type
     */
    private function __construct(
        public readonly string $fileId,
        public readonly int $index,
        public readonly string $type,
    ) {}

    /**
     * @param  FilePathType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            fileId: $attributes['file_id'],
            index: $attributes['index'],
            type: $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'file_id' => $this->fileId,
            'index'   => $this->index,
            'type'    => $this->type,
        ];
    }
}
PK     S%W]õÀD>]	  ]	  B  client/src/Responses/Responses/Output/OutputFileSearchToolCall.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Output;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-import-type OutputFileSearchToolCallResultType from OutputFileSearchToolCallResult
 *
 * @phpstan-type OutputFileSearchToolCallType array{id: string, queries: array<int, string>, status: 'in_progress'|'searching'|'incomplete'|'failed', type: 'file_search_call', results: ?array<int, OutputFileSearchToolCallResultType>}
 *
 * @implements ResponseContract<OutputFileSearchToolCallType>
 */
final class OutputFileSearchToolCall implements ResponseContract
{
    /**
     * @use ArrayAccessible<OutputFileSearchToolCallType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  array<int, string>  $queries
     * @param  'in_progress'|'searching'|'incomplete'|'failed'  $status
     * @param  'file_search_call'  $type
     * @param  ?array<int, OutputFileSearchToolCallResult>  $results
     */
    private function __construct(
        public readonly string $id,
        public readonly array $queries,
        public readonly string $status,
        public readonly string $type,
        public readonly ?array $results = null,
    ) {}

    /**
     * @param  OutputFileSearchToolCallType  $attributes
     */
    public static function from(array $attributes): self
    {
        $results = isset($attributes['results'])
            ? array_map(
                fn (array $result): OutputFileSearchToolCallResult => OutputFileSearchToolCallResult::from($result),
                $attributes['results']
            )
            : null;

        return new self(
            id: $attributes['id'],
            queries: $attributes['queries'],
            status: $attributes['status'],
            type: $attributes['type'],
            results: $results,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'      => $this->id,
            'queries' => $this->queries,
            'status'  => $this->status,
            'type'    => $this->type,
            'results' => isset($this->results) ? array_map(
                fn (OutputFileSearchToolCallResult $result) => $result->toArray(),
                $this->results
            ) : null,
        ];
    }
}
PK     S%W]Ü7Aáá  á  G  client/src/Responses/Responses/Output/OutputImageGenerationToolCall.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Output;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type OutputImageGenerationToolCallType array{id: string, result?: string|null, status: string, type: 'image_generation_call'}
 *
 * @implements ResponseContract<OutputImageGenerationToolCallType>
 */
final class OutputImageGenerationToolCall implements ResponseContract
{
    /**
     * @use ArrayAccessible<OutputImageGenerationToolCallType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'image_generation_call'  $type
     */
    private function __construct(
        public readonly string $id,
        public readonly ?string $result,
        public readonly string $status,
        public readonly string $type,
    ) {}

    /**
     * @param  OutputImageGenerationToolCallType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            id: $attributes['id'],
            result: $attributes['result'] ?? null,
            status: $attributes['status'],
            type: $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'     => $this->id,
            'result' => $this->result,
            'status' => $this->status,
            'type'   => $this->type,
        ];
    }
}
PK     S%W]YBª    E  client/src/Responses/Responses/Output/OutputMessageContentRefusal.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Output;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type ContentRefusalType array{refusal: string, type: 'refusal'}
 *
 * @implements ResponseContract<ContentRefusalType>
 */
final class OutputMessageContentRefusal implements ResponseContract
{
    /**
     * @use ArrayAccessible<ContentRefusalType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'refusal'  $type
     */
    private function __construct(
        public readonly string $refusal,
        public readonly string $type,
    ) {}

    /**
     * @param  ContentRefusalType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            refusal: $attributes['refusal'],
            type: $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'refusal' => $this->refusal,
            'type'    => $this->type,
        ];
    }
}
PK     S%W]¹bLr  r  <  client/src/Responses/Responses/Output/OutputMcpListTools.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Output;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-import-type OutputMcpListToolsToolType from OutputMcpListToolsTool
 *
 * @phpstan-type OutputMcpListToolsType array{id: string, server_label: string, type: 'mcp_list_tools', tools: array<int, OutputMcpListToolsToolType>}
 *
 * @implements ResponseContract<OutputMcpListToolsType>
 */
final class OutputMcpListTools implements ResponseContract
{
    /**
     * @use ArrayAccessible<OutputMcpListToolsType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'mcp_list_tools'  $type
     * @param  array<int, OutputMcpListToolsTool>  $tools
     */
    private function __construct(
        public readonly string $id,
        public readonly string $serverLabel,
        public readonly string $type,
        public readonly array $tools,
    ) {}

    /**
     * @param  OutputMcpListToolsType  $attributes
     */
    public static function from(array $attributes): self
    {
        $tools = array_map(
            fn (array $result): OutputMcpListToolsTool => OutputMcpListToolsTool::from($result),
            $attributes['tools']
        );

        return new self(
            id: $attributes['id'],
            serverLabel: $attributes['server_label'],
            type: $attributes['type'],
            tools: $tools,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'           => $this->id,
            'server_label' => $this->serverLabel,
            'type'         => $this->type,
            'tools'        => array_map(
                fn (OutputMcpListToolsTool $tool) => $tool->toArray(),
                $this->tools
            ),
        ];
    }
}
PK     S%W]°G"i  i  7  client/src/Responses/Responses/Output/OutputMcpCall.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Output;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type OutputMcpCallType array{id: string, server_label: string, type: 'mcp_call', approval_request_id: ?string, arguments: string, error: ?string, name: string, output: ?string}
 *
 * @implements ResponseContract<OutputMcpCallType>
 */
final class OutputMcpCall implements ResponseContract
{
    /**
     * @use ArrayAccessible<OutputMcpCallType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'mcp_call'  $type
     */
    private function __construct(
        public readonly string $id,
        public readonly string $serverLabel,
        public readonly string $type,
        public readonly string $arguments,
        public readonly string $name,
        public readonly ?string $approvalRequestId = null,
        public readonly ?string $error = null,
        public readonly ?string $output = null,
    ) {}

    /**
     * @param  OutputMcpCallType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            id: $attributes['id'],
            serverLabel: $attributes['server_label'],
            type: $attributes['type'],
            arguments: $attributes['arguments'],
            name: $attributes['name'],
            approvalRequestId: $attributes['approval_request_id'],
            error: $attributes['error'],
            output: $attributes['output'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'                  => $this->id,
            'server_label'        => $this->serverLabel,
            'type'                => $this->type,
            'arguments'           => $this->arguments,
            'name'                => $this->name,
            'approval_request_id' => $this->approvalRequestId,
            'error'               => $this->error,
            'output'              => $this->output,
        ];
    }
}
PK     S%W]œœUë–  –  @  client/src/Responses/Responses/Output/OutputMcpListToolsTool.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Output;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type OutputMcpListToolsToolType array{annotations: array<string, string>|null, description: ?string, input_schema: array<string, string>, name: string}
 *
 * @implements ResponseContract<OutputMcpListToolsToolType>
 */
final class OutputMcpListToolsTool implements ResponseContract
{
    /**
     * @use ArrayAccessible<OutputMcpListToolsToolType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  array<string, string>  $inputSchema
     * @param  array<string, string>|null  $annotations
     */
    private function __construct(
        public readonly string $name,
        public readonly array $inputSchema,
        public readonly ?string $description = null,
        public readonly ?array $annotations = null,
    ) {}

    /**
     * @param  OutputMcpListToolsToolType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            name: $attributes['name'],
            inputSchema: $attributes['input_schema'],
            description: $attributes['description'] ?? null,
            annotations: $attributes['annotations'] ?? null,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'name'         => $this->name,
            'input_schema' => $this->inputSchema,
            'description'  => $this->description,
            'annotations'  => $this->annotations,
        ];
    }
}
PK     S%W]{åº[H  H  ^  client/src/Responses/Responses/Output/OutputMessageContentOutputTextAnnotationsUrlCitation.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Output;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type UrlCitationType array{end_index: int, start_index: int, title: string, type: 'url_citation', url: string}
 *
 * @implements ResponseContract<UrlCitationType>
 */
final class OutputMessageContentOutputTextAnnotationsUrlCitation implements ResponseContract
{
    /**
     * @use ArrayAccessible<UrlCitationType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'url_citation'  $type
     */
    private function __construct(
        public readonly int $endIndex,
        public readonly int $startIndex,
        public readonly string $title,
        public readonly string $type,
        public readonly string $url,
    ) {}

    /**
     * @param  UrlCitationType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            endIndex: $attributes['end_index'],
            startIndex: $attributes['start_index'],
            title: $attributes['title'],
            type: $attributes['type'],
            url: $attributes['url'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'end_index'   => $this->endIndex,
            'start_index' => $this->startIndex,
            'title'       => $this->title,
            'type'        => $this->type,
            'url'         => $this->url,
        ];
    }
}
PK     S%W]Ã¥;ë    A  client/src/Responses/Responses/Output/OutputWebSearchToolCall.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Output;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type OutputWebSearchToolCallType array{id: string, status: string, type: 'web_search_call'}
 *
 * @implements ResponseContract<OutputWebSearchToolCallType>
 */
final class OutputWebSearchToolCall implements ResponseContract
{
    /**
     * @use ArrayAccessible<OutputWebSearchToolCallType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'web_search_call'  $type
     */
    private function __construct(
        public readonly string $id,
        public readonly string $status,
        public readonly string $type,
    ) {}

    /**
     * @param  OutputWebSearchToolCallType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            id: $attributes['id'],
            status: $attributes['status'],
            type: $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'     => $this->id,
            'status' => $this->status,
            'type'   => $this->type,
        ];
    }
}
PK     S%W]"€C”  ”  :  client/src/Responses/Responses/Format/JsonSchemaFormat.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Format;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type JsonSchemaFormatType array{name: string, schema: array<string, mixed>, type: 'json_schema', description: ?string, strict: ?bool}
 *
 * @implements ResponseContract<JsonSchemaFormatType>
 */
final class JsonSchemaFormat implements ResponseContract
{
    /**
     * @use ArrayAccessible<JsonSchemaFormatType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  array<string, mixed>  $schema
     * @param  'json_schema'  $type
     */
    private function __construct(
        public readonly string $name,
        public readonly array $schema,
        public readonly string $type,
        public readonly ?string $description,
        public readonly ?bool $strict = null,
    ) {}

    /**
     * @param  JsonSchemaFormatType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            name: $attributes['name'],
            schema: $attributes['schema'],
            type: $attributes['type'],
            description: $attributes['description'] ?? null,
            strict: $attributes['strict'] ?? null,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'name'        => $this->name,
            'schema'      => $this->schema,
            'type'        => $this->type,
            'description' => $this->description,
            'strict'      => $this->strict,
        ];
    }
}
PK     S%W]TuÝÅ  Å  4  client/src/Responses/Responses/Format/TextFormat.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Format;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type TextFormatType array{type: 'text'}
 *
 * @implements ResponseContract<TextFormatType>
 */
final class TextFormat implements ResponseContract
{
    /**
     * @use ArrayAccessible<TextFormatType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'text'  $type
     */
    private function __construct(
        public readonly string $type,
    ) {}

    /**
     * @param  TextFormatType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            type: $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type' => $this->type,
        ];
    }
}
PK     S%W]º^c¨ñ  ñ  :  client/src/Responses/Responses/Format/JsonObjectFormat.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Responses\Format;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @phpstan-type JsonObjectFormatType array{type: 'json_object'}
 *
 * @implements ResponseContract<JsonObjectFormatType>
 */
final class JsonObjectFormat implements ResponseContract
{
    /**
     * @use ArrayAccessible<JsonObjectFormatType>
     */
    use ArrayAccessible;

    use Fakeable;

    /**
     * @param  'json_object'  $type
     */
    private function __construct(
        public readonly string $type,
    ) {}

    /**
     * @param  JsonObjectFormatType  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            type: $attributes['type'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'type' => $this->type,
        ];
    }
}
PK     S%W]ÃœNÓà  à  +  client/src/Responses/Files/ListResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Files;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{object: string, data: array<int, array{id: string, object: string, created_at: int, bytes: ?int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>}>
 */
final class ListResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{object: string, data: array<int, array{id: string, object: string, created_at: int, bytes: ?int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<int, RetrieveResponse>  $data
     */
    private function __construct(
        public readonly string $object,
        public readonly array $data,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{object: string, data: array<int, array{id: string, object: string, created_at: int, bytes: ?int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        $data = array_map(fn (array $result): RetrieveResponse => RetrieveResponse::from(
            $result,
            $meta,
        ), $attributes['data']);

        return new self(
            $attributes['object'],
            $data,
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'object' => $this->object,
            'data'   => array_map(
                static fn (RetrieveResponse $response): array => $response->toArray(),
                $this->data,
            ),
        ];
    }
}
PK     S%W]Mòë    -  client/src/Responses/Files/DeleteResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Files;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{id: string, object: string, deleted: bool}>
 */
final class DeleteResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{id: string, object: string, deleted: bool}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    private function __construct(
        public readonly string $id,
        public readonly string $object,
        public readonly bool $deleted,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{id: string, object: string, deleted: bool}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            $attributes['id'],
            $attributes['object'],
            $attributes['deleted'],
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'      => $this->id,
            'object'  => $this->object,
            'deleted' => $this->deleted,
        ];
    }
}
PK     S%W]ì]±v
  v
  /  client/src/Responses/Files/RetrieveResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Files;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{id: string, object: string, created_at: int, bytes: ?int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>
 */
final class RetrieveResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{id: string, object: string, created_at: int, bytes: ?int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<array-key, mixed>|null  $statusDetails
     */
    private function __construct(
        public readonly string $id,
        public readonly string $object,
        public readonly ?int $bytes,
        public readonly int $createdAt,
        public readonly string $filename,
        public readonly string $purpose,
        public readonly string $status,
        public readonly array|string|null $statusDetails,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{id: string, object: string, created_at: int, bytes: ?int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            $attributes['id'],
            $attributes['object'],
            $attributes['bytes'],
            $attributes['created_at'],
            $attributes['filename'],
            $attributes['purpose'],
            $attributes['status'],
            $attributes['status_details'] ?? null,
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'             => $this->id,
            'object'         => $this->object,
            'bytes'          => $this->bytes,
            'created_at'     => $this->createdAt,
            'filename'       => $this->filename,
            'purpose'        => $this->purpose,
            'status'         => $this->status,
            'status_details' => $this->statusDetails,
        ];
    }
}
PK     S%W]î‰Ëp
  p
  -  client/src/Responses/Files/CreateResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\Files;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>
 */
final class CreateResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<array-key, mixed>|null  $statusDetails
     */
    private function __construct(
        public readonly string $id,
        public readonly string $object,
        public readonly int $bytes,
        public readonly int $createdAt,
        public readonly string $filename,
        public readonly string $purpose,
        public readonly string $status,
        public readonly array|string|null $statusDetails,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        return new self(
            $attributes['id'],
            $attributes['object'],
            $attributes['bytes'],
            $attributes['created_at'],
            $attributes['filename'],
            $attributes['purpose'],
            $attributes['status'],
            $attributes['status_details'] ?? null,
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'             => $this->id,
            'object'         => $this->object,
            'bytes'          => $this->bytes,
            'created_at'     => $this->createdAt,
            'filename'       => $this->filename,
            'purpose'        => $this->purpose,
            'status'         => $this->status,
            'status_details' => $this->statusDetails,
        ];
    }
}
PK     S%W]ã£%dÿ  ÿ  /  client/src/Responses/FineTunes/ListResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\FineTunes;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{object: string, data: array<int, array{id: string, object: string, model: string, created_at: int, events: array<int, array{object: string, created_at: int, level: string, message: string}>, fine_tuned_model: ?string, hyperparams: array{batch_size: ?int, learning_rate_multiplier: ?float, n_epochs: int, prompt_loss_weight: float}, organization_id: string, result_files: array<int, array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>, status: string, validation_files: array<int, array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>, training_files: array<int, array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>, updated_at: int}>}>
 */
final class ListResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{object: string, data: array<int, array{id: string, object: string, model: string, created_at: int, events: array<int, array{object: string, created_at: int, level: string, message: string}>, fine_tuned_model: ?string, hyperparams: array{batch_size: ?int, learning_rate_multiplier: ?float, n_epochs: int, prompt_loss_weight: float}, organization_id: string, result_files: array<int, array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>, status: string, validation_files: array<int, array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>, training_files: array<int, array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>, updated_at: int}>}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<int, RetrieveResponse>  $data
     */
    private function __construct(
        public readonly string $object,
        public readonly array $data,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{object: string, data: array<int, array{id: string, object: string, model: string, created_at: int, events: array<int, array{object: string, created_at: int, level: string, message: string}>, fine_tuned_model: ?string, hyperparams: array{batch_size: ?int, learning_rate_multiplier: ?float, n_epochs: int, prompt_loss_weight: float}, organization_id: string, result_files: array<int, array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>, status: string, validation_files: array<int, array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>, training_files: array<int, array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>, updated_at: int}>}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        $data = array_map(fn (array $result): RetrieveResponse => RetrieveResponse::from(
            $result,
            $meta,
        ), $attributes['data']);

        return new self(
            $attributes['object'],
            $data,
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'object' => $this->object,
            'data'   => array_map(
                static fn (RetrieveResponse $response): array => $response->toArray(),
                $this->data,
            ),
        ];
    }
}
PK     S%W]¬÷cõ  õ  @  client/src/Responses/FineTunes/RetrieveStreamedResponseEvent.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\FineTunes;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Testing\Responses\Concerns\FakeableForStreamedResponse;

/**
 * @implements ResponseContract<array{object: string, created_at: int, level: string, message: string}>
 */
final class RetrieveStreamedResponseEvent implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{object: string, created_at: int, level: string, message: string}>
     */
    use ArrayAccessible;

    use FakeableForStreamedResponse;

    private function __construct(
        public readonly string $object,
        public readonly int $createdAt,
        public readonly string $level,
        public readonly string $message,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{object: string, created_at: int, level: string, message: string}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['object'],
            $attributes['created_at'],
            $attributes['level'],
            $attributes['message'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'object'     => $this->object,
            'created_at' => $this->createdAt,
            'level'      => $this->level,
            'message'    => $this->message,
        ];
    }
}
PK     S%W]rÞrO°  °  3  client/src/Responses/FineTunes/RetrieveResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\FineTunes;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{id: string, object: string, model: string, created_at: int, events: array<int, array{object: string, created_at: int, level: string, message: string}>, fine_tuned_model: ?string, hyperparams: array{batch_size: ?int, learning_rate_multiplier: ?float, n_epochs: int, prompt_loss_weight: float}, organization_id: string, result_files: array<int, array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>, status: string, validation_files: array<int, array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>, training_files: array<int, array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>, updated_at: int}>
 */
final class RetrieveResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{id: string, object: string, model: string, created_at: int, events: array<int, array{object: string, created_at: int, level: string, message: string}>, fine_tuned_model: ?string, hyperparams: array{batch_size: ?int, learning_rate_multiplier: ?float, n_epochs: int, prompt_loss_weight: float}, organization_id: string, result_files: array<int, array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>, status: string, validation_files: array<int, array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>, training_files: array<int, array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>, updated_at: int}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<int, RetrieveResponseEvent>  $events
     * @param  array<int, RetrieveResponseFile>  $resultFiles
     * @param  array<int, RetrieveResponseFile>  $validationFiles
     * @param  array<int, RetrieveResponseFile>  $trainingFiles
     */
    private function __construct(
        public readonly string $id,
        public readonly string $object,
        public readonly string $model,
        public readonly int $createdAt,
        public readonly array $events,
        public readonly ?string $fineTunedModel,
        public readonly RetrieveResponseHyperparams $hyperparams,
        public readonly string $organizationId,
        public readonly array $resultFiles,
        public readonly string $status,
        public readonly array $validationFiles,
        public readonly array $trainingFiles,
        public readonly int $updatedAt,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{id: string, object: string, model: string, created_at: int, events?: array<int, array{object: string, created_at: int, level: string, message: string}>, fine_tuned_model: ?string, hyperparams: array{batch_size: ?int, learning_rate_multiplier: ?float, n_epochs: int, prompt_loss_weight: float}, organization_id: string, result_files: array<int, array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>, status: string, validation_files: array<int, array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>, training_files: array<int, array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>, updated_at: int}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        $events = array_map(fn (array $result): RetrieveResponseEvent => RetrieveResponseEvent::from(
            $result
        ), $attributes['events'] ?? []);

        $resultFiles = array_map(fn (array $result): RetrieveResponseFile => RetrieveResponseFile::from(
            $result
        ), $attributes['result_files']);

        $validationFiles = array_map(fn (array $result): RetrieveResponseFile => RetrieveResponseFile::from(
            $result
        ), $attributes['validation_files']);

        $trainingFiles = array_map(fn (array $result): RetrieveResponseFile => RetrieveResponseFile::from(
            $result
        ), $attributes['training_files']);

        return new self(
            $attributes['id'],
            $attributes['object'],
            $attributes['model'],
            $attributes['created_at'],
            $events,
            $attributes['fine_tuned_model'],
            RetrieveResponseHyperparams::from($attributes['hyperparams']),
            $attributes['organization_id'],
            $resultFiles,
            $attributes['status'],
            $validationFiles,
            $trainingFiles,
            $attributes['updated_at'],
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'         => $this->id,
            'object'     => $this->object,
            'model'      => $this->model,
            'created_at' => $this->createdAt,
            'events'     => array_map(
                static fn (RetrieveResponseEvent $result): array => $result->toArray(),
                $this->events
            ),
            'fine_tuned_model' => $this->fineTunedModel,
            'hyperparams'      => $this->hyperparams->toArray(),
            'organization_id'  => $this->organizationId,
            'result_files'     => array_map(
                static fn (RetrieveResponseFile $result): array => $result->toArray(),
                $this->resultFiles
            ),
            'status'           => $this->status,
            'validation_files' => array_map(
                static fn (RetrieveResponseFile $result): array => $result->toArray(),
                $this->validationFiles
            ),
            'training_files' => array_map(
                static fn (RetrieveResponseFile $result): array => $result->toArray(),
                $this->trainingFiles
            ),
            'updated_at' => $this->updatedAt,
        ];
    }
}
PK     S%W]ë~>l  l  >  client/src/Responses/FineTunes/RetrieveResponseHyperparams.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\FineTunes;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;

/**
 * @implements ResponseContract<array{batch_size: ?int, learning_rate_multiplier: ?float, n_epochs: int, prompt_loss_weight: float}>
 */
final class RetrieveResponseHyperparams implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{batch_size: ?int, learning_rate_multiplier: ?float, n_epochs: int, prompt_loss_weight: float}>
     */
    use ArrayAccessible;

    private function __construct(
        public readonly ?int $batchSize,
        public readonly ?float $learningRateMultiplier,
        public readonly int $nEpochs,
        public readonly float $promptLossWeight,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{batch_size: ?int, learning_rate_multiplier: ?float, n_epochs: int, prompt_loss_weight: float}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['batch_size'],
            $attributes['learning_rate_multiplier'],
            $attributes['n_epochs'],
            $attributes['prompt_loss_weight'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'batch_size'               => $this->batchSize,
            'learning_rate_multiplier' => $this->learningRateMultiplier,
            'n_epochs'                 => $this->nEpochs,
            'prompt_loss_weight'       => $this->promptLossWeight,
        ];
    }
}
PK     S%W]{6ök„  „  8  client/src/Responses/FineTunes/RetrieveResponseEvent.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\FineTunes;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;

/**
 * @implements ResponseContract<array{object: string, created_at: int, level: string, message: string}>
 */
final class RetrieveResponseEvent implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{object: string, created_at: int, level: string, message: string}>
     */
    use ArrayAccessible;

    private function __construct(
        public readonly string $object,
        public readonly int $createdAt,
        public readonly string $level,
        public readonly string $message,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{object: string, created_at: int, level: string, message: string}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['object'],
            $attributes['created_at'],
            $attributes['level'],
            $attributes['message'],
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'object'     => $this->object,
            'created_at' => $this->createdAt,
            'level'      => $this->level,
            'message'    => $this->message,
        ];
    }
}
PK     S%W]ØŠšt	  	  7  client/src/Responses/FineTunes/RetrieveResponseFile.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\FineTunes;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Responses\Concerns\ArrayAccessible;

/**
 * @implements ResponseContract<array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>
 */
final class RetrieveResponseFile implements ResponseContract
{
    /**
     * @use ArrayAccessible<array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>
     */
    use ArrayAccessible;

    /**
     * @param  array<array-key, mixed>|null  $statusDetails
     */
    private function __construct(
        public readonly string $id,
        public readonly string $object,
        public readonly int $bytes,
        public readonly int $createdAt,
        public readonly string $filename,
        public readonly string $purpose,
        public readonly string $status,
        public readonly array|string|null $statusDetails,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}  $attributes
     */
    public static function from(array $attributes): self
    {
        return new self(
            $attributes['id'],
            $attributes['object'],
            $attributes['bytes'],
            $attributes['created_at'],
            $attributes['filename'],
            $attributes['purpose'],
            $attributes['status'],
            $attributes['status_details'] ?? null,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'id'             => $this->id,
            'object'         => $this->object,
            'bytes'          => $this->bytes,
            'created_at'     => $this->createdAt,
            'filename'       => $this->filename,
            'purpose'        => $this->purpose,
            'status'         => $this->status,
            'status_details' => $this->statusDetails,
        ];
    }
}
PK     S%W]tuwÇ  Ç  5  client/src/Responses/FineTunes/ListEventsResponse.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Responses\FineTunes;

use OpenAI\Contracts\ResponseContract;
use OpenAI\Contracts\ResponseHasMetaInformationContract;
use OpenAI\Responses\Concerns\ArrayAccessible;
use OpenAI\Responses\Concerns\HasMetaInformation;
use OpenAI\Responses\Meta\MetaInformation;
use OpenAI\Testing\Responses\Concerns\Fakeable;

/**
 * @implements ResponseContract<array{object: string, data: array<int, array{object: string, created_at: int, level: string, message: string}>}>
 */
final class ListEventsResponse implements ResponseContract, ResponseHasMetaInformationContract
{
    /**
     * @use ArrayAccessible<array{object: string, data: array<int, array{object: string, created_at: int, level: string, message: string}>}>
     */
    use ArrayAccessible;

    use Fakeable;
    use HasMetaInformation;

    /**
     * @param  array<int, RetrieveResponseEvent>  $data
     */
    private function __construct(
        public readonly string $object,
        public readonly array $data,
        private readonly MetaInformation $meta,
    ) {}

    /**
     * Acts as static factory, and returns a new Response instance.
     *
     * @param  array{object: string, data: array<int, array{object: string, created_at: int, level: string, message: string}>}  $attributes
     */
    public static function from(array $attributes, MetaInformation $meta): self
    {
        $data = array_map(fn (array $result): RetrieveResponseEvent => RetrieveResponseEvent::from(
            $result
        ), $attributes['data']);

        return new self(
            $attributes['object'],
            $data,
            $meta,
        );
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [
            'object' => $this->object,
            'data'   => array_map(
                static fn (RetrieveResponseEvent $response): array => $response->toArray(),
                $this->data,
            ),
        ];
    }
}
PK     S%W]äÃº*½  ½  #  client/src/Resources/FineTuning.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Resources;

use OpenAI\Contracts\Resources\FineTuningContract;
use OpenAI\Responses\FineTuning\ListJobEventsResponse;
use OpenAI\Responses\FineTuning\ListJobsResponse;
use OpenAI\Responses\FineTuning\RetrieveJobResponse;
use OpenAI\ValueObjects\Transporter\Payload;
use OpenAI\ValueObjects\Transporter\Response;

final class FineTuning implements FineTuningContract
{
    use Concerns\Transportable;

    /**
     * Creates a job that fine-tunes a specified model from a given dataset.
     *
     * Response includes details of the enqueued job including job status and the name of the fine-tuned models once complete.
     *
     * @see https://platform.openai.com/docs/api-reference/fine-tuning/create
     *
     * @param  array<string, mixed>  $parameters
     */
    public function createJob(array $parameters): RetrieveJobResponse
    {
        $payload = Payload::create('fine_tuning/jobs', $parameters);

        /** @var Response<array{id: string, object: string, model: string, created_at: int, finished_at: ?int, fine_tuned_model: ?string, hyperparameters: array{n_epochs: int|string, batch_size: int|string|null, learning_rate_multiplier: float|string|null}, organization_id: string, result_files: array<int, string>, status: string, validation_file: ?string, training_file: string, trained_tokens: ?int, error: ?array{code: string, param: ?string, message: string}}> $response */
        $response = $this->transporter->requestObject($payload);

        return RetrieveJobResponse::from($response->data(), $response->meta());
    }

    /**
     * List your organization's fine-tuning jobs.
     *
     * @see https://platform.openai.com/docs/api-reference/fine-tuning/undefined
     *
     * @param  array<string, mixed>  $parameters
     */
    public function listJobs(array $parameters = []): ListJobsResponse
    {
        $payload = Payload::list('fine_tuning/jobs', $parameters);

        /** @var Response<array{object: string, data: array<int, array{id: string, object: string, model: string, created_at: int, finished_at: ?int, fine_tuned_model: ?string, hyperparameters: array{n_epochs: int|string, batch_size: int|string|null, learning_rate_multiplier: float|string|null}, organization_id: string, result_files: array<int, string>, status: string, validation_file: ?string, training_file: string, trained_tokens: ?int, error: ?array{code: string, param: ?string, message: string}}>, has_more: bool}> $response */
        $response = $this->transporter->requestObject($payload);

        return ListJobsResponse::from($response->data(), $response->meta());
    }

    /**
     * Gets info about the fine-tune job.
     *
     * @see https://platform.openai.com/docs/api-reference/fine-tuning/retrieve
     */
    public function retrieveJob(string $jobId): RetrieveJobResponse
    {
        $payload = Payload::retrieve('fine_tuning/jobs', $jobId);

        /** @var Response<array{id: string, object: string, model: string, created_at: int, finished_at: ?int, fine_tuned_model: ?string, hyperparameters: array{n_epochs: int|string, batch_size: int|string|null, learning_rate_multiplier: float|string|null}, organization_id: string, result_files: array<int, string>, status: string, validation_file: ?string, training_file: string, trained_tokens: ?int, error: ?array{code: string, param: ?string, message: string}}> $response */
        $response = $this->transporter->requestObject($payload);

        return RetrieveJobResponse::from($response->data(), $response->meta());
    }

    /**
     * Immediately cancel a fine-tune job.
     *
     * @see https://platform.openai.com/docs/api-reference/fine-tuning/cancel
     */
    public function cancelJob(string $jobId): RetrieveJobResponse
    {
        $payload = Payload::cancel('fine_tuning/jobs', $jobId);

        /** @var Response<array{id: string, object: string, model: string, created_at: int, finished_at: ?int, fine_tuned_model: ?string, hyperparameters: array{n_epochs: int|string, batch_size: int|string|null, learning_rate_multiplier: float|string|null}, organization_id: string, result_files: array<int, string>, status: string, validation_file: ?string, training_file: string, trained_tokens: ?int, error: ?array{code: string, param: ?string, message: string}}> $response */
        $response = $this->transporter->requestObject($payload);

        return RetrieveJobResponse::from($response->data(), $response->meta());
    }

    /**
     * Get status updates for a fine-tuning job.
     *
     * @see https://platform.openai.com/docs/api-reference/fine-tuning/list-events
     *
     * @param  array<string, mixed>  $parameters
     */
    public function listJobEvents(string $jobId, array $parameters = []): ListJobEventsResponse
    {
        $payload = Payload::retrieve('fine_tuning/jobs', $jobId, '/events', $parameters);

        /** @var Response<array{object: string, data: array<int, array{object: string, id: string, created_at: int, level: string, message: string, data: array{step: int, train_loss: float, train_mean_token_accuracy: float}|null, type: string}>, has_more: bool}> $response */
        $response = $this->transporter->requestObject($payload);

        return ListJobEventsResponse::from($response->data(), $response->meta());
    }
}
PK     S%W]²/>›»  »  #  client/src/Resources/Assistants.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Resources;

use OpenAI\Contracts\Resources\AssistantsContract;
use OpenAI\Responses\Assistants\AssistantDeleteResponse;
use OpenAI\Responses\Assistants\AssistantListResponse;
use OpenAI\Responses\Assistants\AssistantResponse;
use OpenAI\ValueObjects\Transporter\Payload;
use OpenAI\ValueObjects\Transporter\Response;

final class Assistants implements AssistantsContract
{
    use Concerns\Transportable;

    /**
     * Create an assistant with a model and instructions.
     *
     * @see https://platform.openai.com/docs/api-reference/assistants/createAssistant
     *
     * @param  array<string, mixed>  $parameters
     */
    public function create(array $parameters): AssistantResponse
    {
        $payload = Payload::create('assistants', $parameters);

        /** @var Response<array{id: string, object: string, created_at: int, name: ?string, reasoning_effort?: ?string, description: ?string, model: string, instructions: ?string, tools: array<int, array{type: 'code_interpreter'}|array{type: 'file_search'}|array{type: 'function', function: array{description: string, name: string, parameters: array<string, mixed>}}>, tool_resources: array{code_interpreter?: array{file_ids: array<int,string>}, file_search?: array{vector_store_ids: array<int,string>}}, metadata: array<string, string>, temperature: ?float, top_p: ?float, response_format: string|array{type: 'text'|'json_object'}}> $response */
        $response = $this->transporter->requestObject($payload);

        return AssistantResponse::from($response->data(), $response->meta());
    }

    /**
     * Retrieves an assistant.
     *
     * @see https://platform.openai.com/docs/api-reference/assistants/getAssistant
     */
    public function retrieve(string $id): AssistantResponse
    {
        $payload = Payload::retrieve('assistants', $id);

        /** @var Response<array{id: string, object: string, created_at: int, name: ?string, reasoning_effort?: ?string, description: ?string, model: string, instructions: ?string, tools: array<int, array{type: 'code_interpreter'}|array{type: 'file_search'}|array{type: 'function', function: array{description: string, name: string, parameters: array<string, mixed>}}>, tool_resources: array{code_interpreter?: array{file_ids: array<int,string>}, file_search?: array{vector_store_ids: array<int,string>}}, metadata: array<string, string>, temperature: ?float, top_p: ?float, response_format: string|array{type: 'text'|'json_object'}}> $response */
        $response = $this->transporter->requestObject($payload);

        return AssistantResponse::from($response->data(), $response->meta());
    }

    /**
     * Modifies an assistant.
     *
     * @see https://platform.openai.com/docs/api-reference/assistants/modifyAssistant
     *
     * @param  array<string, mixed>  $parameters
     */
    public function modify(string $id, array $parameters): AssistantResponse
    {
        $payload = Payload::modify('assistants', $id, $parameters);

        /** @var Response<array{id: string, object: string, created_at: int, name: ?string, reasoning_effort?: ?string, description: ?string, model: string, instructions: ?string, tools: array<int, array{type: 'code_interpreter'}|array{type: 'file_search'}|array{type: 'function', function: array{description: string, name: string, parameters: array<string, mixed>}}>, tool_resources: array{code_interpreter?: array{file_ids: array<int,string>}, file_search?: array{vector_store_ids: array<int,string>}}, metadata: array<string, string>, temperature: ?float, top_p: ?float, response_format: string|array{type: 'text'|'json_object'}}> $response */
        $response = $this->transporter->requestObject($payload);

        return AssistantResponse::from($response->data(), $response->meta());
    }

    /**
     * Delete an assistant.
     *
     * @see https://platform.openai.com/docs/api-reference/assistants/deleteAssistant
     */
    public function delete(string $id): AssistantDeleteResponse
    {
        $payload = Payload::delete('assistants', $id);

        /** @var Response<array{id: string, object: string, deleted: bool}> $response */
        $response = $this->transporter->requestObject($payload);

        return AssistantDeleteResponse::from($response->data(), $response->meta());
    }

    /**
     * Returns a list of assistants.
     *
     * @see https://platform.openai.com/docs/api-reference/assistants/listAssistants
     *
     * @param  array<string, mixed>  $parameters
     */
    public function list(array $parameters = []): AssistantListResponse
    {
        $payload = Payload::list('assistants', $parameters);

        /** @var Response<array{object: string, data: array<int, array{id: string, object: string, created_at: int, name: ?string, reasoning_effort?: ?string, description: ?string, model: string, instructions: ?string, tools: array<int, array{type: 'code_interpreter'}|array{type: 'file_search'}|array{type: 'function', function: array{description: string, name: string, parameters: array<string, mixed>}}>, tool_resources: array{code_interpreter?: array{file_ids: array<int,string>}, file_search?: array{vector_store_ids: array<int,string>}}, metadata: array<string, string>, temperature: ?float, top_p: ?float, response_format: string|array{type: 'text'|'json_object'}}>, first_id: ?string, last_id: ?string, has_more: bool}> $response */
        $response = $this->transporter->requestObject($payload);

        return AssistantListResponse::from($response->data(), $response->meta());
    }
}
PK     S%W]äVúõ       client/src/Resources/Batches.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Resources;

use OpenAI\Contracts\Resources\BatchesContract;
use OpenAI\Responses\Batches\BatchListResponse;
use OpenAI\Responses\Batches\BatchResponse;
use OpenAI\ValueObjects\Transporter\Payload;
use OpenAI\ValueObjects\Transporter\Response;

final class Batches implements BatchesContract
{
    use Concerns\Transportable;

    /**
     * Creates and executes a batch from an uploaded file of requests
     *
     * @see https://platform.openai.com/docs/api-reference/batch/create
     *
     * @param  array<string, mixed>  $parameters
     */
    public function create(array $parameters): BatchResponse
    {
        $payload = Payload::create('batches', $parameters);

        /** @var Response<array{id: string, object: string, endpoint: string, errors?: array{object: string, data: array<array-key, array{code: string, message: string, param: ?string, line: ?int}>}, input_file_id: string, completion_window: string, status: string, output_file_id: ?string, error_file_id: ?string, created_at: int, in_progress_at: ?int, expires_at: ?int, finalizing_at: ?int, completed_at: ?int, failed_at: ?int, expired_at: ?int, cancelling_at: ?int, cancelled_at: ?int, request_counts?: array{total: int, completed: int, failed: int}, metadata: ?array<string, string>}> $response */
        $response = $this->transporter->requestObject($payload);

        return BatchResponse::from($response->data(), $response->meta());
    }

    /**
     * Retrieves a batch.
     * *
     * @see https://platform.openai.com/docs/api-reference/batch/retrieve
     */
    public function retrieve(string $id): BatchResponse
    {
        $payload = Payload::retrieve('batches', $id);

        /** @var Response<array{id: string, object: string, endpoint: string, errors?: array{object: string, data: array<array-key, array{code: string, message: string, param: ?string, line: ?int}>}, input_file_id: string, completion_window: string, status: string, output_file_id: ?string, error_file_id: ?string, created_at: int, in_progress_at: ?int, expires_at: ?int, finalizing_at: ?int, completed_at: ?int, failed_at: ?int, expired_at: ?int, cancelling_at: ?int, cancelled_at: ?int, request_counts?: array{total: int, completed: int, failed: int}, metadata: ?array<string, string>}> $response */
        $response = $this->transporter->requestObject($payload);

        return BatchResponse::from($response->data(), $response->meta());
    }

    /**
     * Cancels an in-progress batch.
     * *
     * @see https://platform.openai.com/docs/api-reference/batch/cancel
     */
    public function cancel(string $id): BatchResponse
    {
        $payload = Payload::cancel('batches', $id);

        /** @var Response<array{id: string, object: string, endpoint: string, errors?: array{object: string, data: array<array-key, array{code: string, message: string, param: ?string, line: ?int}>}, input_file_id: string, completion_window: string, status: string, output_file_id: ?string, error_file_id: ?string, created_at: int, in_progress_at: ?int, expires_at: ?int, finalizing_at: ?int, completed_at: ?int, failed_at: ?int, expired_at: ?int, cancelling_at: ?int, cancelled_at: ?int, request_counts?: array{total: int, completed: int, failed: int}, metadata: ?array<string, string>}> $response */
        $response = $this->transporter->requestObject($payload);

        return BatchResponse::from($response->data(), $response->meta());
    }

    /**
     * List your organization's batches.
     *
     * @see https://platform.openai.com/docs/api-reference/batch/list
     *
     * @param  array<string, mixed>  $parameters
     */
    public function list(array $parameters = []): BatchListResponse
    {
        $payload = Payload::list('batches', $parameters);

        /** @var Response<array{object: string, data: array<int, array{id: string, object: string, endpoint: string, errors?: array{object: string, data: array<array-key, array{code: string, message: string, param: ?string, line: ?int}>}, input_file_id: string, completion_window: string, status: string, output_file_id: ?string, error_file_id: ?string, created_at: int, in_progress_at: ?int, expires_at: ?int, finalizing_at: ?int, completed_at: ?int, failed_at: ?int, expired_at: ?int, cancelling_at: ?int, cancelled_at: ?int, request_counts?: array{total: int, completed: int, failed: int}, metadata: ?array<string, string>}>, first_id: ?string, last_id: ?string, has_more: bool}> $response */
        $response = $this->transporter->requestObject($payload);

        return BatchListResponse::from($response->data(), $response->meta());
    }
}
PK     S%W]”z      client/src/Resources/Chat.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Resources;

use OpenAI\Contracts\Resources\ChatContract;
use OpenAI\Responses\Chat\CreateResponse;
use OpenAI\Responses\Chat\CreateStreamedResponse;
use OpenAI\Responses\StreamResponse;
use OpenAI\ValueObjects\Transporter\Payload;
use OpenAI\ValueObjects\Transporter\Response;

final class Chat implements ChatContract
{
    use Concerns\Streamable;
    use Concerns\Transportable;

    /**
     * Creates a completion for the chat message
     *
     * @see https://platform.openai.com/docs/api-reference/chat/create
     *
     * @param  array<string, mixed>  $parameters
     */
    public function create(array $parameters): CreateResponse
    {
        $this->ensureNotStreamed($parameters);

        $payload = Payload::create('chat/completions', $parameters);

        /** @var Response<array{id: string, object: string, created: int, model: string, system_fingerprint?: string, choices: array<int, array{index: int, message: array{role: string, content: ?string, function_call: ?array{name: string, arguments: string}, tool_calls: ?array<int, array{id: string, type: string, function: array{name: string, arguments: string}}>}, logprobs: ?array{content: ?array<int, array{token: string, logprob: float, bytes: ?array<int, int>}>}, finish_reason: string|null}>, usage: array{prompt_tokens: int, completion_tokens: int|null, total_tokens: int}}> $response */
        $response = $this->transporter->requestObject($payload);

        return CreateResponse::from($response->data(), $response->meta());
    }

    /**
     * Creates a streamed completion for the chat message
     *
     * @see https://platform.openai.com/docs/api-reference/chat/create
     *
     * @param  array<string, mixed>  $parameters
     *
     * @return StreamResponse<CreateStreamedResponse>
     */
    public function createStreamed(array $parameters): StreamResponse
    {
        $parameters = $this->setStreamParameter($parameters);

        $payload = Payload::create('chat/completions', $parameters);

        $response = $this->transporter->requestStream($payload);

        return new StreamResponse(CreateStreamedResponse::class, $response);
    }
}
PK     S%W]s”ƒÄ7  7  $  client/src/Resources/Completions.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Resources;

use OpenAI\Contracts\Resources\CompletionsContract;
use OpenAI\Responses\Completions\CreateResponse;
use OpenAI\Responses\Completions\CreateStreamedResponse;
use OpenAI\Responses\StreamResponse;
use OpenAI\ValueObjects\Transporter\Payload;
use OpenAI\ValueObjects\Transporter\Response;

final class Completions implements CompletionsContract
{
    use Concerns\Streamable;
    use Concerns\Transportable;

    /**
     * Creates a completion for the provided prompt and parameters
     *
     * @see https://platform.openai.com/docs/api-reference/completions/create-completion
     *
     * @param  array<string, mixed>  $parameters
     */
    public function create(array $parameters): CreateResponse
    {
        $this->ensureNotStreamed($parameters);

        $payload = Payload::create('completions', $parameters);

        /** @var Response<array{id: string, object: string, created: int, model: string, choices: array<int, array{text: string, index: int, logprobs: array{tokens: array<int, string>, token_logprobs: array<int, float>, top_logprobs: array<int, string>|null, text_offset: array<int, int>}|null, finish_reason: string}>, usage: array{prompt_tokens: int, completion_tokens: int, total_tokens: int}}> $response */
        $response = $this->transporter->requestObject($payload);

        return CreateResponse::from($response->data(), $response->meta());
    }

    /**
     * Creates a streamed completion for the provided prompt and parameters
     *
     * @see https://platform.openai.com/docs/api-reference/completions/create-completion
     *
     * @param  array<string, mixed>  $parameters
     *
     * @return StreamResponse<CreateStreamedResponse>
     */
    public function createStreamed(array $parameters): StreamResponse
    {
        $parameters = $this->setStreamParameter($parameters);

        $payload = Payload::create('completions', $parameters);

        $response = $this->transporter->requestStream($payload);

        return new StreamResponse(CreateStreamedResponse::class, $response);
    }
}
PK     S%W]ÛÄWƒ0  ƒ0  $  client/src/Resources/ThreadsRuns.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Resources;

use OpenAI\Contracts\Resources\ThreadsRunsContract;
use OpenAI\Contracts\Resources\ThreadsRunsStepsContract;
use OpenAI\Responses\StreamResponse;
use OpenAI\Responses\Threads\Runs\ThreadRunListResponse;
use OpenAI\Responses\Threads\Runs\ThreadRunResponse;
use OpenAI\Responses\Threads\Runs\ThreadRunStreamResponse;
use OpenAI\ValueObjects\Transporter\Payload;
use OpenAI\ValueObjects\Transporter\Response;

final class ThreadsRuns implements ThreadsRunsContract
{
    use Concerns\Streamable;
    use Concerns\Transportable;

    /**
     * Create a run.
     *
     * @see https://platform.openai.com/docs/api-reference/runs/createRun
     *
     * @param  array<string, mixed>  $parameters
     */
    public function create(string $threadId, array $parameters): ThreadRunResponse
    {
        $payload = Payload::create('threads/' . $threadId . '/runs', $parameters);

        /** @var Response<array{id: string, object: string, created_at: int, thread_id: string, assistant_id: string, status: string, required_action?: array{type: string, submit_tool_outputs: array{tool_calls: array<int, array{id: string, type: string, function: array{name: string, arguments: string}}>}}, last_error: ?array{code: string, message: string}, expires_at: ?int, started_at: ?int, cancelled_at: ?int, failed_at: ?int, completed_at: ?int, model: string, instructions: ?string, tools: array<int, array{type: 'code_interpreter'}|array{type: 'file_search'}|array{type: 'function', function: array{description: string, name: string, parameters: array<string, mixed>}}>, metadata: array<string, string>, usage?: array{prompt_tokens: int, completion_tokens: int|null, total_tokens: int}, incomplete_details: ?array{reason: string}, temperature: float|int|null, top_p: null|float|int, max_prompt_tokens: ?int, max_completion_tokens: ?int, truncation_strategy: array{type: string, last_messages: ?int}, tool_choice: string|array{type: string, function?: array{name: string}}, response_format: string|array{type: 'text'|'json_object'}}> $response */
        $response = $this->transporter->requestObject($payload);

        return ThreadRunResponse::from($response->data(), $response->meta());
    }

    /**
     * Creates a streamed run
     *
     * @see https://platform.openai.com/docs/api-reference/runs/createRun
     *
     * @param  array<string, mixed>  $parameters
     *
     * @return StreamResponse<ThreadRunStreamResponse>
     */
    public function createStreamed(string $threadId, array $parameters): StreamResponse
    {
        $parameters = $this->setStreamParameter($parameters);

        $payload = Payload::create('threads/' . $threadId . '/runs', $parameters);

        $response = $this->transporter->requestStream($payload);

        return new StreamResponse(ThreadRunStreamResponse::class, $response);
    }

    /**
     * Retrieves a run.
     *
     * @see https://platform.openai.com/docs/api-reference/runs/getRun
     */
    public function retrieve(string $threadId, string $runId): ThreadRunResponse
    {
        $payload = Payload::retrieve('threads/' . $threadId . '/runs', $runId);

        /** @var Response<array{id: string, object: string, created_at: int, thread_id: string, assistant_id: string, status: string, required_action?: array{type: string, submit_tool_outputs: array{tool_calls: array<int, array{id: string, type: string, function: array{name: string, arguments: string}}>}}, last_error: ?array{code: string, message: string}, expires_at: ?int, started_at: ?int, cancelled_at: ?int, failed_at: ?int, completed_at: ?int, model: string, instructions: ?string, tools: array<int, array{type: 'code_interpreter'}|array{type: 'file_search'}|array{type: 'function', function: array{description: string, name: string, parameters: array<string, mixed>}}>, metadata: array<string, string>, usage?: array{prompt_tokens: int, completion_tokens: int|null, total_tokens: int}, incomplete_details: ?array{reason: string}, temperature: float|int|null, top_p: null|float|int, max_prompt_tokens: ?int, max_completion_tokens: ?int, truncation_strategy: array{type: string, last_messages: ?int}, tool_choice: string|array{type: string, function?: array{name: string}}, response_format: string|array{type: 'text'|'json_object'}}> $response */
        $response = $this->transporter->requestObject($payload);

        return ThreadRunResponse::from($response->data(), $response->meta());
    }

    /**
     * Modifies a run.
     *
     * @see https://platform.openai.com/docs/api-reference/runs/modifyRun
     *
     * @param  array<string, mixed>  $parameters
     */
    public function modify(string $threadId, string $runId, array $parameters): ThreadRunResponse
    {
        $payload = Payload::modify('threads/' . $threadId . '/runs', $runId, $parameters);

        /** @var Response<array{id: string, object: string, created_at: int, thread_id: string, assistant_id: string, status: string, required_action?: array{type: string, submit_tool_outputs: array{tool_calls: array<int, array{id: string, type: string, function: array{name: string, arguments: string}}>}}, last_error: ?array{code: string, message: string}, expires_at: ?int, started_at: ?int, cancelled_at: ?int, failed_at: ?int, completed_at: ?int, model: string, instructions: ?string, tools: array<int, array{type: 'code_interpreter'}|array{type: 'file_search'}|array{type: 'function', function: array{description: string, name: string, parameters: array<string, mixed>}}>, metadata: array<string, string>, usage?: array{prompt_tokens: int, completion_tokens: int|null, total_tokens: int}, incomplete_details: ?array{reason: string}, temperature: float|int|null, top_p: null|float|int, max_prompt_tokens: ?int, max_completion_tokens: ?int, truncation_strategy: array{type: string, last_messages: ?int}, tool_choice: string|array{type: string, function?: array{name: string}}, response_format: string|array{type: 'text'|'json_object'}}> $response */
        $response = $this->transporter->requestObject($payload);

        return ThreadRunResponse::from($response->data(), $response->meta());
    }

    /**
     * This endpoint can be used to submit the outputs from the tool calls once they're all completed.
     *
     * @see https://platform.openai.com/docs/api-reference/runs/submitToolOutputs
     *
     * @param  array<string, mixed>  $parameters
     */
    public function submitToolOutputs(string $threadId, string $runId, array $parameters): ThreadRunResponse
    {
        $payload = Payload::create('threads/' . $threadId . '/runs/' . $runId . '/submit_tool_outputs', $parameters);

        /** @var Response<array{id: string, object: string, created_at: int, thread_id: string, assistant_id: string, status: string, required_action?: array{type: string, submit_tool_outputs: array{tool_calls: array<int, array{id: string, type: string, function: array{name: string, arguments: string}}>}}, last_error: ?array{code: string, message: string}, expires_at: ?int, started_at: ?int, cancelled_at: ?int, failed_at: ?int, completed_at: ?int, model: string, instructions: ?string, tools: array<int, array{type: 'code_interpreter'}|array{type: 'file_search'}|array{type: 'function', function: array{description: string, name: string, parameters: array<string, mixed>}}>, metadata: array<string, string>, usage?: array{prompt_tokens: int, completion_tokens: int|null, total_tokens: int}, incomplete_details: ?array{reason: string}, temperature: float|int|null, top_p: null|float|int, max_prompt_tokens: ?int, max_completion_tokens: ?int, truncation_strategy: array{type: string, last_messages: ?int}, tool_choice: string|array{type: string, function?: array{name: string}}, response_format: string|array{type: 'text'|'json_object'}}> $response */
        $response = $this->transporter->requestObject($payload);

        return ThreadRunResponse::from($response->data(), $response->meta());
    }

    /**
     * This endpoint can be used to submit the outputs from the tool calls once they're all completed.
     * And stream back the response
     *
     * @see https://platform.openai.com/docs/api-reference/runs/submitToolOutputs
     *
     * @param  array<string, mixed>  $parameters
     *
     * @return StreamResponse<ThreadRunStreamResponse>
     */
    public function submitToolOutputsStreamed(string $threadId, string $runId, array $parameters): StreamResponse
    {
        $parameters = $this->setStreamParameter($parameters);

        $payload = Payload::create('threads/' . $threadId . '/runs/' . $runId . '/submit_tool_outputs', $parameters);

        $response = $this->transporter->requestStream($payload);

        return new StreamResponse(ThreadRunStreamResponse::class, $response);
    }

    /**
     * Cancels a run that is `in_progress`.
     *
     * @see https://platform.openai.com/docs/api-reference/runs/cancelRun
     */
    public function cancel(string $threadId, string $runId): ThreadRunResponse
    {
        $payload = Payload::cancel('threads/' . $threadId . '/runs', $runId);

        /** @var Response<array{id: string, object: string, created_at: int, thread_id: string, assistant_id: string, status: string, required_action?: array{type: string, submit_tool_outputs: array{tool_calls: array<int, array{id: string, type: string, function: array{name: string, arguments: string}}>}}, last_error: ?array{code: string, message: string}, expires_at: ?int, started_at: ?int, cancelled_at: ?int, failed_at: ?int, completed_at: ?int, model: string, instructions: ?string, tools: array<int, array{type: 'code_interpreter'}|array{type: 'file_search'}|array{type: 'function', function: array{description: string, name: string, parameters: array<string, mixed>}}>, metadata: array<string, string>, usage?: array{prompt_tokens: int, completion_tokens: int|null, total_tokens: int}, incomplete_details: ?array{reason: string}, temperature: float|int|null, top_p: null|float|int, max_prompt_tokens: ?int, max_completion_tokens: ?int, truncation_strategy: array{type: string, last_messages: ?int}, tool_choice: string|array{type: string, function?: array{name: string}}, response_format: string|array{type: 'text'|'json_object'}}> $response */
        $response = $this->transporter->requestObject($payload);

        return ThreadRunResponse::from($response->data(), $response->meta());
    }

    /**
     * Returns a list of runs belonging to a thread.
     *
     * @see https://platform.openai.com/docs/api-reference/runs/listRuns
     *
     * @param  array<string, mixed>  $parameters
     */
    public function list(string $threadId, array $parameters = []): ThreadRunListResponse
    {
        $payload = Payload::list('threads/' . $threadId . '/runs', $parameters);

        /** @var Response<array{object: string, data: array<int, array{id: string, object: string, created_at: int, thread_id: string, assistant_id: string, status: string, required_action?: array{type: string, submit_tool_outputs: array{tool_calls: array<int, array{id: string, type: string, function: array{name: string, arguments: string}}>}}, last_error: ?array{code: string, message: string}, expires_at: ?int, started_at: ?int, cancelled_at: ?int, failed_at: ?int, completed_at: ?int, model: string, instructions: ?string, tools: array<int, array{type: 'code_interpreter'}|array{type: 'file_search'}|array{type: 'function', function: array{description: string, name: string, parameters: array<string, mixed>}}>, metadata: array<string, string>, usage?: array{prompt_tokens: int, completion_tokens: int|null, total_tokens: int}, incomplete_details: ?array{reason: string}, temperature: float|int|null, top_p: null|float|int, max_prompt_tokens: ?int, max_completion_tokens: ?int, truncation_strategy: array{type: string, last_messages: ?int}, tool_choice: string|array{type: string, function?: array{name: string}}, response_format: string|array{type: 'text'|'json_object'}}>, first_id: ?string, last_id: ?string, has_more: bool}> $response */
        $response = $this->transporter->requestObject($payload);

        return ThreadRunListResponse::from($response->data(), $response->meta());
    }

    /**
     * Get steps attached to a run.
     *
     * @see https://platform.openai.com/docs/api-reference/runs/step-object
     */
    public function steps(): ThreadsRunsStepsContract
    {
        return new ThreadsRunsSteps($this->transporter);
    }
}
PK     S%W]”¬“É    #  client/src/Resources/Containers.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Resources;

use OpenAI\Contracts\Resources\ContainersContract;
use OpenAI\Responses\Containers\CreateContainer;
use OpenAI\Responses\Containers\DeleteContainer;
use OpenAI\Responses\Containers\ListContainers;
use OpenAI\Responses\Containers\RetrieveContainer;
use OpenAI\ValueObjects\Transporter\Payload;
use OpenAI\ValueObjects\Transporter\Response;

/**
 * @phpstan-import-type CreateContainerType from CreateContainer
 * @phpstan-import-type RetrieveContainerType from RetrieveContainer
 * @phpstan-import-type DeleteContainerType from DeleteContainer
 * @phpstan-import-type ListContainersType from ListContainers
 */
final class Containers implements ContainersContract
{
    use Concerns\Transportable;

    /**
     * Creates a container for use with the Code Interpreter tool.
     *
     * @see https://platform.openai.com/docs/api-reference/containers/createContainers
     *
     * @param  array<string, mixed>  $parameters
     */
    public function create(array $parameters): CreateContainer
    {
        $payload = Payload::create('containers', $parameters);

        /** @var Response<CreateContainerType> $response */
        $response = $this->transporter->requestObject($payload);

        return CreateContainer::from($response->data(), $response->meta());
    }

    /**
     * Retrieves a container with the given ID.
     *
     * @see https://platform.openai.com/docs/api-reference/containers/retrieveContainer
     */
    public function retrieve(string $id): RetrieveContainer
    {
        $payload = Payload::retrieve('containers', $id);

        /** @var Response<RetrieveContainerType> $response */
        $response = $this->transporter->requestObject($payload);

        return RetrieveContainer::from($response->data(), $response->meta());
    }

    /**
     * Delete a container with the given ID.
     *
     * @see https://platform.openai.com/docs/api-reference/containers/deleteContainer
     */
    public function delete(string $id): DeleteContainer
    {
        $payload = Payload::delete('containers', $id);

        /** @var Response<DeleteContainerType> $response */
        $response = $this->transporter->requestObject($payload);

        return DeleteContainer::from($response->data(), $response->meta());
    }

    /**
     * List containers
     *
     * @see https://platform.openai.com/docs/api-reference/containers/listContainers
     *
     * @param  array<string, mixed>  $parameters
     */
    public function list(array $parameters = []): ListContainers
    {
        $payload = Payload::list('containers', $parameters);

        /** @var Response<ListContainersType> $response */
        $response = $this->transporter->requestObject($payload);

        return ListContainers::from($response->data(), $response->meta());
    }
}
PK     S%W]Õ¡^    #  client/src/Resources/Embeddings.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Resources;

use OpenAI\Contracts\Resources\EmbeddingsContract;
use OpenAI\Responses\Embeddings\CreateResponse;
use OpenAI\ValueObjects\Transporter\Payload;
use OpenAI\ValueObjects\Transporter\Response;

final class Embeddings implements EmbeddingsContract
{
    use Concerns\Transportable;

    /**
     * Creates an embedding vector representing the input text.
     *
     * @see https://platform.openai.com/docs/api-reference/embeddings/create
     *
     * @param  array<string, mixed>  $parameters
     */
    public function create(array $parameters): CreateResponse
    {
        $payload = Payload::create('embeddings', $parameters);

        /** @var Response<array{object: string, model: string, data: array<int, array{object: string, embedding: array<int, float>, index: int}>, usage: array{prompt_tokens: int, total_tokens: int}}> $response */
        $response = $this->transporter->requestObject($payload);

        return CreateResponse::from($response->data(), $response->meta());
    }
}
PK     S%W]òS¢â¯  ¯  "  client/src/Resources/FineTunes.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Resources;

use OpenAI\Contracts\Resources\FineTunesContract;
use OpenAI\Responses\FineTunes\ListEventsResponse;
use OpenAI\Responses\FineTunes\ListResponse;
use OpenAI\Responses\FineTunes\RetrieveResponse;
use OpenAI\Responses\FineTunes\RetrieveStreamedResponseEvent;
use OpenAI\Responses\StreamResponse;
use OpenAI\ValueObjects\Transporter\Payload;
use OpenAI\ValueObjects\Transporter\Response;

final class FineTunes implements FineTunesContract
{
    use Concerns\Transportable;

    /**
     * Creates a job that fine-tunes a specified model from a given dataset.
     *
     * Response includes details of the enqueued job including job status and the name of the fine-tuned models once complete.
     *
     * @see https://platform.openai.com/docs/api-reference/fine-tunes/create
     *
     * @param  array<string, mixed>  $parameters
     */
    public function create(array $parameters): RetrieveResponse
    {
        $payload = Payload::create('fine-tunes', $parameters);

        /** @var Response<array{id: string, object: string, model: string, created_at: int, events: array<int, array{object: string, created_at: int, level: string, message: string}>, fine_tuned_model: ?string, hyperparams: array{batch_size: ?int, learning_rate_multiplier: ?float, n_epochs: int, prompt_loss_weight: float}, organization_id: string, result_files: array<int, array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>, status: string, validation_files: array<int, array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>, training_files: array<int, array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>, updated_at: int}>  $response */
        $response = $this->transporter->requestObject($payload);

        return RetrieveResponse::from($response->data(), $response->meta());
    }

    /**
     * List your organization's fine-tuning jobs.
     *
     * @see https://platform.openai.com/docs/api-reference/fine-tunes/list
     */
    public function list(): ListResponse
    {
        $payload = Payload::list('fine-tunes');

        /** @var Response<array{object: string, data: array<int, array{id: string, object: string, model: string, created_at: int, events: array<int, array{object: string, created_at: int, level: string, message: string}>, fine_tuned_model: ?string, hyperparams: array{batch_size: ?int, learning_rate_multiplier: ?float, n_epochs: int, prompt_loss_weight: float}, organization_id: string, result_files: array<int, array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>, status: string, validation_files: array<int, array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>, training_files: array<int, array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>, updated_at: int}>}> $response */
        $response = $this->transporter->requestObject($payload);

        return ListResponse::from($response->data(), $response->meta());
    }

    /**
     * Gets info about the fine-tune job.
     *
     * @see https://platform.openai.com/docs/api-reference/fine-tunes/list
     */
    public function retrieve(string $fineTuneId): RetrieveResponse
    {
        $payload = Payload::retrieve('fine-tunes', $fineTuneId);

        /** @var Response<array{id: string, object: string, model: string, created_at: int, events: array<int, array{object: string, created_at: int, level: string, message: string}>, fine_tuned_model: ?string, hyperparams: array{batch_size: ?int, learning_rate_multiplier: ?float, n_epochs: int, prompt_loss_weight: float}, organization_id: string, result_files: array<int, array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>, status: string, validation_files: array<int, array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>, training_files: array<int, array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>, updated_at: int}>  $response */
        $response = $this->transporter->requestObject($payload);

        return RetrieveResponse::from($response->data(), $response->meta());
    }

    /**
     * Immediately cancel a fine-tune job.
     *
     * @see https://platform.openai.com/docs/api-reference/fine-tunes/cancel
     */
    public function cancel(string $fineTuneId): RetrieveResponse
    {
        $payload = Payload::cancel('fine-tunes', $fineTuneId);

        /** @var Response<array{id: string, object: string, model: string, created_at: int, events: array<int, array{object: string, created_at: int, level: string, message: string}>, fine_tuned_model: ?string, hyperparams: array{batch_size: ?int, learning_rate_multiplier: ?float, n_epochs: int, prompt_loss_weight: float}, organization_id: string, result_files: array<int, array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>, status: string, validation_files: array<int, array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>, training_files: array<int, array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>, updated_at: int}>  $response */
        $response = $this->transporter->requestObject($payload);

        return RetrieveResponse::from($response->data(), $response->meta());
    }

    /**
     * Get fine-grained status updates for a fine-tune job.
     *
     * @see https://platform.openai.com/docs/api-reference/fine-tunes/events
     */
    public function listEvents(string $fineTuneId): ListEventsResponse
    {
        $payload = Payload::retrieve('fine-tunes', $fineTuneId, '/events');

        /** @var Response<array{object: string, data: array<int, array{object: string, created_at: int, level: string, message: string}>}> $response */
        $response = $this->transporter->requestObject($payload);

        return ListEventsResponse::from($response->data(), $response->meta());
    }

    /**
     * Get streamed fine-grained status updates for a fine-tune job.
     *
     * @see https://platform.openai.com/docs/api-reference/fine-tunes/events
     *
     * @return StreamResponse<RetrieveStreamedResponseEvent>
     */
    public function listEventsStreamed(string $fineTuneId): StreamResponse
    {
        $payload = Payload::retrieve('fine-tunes', $fineTuneId, '/events?stream=true');

        $response = $this->transporter->requestStream($payload);

        return new StreamResponse(RetrieveStreamedResponseEvent::class, $response);
    }
}
PK     S%W];¯Ö  Ö     client/src/Resources/Threads.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Resources;

use OpenAI\Contracts\Resources\ThreadsContract;
use OpenAI\Contracts\Resources\ThreadsMessagesContract;
use OpenAI\Contracts\Resources\ThreadsRunsContract;
use OpenAI\Responses\StreamResponse;
use OpenAI\Responses\Threads\Runs\ThreadRunResponse;
use OpenAI\Responses\Threads\Runs\ThreadRunStreamResponse;
use OpenAI\Responses\Threads\ThreadDeleteResponse;
use OpenAI\Responses\Threads\ThreadResponse;
use OpenAI\ValueObjects\Transporter\Payload;
use OpenAI\ValueObjects\Transporter\Response;

final class Threads implements ThreadsContract
{
    use Concerns\Streamable;
    use Concerns\Transportable;

    /**
     * Create a thread.
     *
     * @see https://platform.openai.com/docs/api-reference/threads/createThread
     *
     * @param  array<string, mixed>  $parameters
     */
    public function create(array $parameters = []): ThreadResponse
    {
        $payload = Payload::create('threads', $parameters);

        /** @var Response<array{id: string, object: string, created_at: int, tool_resources: ?array{code_interpreter?: array{file_ids: array<int,string>}, file_search?: array{vector_store_ids: array<int,string>}}, metadata: array<string, string>}> $response */
        $response = $this->transporter->requestObject($payload);

        return ThreadResponse::from($response->data(), $response->meta());
    }

    /**
     * Create a thread and run it in one request.
     *
     * @see https://platform.openai.com/docs/api-reference/runs/createThreadAndRun
     *
     * @param  array<string, mixed>  $parameters
     */
    public function createAndRun(array $parameters): ThreadRunResponse
    {
        $payload = Payload::create('threads/runs', $parameters);

        /** @var Response<array{id: string, object: string, created_at: int, thread_id: string, assistant_id: string, status: string, required_action?: array{type: string, submit_tool_outputs: array{tool_calls: array<int, array{id: string, type: string, function: array{name: string, arguments: string}}>}}, last_error: ?array{code: string, message: string}, expires_at: ?int, started_at: ?int, cancelled_at: ?int, failed_at: ?int, completed_at: ?int, model: string, instructions: ?string, tools: array<int, array{type: 'code_interpreter'}|array{type: 'file_search'}|array{type: 'function', function: array{description: string, name: string, parameters: array<string, mixed>}}>, metadata: array<string, string>, usage?: array{prompt_tokens: int, completion_tokens: int|null, total_tokens: int}, incomplete_details: ?array{reason: string}, temperature: float|int|null, top_p: null|float|int, max_prompt_tokens: ?int, max_completion_tokens: ?int, truncation_strategy: array{type: string, last_messages: ?int}, tool_choice: string|array{type: string, function?: array{name: string}}, response_format: string|array{type: 'text'|'json_object'}}> $response */
        $response = $this->transporter->requestObject($payload);

        return ThreadRunResponse::from($response->data(), $response->meta());
    }

    /**
     * Create a thread and run it in one request, returning a stream.
     *
     * @see https://platform.openai.com/docs/api-reference/runs/createThreadAndRun
     *
     * @param  array<string, mixed>  $parameters
     *
     * @return StreamResponse<ThreadRunStreamResponse>
     */
    public function createAndRunStreamed(array $parameters): StreamResponse
    {
        $parameters = $this->setStreamParameter($parameters);

        $payload = Payload::create('threads/runs', $parameters);

        $response = $this->transporter->requestStream($payload);

        return new StreamResponse(ThreadRunStreamResponse::class, $response);
    }

    /**
     * Retrieves a thread.
     *
     * @see https://platform.openai.com/docs/api-reference/threads/getThread
     */
    public function retrieve(string $id): ThreadResponse
    {
        $payload = Payload::retrieve('threads', $id);

        /** @var Response<array{id: string, object: string, created_at: int, tool_resources: ?array{code_interpreter?: array{file_ids: array<int,string>}, file_search?: array{vector_store_ids: array<int,string>}}, metadata: array<string, string>}> $response */
        $response = $this->transporter->requestObject($payload);

        return ThreadResponse::from($response->data(), $response->meta());
    }

    /**
     * Modifies a thread.
     *
     * @see https://platform.openai.com/docs/api-reference/threads/modifyThread
     *
     * @param  array<string, mixed>  $parameters
     */
    public function modify(string $id, array $parameters): ThreadResponse
    {
        $payload = Payload::modify('threads', $id, $parameters);

        /** @var Response<array{id: string, object: string, created_at: int, tool_resources: ?array{code_interpreter?: array{file_ids: array<int,string>}, file_search?: array{vector_store_ids: array<int,string>}}, metadata: array<string, string>}> $response */
        $response = $this->transporter->requestObject($payload);

        return ThreadResponse::from($response->data(), $response->meta());
    }

    /**
     * Delete a thread.
     *
     * @see https://platform.openai.com/docs/api-reference/threads/deleteThread
     */
    public function delete(string $id): ThreadDeleteResponse
    {
        $payload = Payload::delete('threads', $id);

        /** @var Response<array{id: string, object: string, deleted: bool}> $response */
        $response = $this->transporter->requestObject($payload);

        return ThreadDeleteResponse::from($response->data(), $response->meta());
    }

    /**
     * Manage messages attached to a thread.
     *
     * @see https://platform.openai.com/docs/api-reference/messages
     */
    public function messages(): ThreadsMessagesContract
    {
        return new ThreadsMessages($this->transporter);
    }

    /**
     * Represents an execution run on a thread.
     *
     * @see https://platform.openai.com/docs/api-reference/runs
     */
    public function runs(): ThreadsRunsContract
    {
        return new ThreadsRuns($this->transporter);
    }
}
PK     S%W]QÎ™    %  client/src/Resources/VectorStores.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Resources;

use OpenAI\Contracts\Resources\VectorStoresContract;
use OpenAI\Contracts\Resources\VectorStoresFileBatchesContract;
use OpenAI\Contracts\Resources\VectorStoresFilesContract;
use OpenAI\Responses\VectorStores\Search\VectorStoreSearchResponse;
use OpenAI\Responses\VectorStores\VectorStoreDeleteResponse;
use OpenAI\Responses\VectorStores\VectorStoreListResponse;
use OpenAI\Responses\VectorStores\VectorStoreResponse;
use OpenAI\ValueObjects\Transporter\Payload;
use OpenAI\ValueObjects\Transporter\Response;

final class VectorStores implements VectorStoresContract
{
    use Concerns\Transportable;

    /**
     * Create a vector store
     *
     * @see https://platform.openai.com/docs/api-reference/vector-stores/create
     *
     * @param  array<string, mixed>  $parameters
     */
    public function create(array $parameters): VectorStoreResponse
    {
        $payload = Payload::create('vector_stores', $parameters);

        /** @var Response<array{id: string, object: string, created_at: int, name: ?string, usage_bytes: int, file_counts: array{in_progress: int, completed: int, failed: int, cancelled: int, total: int}, status: string, expires_after: ?array{anchor: string, days: int}, expires_at: ?int, last_active_at: ?int, metadata: array<string, string>}> $response */
        $response = $this->transporter->requestObject($payload);

        return VectorStoreResponse::from($response->data(), $response->meta());
    }

    /**
     * Returns a list of vector stores.
     *
     * @see https://platform.openai.com/docs/api-reference/vector-stores/list
     *
     * @param  array<string, mixed>  $parameters
     */
    public function list(array $parameters = []): VectorStoreListResponse
    {
        $payload = Payload::list('vector_stores', $parameters);

        /** @var Response<array{object: string, data: array<int, array{id: string, object: string, created_at: int, name: ?string, usage_bytes: int, file_counts: array{in_progress: int, completed: int, failed: int, cancelled: int, total: int}, status: string, expires_after: ?array{anchor: string, days: int}, expires_at: ?int, last_active_at: ?int, metadata: array<string, string>}>, first_id: ?string, last_id: ?string, has_more: bool}> $response */
        $response = $this->transporter->requestObject($payload);

        return VectorStoreListResponse::from($response->data(), $response->meta());
    }

    /**
     * Retrieves a vector store.
     *
     * @see https://platform.openai.com/docs/api-reference/vector-stores/retrieve
     */
    public function retrieve(string $vectorStoreId): VectorStoreResponse
    {
        $payload = Payload::retrieve('vector_stores', $vectorStoreId);

        /** @var Response<array{id: string, object: string, created_at: int, name: ?string, usage_bytes: int, file_counts: array{in_progress: int, completed: int, failed: int, cancelled: int, total: int}, status: string, expires_after: ?array{anchor: string, days: int}, expires_at: ?int, last_active_at: ?int, metadata: array<string, string>}> $response */
        $response = $this->transporter->requestObject($payload);

        return VectorStoreResponse::from($response->data(), $response->meta());
    }

    /**
     * Modify a vector store
     *
     * @see https://platform.openai.com/docs/api-reference/vector-stores/modify
     *
     * @param  array<string, mixed>  $parameters
     */
    public function modify(string $vectorStoreId, array $parameters): VectorStoreResponse
    {
        $payload = Payload::modify('vector_stores', $vectorStoreId, $parameters);

        /** @var Response<array{id: string, object: string, created_at: int, name: ?string, usage_bytes: int, file_counts: array{in_progress: int, completed: int, failed: int, cancelled: int, total: int}, status: string, expires_after: ?array{anchor: string, days: int}, expires_at: ?int, last_active_at: ?int, metadata: array<string, string>}> $response */
        $response = $this->transporter->requestObject($payload);

        return VectorStoreResponse::from($response->data(), $response->meta());
    }

    /**
     * Delete a vector store.
     *
     * https://platform.openai.com/docs/api-reference/vector-stores/delete
     */
    public function delete(string $vectorStoreId): VectorStoreDeleteResponse
    {
        $payload = Payload::delete('vector_stores', $vectorStoreId);

        /** @var Response<array{id: string, object: string, deleted: bool}> $response */
        $response = $this->transporter->requestObject($payload);

        return VectorStoreDeleteResponse::from($response->data(), $response->meta());
    }

    /**
     * Manage the files related to the vector store
     *
     * @see https://platform.openai.com/docs/api-reference/vector-stores-files
     */
    public function files(): VectorStoresFilesContract
    {
        return new VectorStoresFiles($this->transporter);
    }

    /**
     * Manage the file batches related to the vector store
     *
     * @see https://platform.openai.com/docs/api-reference/vector-stores-file-batches
     */
    public function batches(): VectorStoresFileBatchesContract
    {
        return new VectorStoresFileBatches($this->transporter);
    }

    /**
     * Search a vector store for relevant chunks based on a query and file attributes filter.
     *
     * @see https://platform.openai.com/docs/api-reference/vector-stores/search
     *
     * @param  array<string, mixed>  $parameters
     */
    public function search(string $vectorStoreId, array $parameters = []): VectorStoreSearchResponse
    {
        $payload = Payload::create("vector_stores/{$vectorStoreId}/search", $parameters);

        /** @var Response<array{object: string, search_query: string|array<mixed>, data: array<int, array{file_id: string, filename: string, score: float, attributes: array<string, mixed>, content: array<int, array{type: string, text: string}>}>, has_more: bool, next_page: ?string}> $response */
        $response = $this->transporter->requestObject($payload);

        return VectorStoreSearchResponse::from($response->data(), $response->meta());
    }
}
PK     S%W]6è²Û÷   ÷   /  client/src/Resources/Concerns/Transportable.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Resources\Concerns;

use OpenAI\Contracts\TransporterContract;

trait Transportable
{
    public function __construct(private readonly TransporterContract $transporter)
    {
        // ..
    }
}
PK     S%W]\hØw  w  ,  client/src/Resources/Concerns/Streamable.phpnu „[µü¤        <?php

namespace OpenAI\Resources\Concerns;

use OpenAI\Exceptions\InvalidArgumentException;

trait Streamable
{
    /**
     * @param  array<string, mixed>  $parameters
     */
    private function ensureNotStreamed(array $parameters, string $fallbackFunction = 'createStreamed'): void
    {
        if (! isset($parameters['stream'])) {
            return;
        }

        if ($parameters['stream'] !== true) {
            return;
        }

        throw new InvalidArgumentException("Stream option is not supported. Please use the $fallbackFunction() method instead.");
    }

    /**
     * Set the stream parameter to true.
     *
     * @param  array<string, mixed>  $parameters
     *
     * @return array<string, mixed>
     */
    private function setStreamParameter(array $parameters): array
    {
        $parameters['stream'] = true;

        return $parameters;
    }
}
PK     S%W]ú7Š@Æ  Æ  !  client/src/Resources/Realtime.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Resources;

use OpenAI\Contracts\Resources\RealtimeContract;
use OpenAI\Responses\Realtime\SessionResponse;
use OpenAI\Responses\Realtime\TranscriptionSessionResponse;
use OpenAI\ValueObjects\Transporter\Payload;
use OpenAI\ValueObjects\Transporter\Response;

/**
 * @phpstan-import-type SessionType from SessionResponse
 * @phpstan-import-type TranscriptionSessionType from TranscriptionSessionResponse
 */
final class Realtime implements RealtimeContract
{
    use Concerns\Transportable;

    /**
     * Create an ephemeral API token for real time sessions.
     *
     * @see https://platform.openai.com/docs/api-reference/realtime-sessions/create
     *
     * @param  array<string, mixed>  $parameters
     */
    public function token(array $parameters = []): SessionResponse
    {
        $payload = Payload::create('realtime/sessions', $parameters);

        /** @var Response<SessionType> $response */
        $response = $this->transporter->requestObject($payload);

        return SessionResponse::from($response->data());
    }

    /**
     * Create an ephemeral API token for real time transcription sessions.
     *
     * @see https://platform.openai.com/docs/api-reference/realtime-sessions/create-transcription
     *
     * @param  array<string, mixed>  $parameters
     */
    public function transcribeToken(array $parameters = []): TranscriptionSessionResponse
    {
        $payload = Payload::create('realtime/transcription_sessions', $parameters);

        /** @var Response<TranscriptionSessionType> $response */
        $response = $this->transporter->requestObject($payload);

        return TranscriptionSessionResponse::from($response->data());
    }
}
PK     S%W]„BÅr  r    client/src/Resources/Models.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Resources;

use OpenAI\Contracts\Resources\ModelsContract;
use OpenAI\Responses\Models\DeleteResponse;
use OpenAI\Responses\Models\ListResponse;
use OpenAI\Responses\Models\RetrieveResponse;
use OpenAI\ValueObjects\Transporter\Payload;
use OpenAI\ValueObjects\Transporter\Response;

final class Models implements ModelsContract
{
    use Concerns\Transportable;

    /**
     * Lists the currently available models, and provides basic information about each one such as the owner and availability.
     *
     * @see https://platform.openai.com/docs/api-reference/models/list
     */
    public function list(): ListResponse
    {
        $payload = Payload::list('models');

        /** @var Response<array{object: string, data: array<int, array{id: string, object: string, created: int, owned_by: string}>}> $response */
        $response = $this->transporter->requestObject($payload);

        return ListResponse::from($response->data(), $response->meta());
    }

    /**
     * Retrieves a model instance, providing basic information about the model such as the owner and permissioning.
     *
     * @see https://platform.openai.com/docs/api-reference/models/retrieve
     */
    public function retrieve(string $model): RetrieveResponse
    {
        $payload = Payload::retrieve('models', $model);

        /** @var Response<array{id: string, object: string, created: int, owned_by: string}> $response */
        $response = $this->transporter->requestObject($payload);

        return RetrieveResponse::from($response->data(), $response->meta());
    }

    /**
     * Delete a fine-tuned model. You must have the Owner role in your organization.
     *
     * @see https://platform.openai.com/docs/api-reference/fine-tunes/delete-model
     */
    public function delete(string $model): DeleteResponse
    {
        $payload = Payload::delete('models', $model);

        /** @var Response<array{id: string, object: string, deleted: bool}> $response */
        $response = $this->transporter->requestObject($payload);

        return DeleteResponse::from($response->data(), $response->meta());
    }
}
PK     S%W]-ˆ}š  š  )  client/src/Resources/ThreadsRunsSteps.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Resources;

use OpenAI\Contracts\Resources\ThreadsRunsStepsContract;
use OpenAI\Responses\Threads\Runs\Steps\ThreadRunStepListResponse;
use OpenAI\Responses\Threads\Runs\Steps\ThreadRunStepResponse;
use OpenAI\ValueObjects\Transporter\Payload;
use OpenAI\ValueObjects\Transporter\Response;

final class ThreadsRunsSteps implements ThreadsRunsStepsContract
{
    use Concerns\Transportable;

    /**
     * Retrieves a run step.
     *
     * @see https://platform.openai.com/docs/api-reference/runs/getRunStep
     */
    public function retrieve(string $threadId, string $runId, string $stepId): ThreadRunStepResponse
    {
        $payload = Payload::retrieve('threads/' . $threadId . '/runs/' . $runId . '/steps', $stepId);

        /** @var Response<array{id: string, object: string, created_at: int, thread_id: string, assistant_id: string, run_id: string, type: string, status: string, step_details: array{type: 'tool_calls', tool_calls: array<int, array{id?: string, type: 'code_interpreter', code_interpreter: array{input: string, outputs: array<int, array{type: 'image', image: array{file_id: string}}|array{type: 'logs', logs: string}>}}|array{id: string, type: 'file_search', file_search: array<string, string>}|array{id?: string, type: 'function', function: array{name?: string, arguments: string, output?: ?string}}>}|array{type: 'message_creation', message_creation: array{message_id: string}}, last_error: ?array{code: string, message: string}, expires_at: ?int, cancelled_at: ?int, failed_at: ?int, completed_at: ?int, metadata?: array<string, string>, usage: ?array{prompt_tokens: int, completion_tokens: int, total_tokens: int}}> $response */
        $response = $this->transporter->requestObject($payload);

        return ThreadRunStepResponse::from($response->data(), $response->meta());
    }

    /**
     * Returns a list of run steps belonging to a run.
     *
     * @see https://platform.openai.com/docs/api-reference/runs/listRunSteps
     *
     * @param  array<string, mixed>  $parameters
     */
    public function list(string $threadId, string $runId, array $parameters = []): ThreadRunStepListResponse
    {
        $payload = Payload::list('threads/' . $threadId . '/runs/' . $runId . '/steps', $parameters);

        /** @var Response<array{object: string, data: array<int, array{id: string, object: string, created_at: int, thread_id: string, assistant_id: string, run_id: string, type: string, status: string, step_details: array{type: 'tool_calls', tool_calls: array<int, array{id?: string, type: 'code_interpreter', code_interpreter: array{input: string, outputs: array<int, array{type: 'image', image: array{file_id: string}}|array{type: 'logs', logs: string}>}}|array{id: string, type: 'file_search', file_search: array<string, string>}|array{id?: string, type: 'function', function: array{name?: string, arguments: string, output?: ?string}}>}|array{type: 'message_creation', message_creation: array{message_id: string}}, last_error: ?array{code: string, message: string}, expires_at: ?int, cancelled_at: ?int, failed_at: ?int, completed_at: ?int, metadata?: array<string, string>, usage: ?array{prompt_tokens: int, completion_tokens: int, total_tokens: int}}>, first_id: ?string, last_id: ?string, has_more: bool}> $response */
        $response = $this->transporter->requestObject($payload);

        return ThreadRunStepListResponse::from($response->data(), $response->meta());
    }
}
PK     S%W]õ£Ò¤  ¤    client/src/Resources/Audio.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Resources;

use OpenAI\Contracts\Resources\AudioContract;
use OpenAI\Responses\Audio\SpeechStreamResponse;
use OpenAI\Responses\Audio\TranscriptionResponse;
use OpenAI\Responses\Audio\TranscriptionStreamResponse;
use OpenAI\Responses\Audio\TranslationResponse;
use OpenAI\Responses\StreamResponse;
use OpenAI\ValueObjects\Transporter\Payload;
use OpenAI\ValueObjects\Transporter\Response;

final class Audio implements AudioContract
{
    use Concerns\Streamable;
    use Concerns\Transportable;

    /**
     * Generates audio from the input text.
     *
     * @see https://platform.openai.com/docs/api-reference/audio/createSpeech
     *
     * @param  array<string, mixed>  $parameters
     */
    public function speech(array $parameters): string
    {
        $this->ensureNotStreamed($parameters, 'speechStreamed');

        $payload = Payload::create('audio/speech', $parameters);

        return $this->transporter->requestContent($payload);
    }

    /**
     * Generates streamed audio from the input text.
     *
     * @see https://platform.openai.com/docs/api-reference/audio/createSpeech
     *
     * @param  array<string, mixed>  $parameters
     */
    public function speechStreamed(array $parameters): SpeechStreamResponse
    {
        $payload = Payload::create('audio/speech', $parameters);

        $response = $this->transporter->requestStream($payload);

        return new SpeechStreamResponse($response);
    }

    /**
     * Transcribes audio into the input language.
     *
     * @see https://platform.openai.com/docs/api-reference/audio/createTranscription
     *
     * @param  array<string, mixed>  $parameters
     */
    public function transcribe(array $parameters): TranscriptionResponse
    {
        $this->ensureNotStreamed($parameters, 'transcribeStreamed');

        $payload = Payload::upload('audio/transcriptions', $parameters);

        /** @var Response<array{task: ?string, language: ?string, duration: ?float, segments: array<int, array{id: int, seek: int, start: float, end: float, text: string, tokens: array<int, int>, temperature: float, avg_logprob: float, compression_ratio: float, no_speech_prob: float, transient?: bool}>, words: array<int, array{word: string, start: float, end: float}>, text: string}> $response */
        $response = $this->transporter->requestObject($payload);

        return TranscriptionResponse::from($response->data(), $response->meta());
    }

    /**
     * Transcribes audio input the streamed events.
     *
     * @see https://platform.openai.com/docs/api-reference/audio/createTranscription#audio-createtranscription-stream
     *
     * @param  array<string, mixed>  $parameters
     *
     * @return StreamResponse<TranscriptionStreamResponse>
     */
    public function transcribeStreamed(array $parameters): StreamResponse
    {
        $parameters = $this->setStreamParameter($parameters);

        $payload = Payload::upload('audio/transcriptions', $parameters);

        $response = $this->transporter->requestStream($payload);

        return new StreamResponse(TranscriptionStreamResponse::class, $response);
    }

    /**
     * Translates audio into English.
     *
     * @see https://platform.openai.com/docs/api-reference/audio/createTranslation
     *
     * @param  array<string, mixed>  $parameters
     */
    public function translate(array $parameters): TranslationResponse
    {
        $payload = Payload::upload('audio/translations', $parameters);

        /** @var Response<array{task: ?string, language: ?string, duration: ?float, segments: array<int, array{id: int, seek: int, start: float, end: float, text: string, tokens: array<int, int>, temperature: float, avg_logprob: float, compression_ratio: float, no_speech_prob: float, transient?: bool}>, text: string}> $response */
        $response = $this->transporter->requestObject($payload);

        return TranslationResponse::from($response->data(), $response->meta());
    }
}
PK     S%W]ÅÍ?S  S  (  client/src/Resources/ThreadsMessages.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Resources;

use OpenAI\Contracts\Resources\ThreadsMessagesContract;
use OpenAI\Responses\Threads\Messages\ThreadMessageDeleteResponse;
use OpenAI\Responses\Threads\Messages\ThreadMessageListResponse;
use OpenAI\Responses\Threads\Messages\ThreadMessageResponse;
use OpenAI\ValueObjects\Transporter\Payload;
use OpenAI\ValueObjects\Transporter\Response;

final class ThreadsMessages implements ThreadsMessagesContract
{
    use Concerns\Transportable;

    /**
     * Create a message.
     *
     * @see https://platform.openai.com/docs/api-reference/messages/createMessage
     *
     * @param  array<string, mixed>  $parameters
     */
    public function create(string $threadId, array $parameters): ThreadMessageResponse
    {
        $payload = Payload::create("threads/$threadId/messages", $parameters);

        /** @var Response<array{id: string, object: string, created_at: int, thread_id: string, role: string, content: array<int, array{type: 'image_url', image_url: array{url: string, detail?: string}}|array{type: 'image_file', image_file: array{file_id: string, detail?: string}}|array{type: 'text', text: array{value: string, annotations: array<int, array{type: 'file_citation', text: string, file_citation: array{file_id: string, quote?: string}, start_index: int, end_index: int}|array{type: 'file_path', text: string, file_path: array{file_id: string}, start_index: int, end_index: int}>}}>, assistant_id: ?string, run_id: ?string, attachments?: array<int, array{file_id: string, tools: array<int, array{type: 'file_search'}|array{type: 'code_interpreter'}>}>, metadata: array<string, string>}> $response */
        $response = $this->transporter->requestObject($payload);

        return ThreadMessageResponse::from($response->data(), $response->meta());
    }

    /**
     * Retrieve a message.
     *
     * @see https://platform.openai.com/docs/api-reference/messages/getMessage
     */
    public function retrieve(string $threadId, string $messageId): ThreadMessageResponse
    {
        $payload = Payload::retrieve("threads/$threadId/messages", $messageId);

        /** @var Response<array{id: string, object: string, created_at: int, thread_id: string, role: string, content: array<int, array{type: 'image_url', image_url: array{url: string, detail?: string}}|array{type: 'image_file', image_file: array{file_id: string, detail?: string}}|array{type: 'text', text: array{value: string, annotations: array<int, array{type: 'file_citation', text: string, file_citation: array{file_id: string, quote?: string}, start_index: int, end_index: int}|array{type: 'file_path', text: string, file_path: array{file_id: string}, start_index: int, end_index: int}>}}>, assistant_id: ?string, run_id: ?string, attachments?: array<int, array{file_id: string, tools: array<int, array{type: 'file_search'}|array{type: 'code_interpreter'}>}>, metadata: array<string, string>}> $response */
        $response = $this->transporter->requestObject($payload);

        return ThreadMessageResponse::from($response->data(), $response->meta());
    }

    /**
     * Modifies a message.
     *
     * @see https://platform.openai.com/docs/api-reference/messages/modifyMessage
     *
     * @param  array<string, mixed>  $parameters
     */
    public function modify(string $threadId, string $messageId, array $parameters): ThreadMessageResponse
    {
        $payload = Payload::modify("threads/$threadId/messages", $messageId, $parameters);

        /** @var Response<array{id: string, object: string, created_at: int, thread_id: string, role: string, content: array<int, array{type: 'image_url', image_url: array{url: string, detail?: string}}|array{type: 'image_file', image_file: array{file_id: string, detail?: string}}|array{type: 'text', text: array{value: string, annotations: array<int, array{type: 'file_citation', text: string, file_citation: array{file_id: string, quote?: string}, start_index: int, end_index: int}|array{type: 'file_path', text: string, file_path: array{file_id: string}, start_index: int, end_index: int}>}}>, assistant_id: ?string, run_id: ?string, attachments?: array<int, array{file_id: string, tools: array<int, array{type: 'file_search'}|array{type: 'code_interpreter'}>}>, metadata: array<string, string>}> $response */
        $response = $this->transporter->requestObject($payload);

        return ThreadMessageResponse::from($response->data(), $response->meta());
    }

    /**
     * Deletes a message.
     *
     * @see https://platform.openai.com/docs/api-reference/messages/deleteMessage
     */
    public function delete(string $threadId, string $messageId): ThreadMessageDeleteResponse
    {
        $payload = Payload::delete("threads/$threadId/messages", $messageId);

        /** @var Response<array{id: string, object: string, deleted: bool}> $response */
        $response = $this->transporter->requestObject($payload);

        return ThreadMessageDeleteResponse::from($response->data(), $response->meta());
    }

    /**
     * Returns a list of messages for a given thread.
     *
     * @see https://platform.openai.com/docs/api-reference/messages/listMessages
     *
     * @param  array<string, mixed>  $parameters
     */
    public function list(string $threadId, array $parameters = []): ThreadMessageListResponse
    {
        $payload = Payload::list("threads/$threadId/messages", $parameters);

        /** @var Response<array{object: string, data: array<int, array{id: string, object: string, created_at: int, thread_id: string, role: string, content: array<int, array{type: 'image_url', image_url: array{url: string, detail?: string}}|array{type: 'image_file', image_file: array{file_id: string, detail?: string}}|array{type: 'text', text: array{value: string, annotations: array<int, array{type: 'file_citation', text: string, file_citation: array{file_id: string, quote?: string}, start_index: int, end_index: int}|array{type: 'file_path', text: string, file_path: array{file_id: string}, start_index: int, end_index: int}>}}>, assistant_id: ?string, run_id: ?string, attachments?: array<int, array{file_id: string, tools: array<int, array{type: 'file_search'}|array{type: 'code_interpreter'}>}>, metadata: array<string, string>}>, first_id: ?string, last_id: ?string, has_more: bool}> $response */
        $response = $this->transporter->requestObject($payload);

        return ThreadMessageListResponse::from($response->data(), $response->meta());
    }
}
PK     S%W]Í-³Q  Q  "  client/src/Resources/Responses.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Resources;

use OpenAI\Contracts\Resources\ResponsesContract;
use OpenAI\Responses\Responses\CreateResponse;
use OpenAI\Responses\Responses\CreateStreamedResponse;
use OpenAI\Responses\Responses\DeleteResponse;
use OpenAI\Responses\Responses\ListInputItems;
use OpenAI\Responses\Responses\RetrieveResponse;
use OpenAI\Responses\StreamResponse;
use OpenAI\ValueObjects\Transporter\Payload;
use OpenAI\ValueObjects\Transporter\Response;

/**
 * @phpstan-import-type CreateResponseType from CreateResponse
 * @phpstan-import-type RetrieveResponseType from RetrieveResponse
 * @phpstan-import-type ListInputItemsType from ListInputItems
 */
final class Responses implements ResponsesContract
{
    use Concerns\Streamable;
    use Concerns\Transportable;

    /**
     * Creates a model response. Provide text or image inputs to generate text or JSON outputs.
     * Have the model call your own custom code or use built-in tools like web search or file search
     * to use your own data as input for the model's response.
     *
     * @see https://platform.openai.com/docs/api-reference/responses/create
     *
     * @param  array<string, mixed>  $parameters
     */
    public function create(array $parameters): CreateResponse
    {
        $this->ensureNotStreamed($parameters);

        $payload = Payload::create('responses', $parameters);

        /** @var Response<CreateResponseType> $response */
        $response = $this->transporter->requestObject($payload);

        return CreateResponse::from($response->data(), $response->meta());
    }

    /**
     * When you create a Response with stream set to true,
     * the server will emit server-sent events to the client as the Response is generated.
     *
     * @see https://platform.openai.com/docs/api-reference/responses-streaming
     *
     * @param  array<string, mixed>  $parameters
     *
     * @return StreamResponse<CreateStreamedResponse>
     */
    public function createStreamed(array $parameters): StreamResponse
    {
        $parameters = $this->setStreamParameter($parameters);

        $payload = Payload::create('responses', $parameters);

        $response = $this->transporter->requestStream($payload);

        return new StreamResponse(CreateStreamedResponse::class, $response);
    }

    /**
     * Retrieves a model response with the given ID.
     *
     * @see https://platform.openai.com/docs/api-reference/responses/get
     */
    public function retrieve(string $id): RetrieveResponse
    {
        $payload = Payload::retrieve('responses', $id);

        /** @var Response<RetrieveResponseType> $response */
        $response = $this->transporter->requestObject($payload);

        return RetrieveResponse::from($response->data(), $response->meta());
    }

    /**
     * Cancels a model response with the given ID. Must be marked as 'background' to be cancellable.
     *
     * @see https://platform.openai.com/docs/api-reference/responses/cancel
     */
    public function cancel(string $id): RetrieveResponse
    {
        $payload = Payload::cancel('responses', $id);

        /** @var Response<RetrieveResponseType> $response */
        $response = $this->transporter->requestObject($payload);

        return RetrieveResponse::from($response->data(), $response->meta());
    }

    /**
     * Deletes a model response with the given ID.
     *
     * @see https://platform.openai.com/docs/api-reference/responses/delete
     */
    public function delete(string $id): DeleteResponse
    {
        $payload = Payload::delete('responses', $id);

        /** @var Response<array{id: string, object: string, deleted: bool}> $response */
        $response = $this->transporter->requestObject($payload);

        return DeleteResponse::from($response->data(), $response->meta());
    }

    /**
     * Lists input items for a response with the given ID.
     *
     * @see https://platform.openai.com/docs/api-reference/responses/input-items
     *
     * @param  array<string, mixed>  $parameters
     */
    public function list(string $id, array $parameters = []): ListInputItems
    {
        $payload = Payload::list('responses/' . $id . '/input_items', $parameters);

        /** @var Response<ListInputItemsType> $response */
        $response = $this->transporter->requestObject($payload);

        return ListInputItems::from($response->data(), $response->meta());
    }
}
PK     S%W]Å¯óq”
  ”
    client/src/Resources/Images.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Resources;

use OpenAI\Contracts\Resources\ImagesContract;
use OpenAI\Responses\Images\CreateResponse;
use OpenAI\Responses\Images\EditResponse;
use OpenAI\Responses\Images\VariationResponse;
use OpenAI\ValueObjects\Transporter\Payload;
use OpenAI\ValueObjects\Transporter\Response;

final class Images implements ImagesContract
{
    use Concerns\Transportable;

    /**
     * Creates an image given a prompt.
     *
     * @see https://platform.openai.com/docs/api-reference/images/create
     *
     * @param  array<string, mixed>  $parameters
     */
    public function create(array $parameters): CreateResponse
    {
        $payload = Payload::create('images/generations', $parameters);

        /** @var Response<array{created: int, data: array<int, array{url?: string, b64_json?: string, revised_prompt?: string}>, usage?: array{total_tokens: int, input_tokens: int, output_tokens: int, input_tokens_details: array{text_tokens: int, image_tokens: int}}}> $response */
        $response = $this->transporter->requestObject($payload);

        return CreateResponse::from($response->data(), $response->meta());
    }

    /**
     * Creates an edited or extended image given an original image and a prompt.
     *
     * @see https://platform.openai.com/docs/api-reference/images/create-edit
     *
     * @param  array<string, mixed>  $parameters
     */
    public function edit(array $parameters): EditResponse
    {
        $payload = Payload::upload('images/edits', $parameters);

        /** @var Response<array{created: int, data: array<int, array{url?: string, b64_json?: string}>, usage?: array{total_tokens: int, input_tokens: int, output_tokens: int, input_tokens_details: array{text_tokens: int, image_tokens: int}}}> $response */
        $response = $this->transporter->requestObject($payload);

        return EditResponse::from($response->data(), $response->meta());
    }

    /**
     * Creates a variation of a given image.
     *
     * @see https://platform.openai.com/docs/api-reference/images/create-variation
     *
     * @param  array<string, mixed>  $parameters
     */
    public function variation(array $parameters): VariationResponse
    {
        $payload = Payload::upload('images/variations', $parameters);

        /** @var Response<array{created: int, data: array<int, array{url?: string, b64_json?: string}>, usage?: array{total_tokens: int, input_tokens: int, output_tokens: int, input_tokens_details: array{text_tokens: int, image_tokens: int}}}> $response */
        $response = $this->transporter->requestObject($payload);

        return VariationResponse::from($response->data(), $response->meta());
    }
}
PK     S%W]˜†sœ'  '  *  client/src/Resources/VectorStoresFiles.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Resources;

use OpenAI\Contracts\Resources\VectorStoresFilesContract;
use OpenAI\Responses\VectorStores\Files\VectorStoreFileDeleteResponse;
use OpenAI\Responses\VectorStores\Files\VectorStoreFileListResponse;
use OpenAI\Responses\VectorStores\Files\VectorStoreFileResponse;
use OpenAI\ValueObjects\Transporter\Payload;
use OpenAI\ValueObjects\Transporter\Response;

final class VectorStoresFiles implements VectorStoresFilesContract
{
    use Concerns\Transportable;

    /**
     * Create a file on a vector store
     *
     * @see https://platform.openai.com/docs/api-reference/vector-stores-files/createFile
     *
     * @param  array<string, mixed>  $parameters
     */
    public function create(string $vectorStoreId, array $parameters): VectorStoreFileResponse
    {
        $payload = Payload::create("vector_stores/$vectorStoreId/files", $parameters);

        /** @var Response<array{id: string, object: string, usage_bytes: int, created_at: int, vector_store_id: string, status: string, attributes: array<string, string>, last_error: ?array{code: string, message: string}, chunking_strategy: array{type: 'static', static: array{max_chunk_size_tokens: int, chunk_overlap_tokens: int}}|array{type: 'other'}}> $response */
        $response = $this->transporter->requestObject($payload);

        return VectorStoreFileResponse::from($response->data(), $response->meta());
    }

    /**
     * Returns a list of files within a vector store.
     *
     * @see https://platform.openai.com/docs/api-reference/vector-stores-files/listFiles
     *
     * @param  array<string, mixed>  $parameters
     */
    public function list(string $vectorStoreId, array $parameters = []): VectorStoreFileListResponse
    {
        $payload = Payload::list("vector_stores/$vectorStoreId/files", $parameters);

        /** @var Response<array{object: string, data: array<int, array{id: string, object: string, usage_bytes: int, created_at: int, vector_store_id: string, status: string, attributes: array<string, string>, last_error: ?array{code: string, message: string}, chunking_strategy: array{type: 'static', static: array{max_chunk_size_tokens: int, chunk_overlap_tokens: int}}|array{type: 'other'}}>, first_id: ?string, last_id: ?string, has_more: bool}> $response */
        $response = $this->transporter->requestObject($payload);

        return VectorStoreFileListResponse::from($response->data(), $response->meta());
    }

    /**
     * Retrieves a file within a vector store.
     *
     * @see https://platform.openai.com/docs/api-reference/vector-stores-files/getFile
     */
    public function retrieve(string $vectorStoreId, string $fileId): VectorStoreFileResponse
    {
        $payload = Payload::retrieve("vector_stores/$vectorStoreId/files", $fileId);

        /** @var Response<array{id: string, object: string, usage_bytes: int, created_at: int, vector_store_id: string, status: string, attributes: array<string, string>, last_error: ?array{code: string, message: string}, chunking_strategy: array{type: 'static', static: array{max_chunk_size_tokens: int, chunk_overlap_tokens: int}}|array{type: 'other'}}> $response */
        $response = $this->transporter->requestObject($payload);

        return VectorStoreFileResponse::from($response->data(), $response->meta());
    }

    /**
     * Update attributes on a vector store file.
     *
     * @see https://platform.openai.com/docs/api-reference/vector-stores-files/updateAttributes
     *
     * @param  array<string, mixed>  $parameters
     */
    public function updateAttributes(string $vectorStoreId, string $fileId, array $parameters): VectorStoreFileResponse
    {
        $payload = Payload::modify("vector_stores/$vectorStoreId/files", $fileId, $parameters);

        /** @var Response<array{id: string, object: string, usage_bytes: int, created_at: int, vector_store_id: string, status: string, attributes: array<string, string>, last_error: ?array{code: string, message: string}, chunking_strategy: array{type: 'static', static: array{max_chunk_size_tokens: int, chunk_overlap_tokens: int}}|array{type: 'other'}}> $response */
        $response = $this->transporter->requestObject($payload);

        return VectorStoreFileResponse::from($response->data(), $response->meta());
    }

    /**
     * Delete a file within a vector store.
     *
     * https://platform.openai.com/docs/api-reference/vector-stores/delete
     */
    public function delete(string $vectorStoreId, string $fileId): VectorStoreFileDeleteResponse
    {
        $payload = Payload::delete("vector_stores/$vectorStoreId/files", $fileId);

        /** @var Response<array{id: string, object: string, deleted: bool}> $response */
        $response = $this->transporter->requestObject($payload);

        return VectorStoreFileDeleteResponse::from($response->data(), $response->meta());
    }
}
PK     S%W]ˆˆ²æ  æ    client/src/Resources/Files.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Resources;

use OpenAI\Contracts\Resources\FilesContract;
use OpenAI\Responses\Files\CreateResponse;
use OpenAI\Responses\Files\DeleteResponse;
use OpenAI\Responses\Files\ListResponse;
use OpenAI\Responses\Files\RetrieveResponse;
use OpenAI\ValueObjects\Transporter\Payload;
use OpenAI\ValueObjects\Transporter\Response;

final class Files implements FilesContract
{
    use Concerns\Transportable;

    /**
     * Returns a list of files that belong to the user's organization.
     *
     * @see https://platform.openai.com/docs/api-reference/files/list
     */
    public function list(array $parameters = []): ListResponse
    {
        $payload = Payload::list('files', $parameters);

        /** @var Response<array{object: string, data: array<int, array{id: string, object: string, created_at: int, bytes: ?int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}>}> $response */
        $response = $this->transporter->requestObject($payload);

        return ListResponse::from($response->data(), $response->meta());
    }

    /**
     * Returns information about a specific file.
     *
     * @see https://platform.openai.com/docs/api-reference/files/retrieve
     */
    public function retrieve(string $file): RetrieveResponse
    {
        $payload = Payload::retrieve('files', $file);

        /** @var Response<array{id: string, object: string, created_at: int, bytes: ?int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}> $response */
        $response = $this->transporter->requestObject($payload);

        return RetrieveResponse::from($response->data(), $response->meta());
    }

    /**
     * Returns the contents of the specified file.
     *
     * @see https://platform.openai.com/docs/api-reference/files/retrieve-content
     */
    public function download(string $file): string
    {
        $payload = Payload::retrieveContent('files', $file);

        return $this->transporter->requestContent($payload);
    }

    /**
     * Upload a file that contains document(s) to be used across various endpoints/features.
     *
     * @see https://platform.openai.com/docs/api-reference/files/upload
     *
     * @param  array<string, mixed>  $parameters
     */
    public function upload(array $parameters): CreateResponse
    {
        $payload = Payload::upload('files', $parameters);

        /** @var Response<array{id: string, object: string, created_at: int, bytes: int, filename: string, purpose: string, status: string, status_details: array<array-key, mixed>|string|null}> $response */
        $response = $this->transporter->requestObject($payload);

        return CreateResponse::from($response->data(), $response->meta());
    }

    /**
     * Delete a file.
     *
     * @see https://platform.openai.com/docs/api-reference/files/delete
     */
    public function delete(string $file): DeleteResponse
    {
        $payload = Payload::delete('files', $file);

        /** @var Response<array{id: string, object: string, deleted: bool}> $response */
        $response = $this->transporter->requestObject($payload);

        return DeleteResponse::from($response->data(), $response->meta());
    }
}
PK     S%W]ý:–Ô  Ô    client/src/Resources/Edits.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Resources;

use OpenAI\Contracts\Resources\EditsContract;
use OpenAI\Responses\Edits\CreateResponse;
use OpenAI\ValueObjects\Transporter\Payload;
use OpenAI\ValueObjects\Transporter\Response;

final class Edits implements EditsContract
{
    use Concerns\Transportable;

    /**
     * Creates a new edit for the provided input, instruction, and parameters.
     *
     *
     *
     * @deprecated OpenAI has deprecated this endpoint and will stop working by January 4, 2024.
     * https://openai.com/blog/gpt-4-api-general-availability#deprecation-of-the-edits-api
     * @see https://platform.openai.com/docs/api-reference/edits/create
     *
     * @param  array<string, mixed>  $parameters
     */
    public function create(array $parameters): CreateResponse
    {
        $payload = Payload::create('edits', $parameters);

        /** @var Response<array{object: string, created: int, choices: array<int, array{text: string, index: int}>, usage: array{prompt_tokens: int, completion_tokens: int, total_tokens: int}}> $response */
        $response = $this->transporter->requestObject($payload);

        return CreateResponse::from($response->data(), $response->meta());
    }
}
PK     S%W]h£n•I  I  $  client/src/Resources/Moderations.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Resources;

use OpenAI\Contracts\Resources\ModerationsContract;
use OpenAI\Responses\Moderations\CreateResponse;
use OpenAI\ValueObjects\Transporter\Payload;
use OpenAI\ValueObjects\Transporter\Response;

final class Moderations implements ModerationsContract
{
    use Concerns\Transportable;

    /**
     * Classifies if text violates OpenAI's Content Policy.
     *
     * @see https://platform.openai.com/docs/api-reference/moderations/create
     *
     * @param  array<string, mixed>  $parameters
     */
    public function create(array $parameters): CreateResponse
    {
        $payload = Payload::create('moderations', $parameters);

        /** @var Response<array{id: string, model: string, results: array<int, array{categories: array<string, bool>, category_scores: array<string, float>, flagged: bool,category_applied_input_types?: array<string, array<int, string>>}>}> $response */
        $response = $this->transporter->requestObject($payload);

        return CreateResponse::from($response->data(), $response->meta());
    }
}
PK     S%W]Øf£S  S  0  client/src/Resources/VectorStoresFileBatches.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace OpenAI\Resources;

use OpenAI\Contracts\Resources\VectorStoresFileBatchesContract;
use OpenAI\Responses\VectorStores\FileBatches\VectorStoreFileBatchResponse;
use OpenAI\Responses\VectorStores\Files\VectorStoreFileListResponse;
use OpenAI\ValueObjects\Transporter\Payload;
use OpenAI\ValueObjects\Transporter\Response;

final class VectorStoresFileBatches implements VectorStoresFileBatchesContract
{
    use Concerns\Transportable;

    /**
     * Create a file batch on a vector store
     *
     * @see https://platform.openai.com/docs/api-reference/vector-stores-file-batches/createBatch
     *
     * @param  array<string, mixed>  $parameters
     */
    public function create(string $vectorStoreId, array $parameters): VectorStoreFileBatchResponse
    {
        $payload = Payload::create("vector_stores/$vectorStoreId/file_batches", $parameters);

        /** @var Response<array{id: string, object: string, created_at: int, vector_store_id: string, status: string, file_counts: array{in_progress: int, completed: int, failed: int, cancelled: int, total: int}}> $response */
        $response = $this->transporter->requestObject($payload);

        return VectorStoreFileBatchResponse::from($response->data(), $response->meta());
    }

    /**
     * Retrieves a file batch within a vector store.
     *
     * @see https://platform.openai.com/docs/api-reference/vector-stores-file-batches/getBatch
     */
    public function retrieve(string $vectorStoreId, string $fileBatchId): VectorStoreFileBatchResponse
    {
        $payload = Payload::retrieve("vector_stores/$vectorStoreId/file_batches", $fileBatchId);

        /** @var Response<array{id: string, object: string, created_at: int, vector_store_id: string, status: string, file_counts: array{in_progress: int, completed: int, failed: int, cancelled: int, total: int}}> $response */
        $response = $this->transporter->requestObject($payload);

        return VectorStoreFileBatchResponse::from($response->data(), $response->meta());
    }

    /**
     * Lists the files within a file batch within a vector store
     *
     * @see https://platform.openai.com/docs/api-reference/vector-stores-file-batches/listBatchFiles
     *
     * @param  array<string, mixed>  $parameters
     */
    public function listFiles(string $vectorStoreId, string $fileBatchId, array $parameters = []): VectorStoreFileListResponse
    {
        $payload = Payload::list("vector_stores/$vectorStoreId/file_batches/$fileBatchId/files", $parameters);

        /** @var Response<array{object: string, data: array<int, array{id: string, object: string, usage_bytes: int, created_at: int, vector_store_id: string, status: string, attributes: array<string, string>, last_error: ?array{code: string, message: string}, chunking_strategy: array{type: 'static', static: array{max_chunk_size_tokens: int, chunk_overlap_tokens: int}}|array{type: 'other'}}>, first_id: ?string, last_id: ?string, has_more: bool}> $response */
        $response = $this->transporter->requestObject($payload);

        return VectorStoreFileListResponse::from($response->data(), $response->meta());
    }

    /**
     * Cancel a vector store file batch
     *
     * @see https://platform.openai.com/docs/api-reference/vector-stores-file-batches/cancelBatch
     */
    public function cancel(string $vectorStoreId, string $fileBatchId): VectorStoreFileBatchResponse
    {
        $payload = Payload::cancel("vector_stores/$vectorStoreId/file_batches", $fileBatchId);

        /** @var Response<array{id: string, object: string, created_at: int, vector_store_id: string, status: string, file_counts: array{in_progress: int, completed: int, failed: int, cancelled: int, total: int}}> $response */
        $response = $this->transporter->requestObject($payload);

        return VectorStoreFileBatchResponse::from($response->data(), $response->meta());
    }
}
PK     S%W]N§&‘  ‘    client/composer.jsonnu „[µü¤        {
    "version": "0.15.0",
    "name": "openai-php/client",
    "description": "OpenAI PHP is a supercharged PHP API client that allows you to interact with the Open AI API",
    "keywords": ["php", "openai", "sdk", "codex", "GPT-3", "DALL-E", "api", "client", "natural", "language", "processing"],
    "license": "MIT",
    "authors": [
        {
            "name": "Nuno Maduro",
            "email": "enunomaduro@gmail.com"
        },
        {
            "name": "Sandro Gehri"
        }
    ],
    "require": {
        "php": "^8.2.0",
        "php-http/discovery": "^1.20.0",
        "php-http/multipart-stream-builder": "^1.4.2",
        "psr/http-client": "^1.0.3",
        "psr/http-client-implementation": "^1.0.1",
        "psr/http-factory-implementation": "*",
        "psr/http-message": "^1.1.0|^2.0.0"
    },
    "require-dev": {
        "guzzlehttp/guzzle": "^7.9.3",
        "guzzlehttp/psr7": "^2.7.1",
        "laravel/pint": "^1.24.0",
        "mockery/mockery": "^1.6.12",
        "nunomaduro/collision": "^8.8.0",
        "pestphp/pest": "^3.8.2|^4.0.0",
        "pestphp/pest-plugin-arch": "^3.1.1|^4.0.0",
        "pestphp/pest-plugin-type-coverage": "^3.5.1|^4.0.0",
        "phpstan/phpstan": "^1.12.25",
        "symfony/var-dumper": "^7.2.6"
    },
    "autoload": {
        "psr-4": {
            "OpenAI\\": "src/"
        },
        "files": [
            "src/OpenAI.php"
        ]
    },
    "autoload-dev": {
        "psr-4": {
            "Tests\\": "tests/"
        }
    },
    "minimum-stability": "dev",
    "prefer-stable": true,
    "config": {
        "sort-packages": true,
        "preferred-install": "dist",
        "allow-plugins": {
            "pestphp/pest-plugin": true,
            "php-http/discovery": false
        }
    },
    "scripts": {
        "lint": "pint -v --parallel",
        "test:lint": "pint --test -v --parallel",
        "test:types": "phpstan analyse --ansi",
        "test:type-coverage": "pest --type-coverage --min=100",
        "test:unit": "pest --colors=always",
        "test": [
            "@test:lint",
            "@test:types",
            "@test:type-coverage",
            "@test:unit"
        ]
    }
}
PK     S%W]E_>	I  I    client/LICENSE.mdnu „[µü¤        The MIT License (MIT)

Copyright (c) Nuno Maduro <enunomaduro@gmail.com>

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
PK       S%W]b+¨ñÍ  Í                  laravel/src/Facades/OpenAI.phpnu „[µü¤        PK       S%W]fuW³q   q   "              laravel/src/Testing/OpenAIFake.phpnu „[µü¤        PK       S%W]ƒZÅ  Å  *            Þ  laravel/src/Exceptions/ApiKeyIsMissing.phpnu „[µü¤        PK       S%W]O:±‡  ‡              ý	  laravel/src/Support/View.phpnu „[µü¤        PK       S%W]K£S†  †  '            Ð  laravel/src/Commands/InstallCommand.phpnu „[µü¤        PK       S%W]B£ÕI	  	              ­   laravel/src/ServiceProvider.phpnu „[µü¤        PK       S%W]0Bá‘¿  ¿              *  laravel/composer.jsonnu „[µü¤        PK       S%W]E_>	I  I              1  laravel/LICENSE.mdnu „[µü¤        PK       S%W]º{>ö      /            §5  laravel/resources/views/components/new-line.phpnu „[µü¤        PK       S%W]Ùêf¢  ¢  ,            6  laravel/resources/views/components/badge.phpnu „[µü¤        PK       S%W]dÂ¾FL  L  8            8  laravel/resources/views/components/two-column-detail.phpnu „[µü¤        PK       S%W]p;Ÿ?  ?              Ä9  laravel/config/openai.phpnu „[µü¤        PK       S%W]$õµWÃ  Ã  '            LA  client/src/ValueObjects/ResourceUri.phpnu „[µü¤        PK       S%W]]¯”  ”  /            fJ  client/src/ValueObjects/Transporter/Headers.phpnu „[µü¤        PK       S%W]òÃ¸  ¸  0            YS  client/src/ValueObjects/Transporter/Response.phpnu „[µü¤        PK       S%W]Ÿ,J–  –  3            qX  client/src/ValueObjects/Transporter/QueryParams.phpnu „[µü¤        PK       S%W]ö¡Ô•      /            j\  client/src/ValueObjects/Transporter/Payload.phpnu „[µü¤        PK       S%W]di›?  ?  /            iu  client/src/ValueObjects/Transporter/BaseUri.phpnu „[µü¤        PK       S%W]B@9w)  )  "            y  client/src/ValueObjects/ApiKey.phpnu „[µü¤        PK       S%W]Bdá-  -              ‚{  client/src/Factory.phpnu „[µü¤        PK       S%W]¿!Ã  Ã              õ  client/src/OpenAI.phpnu „[µü¤        PK       S%W]œÅ0    +            ý’  client/src/Testing/Requests/TestRequest.phpnu „[µü¤        PK       S%W]ÞÔš8  8  !            m•  client/src/Testing/ClientFake.phpnu „[µü¤        PK       S%W](º{;Ü  Ü  2            ö­  client/src/Testing/Responses/Concerns/Fakeable.phpnu „[µü¤        PK       S%W]gÝ§ëT  T  E            4¶  client/src/Testing/Responses/Concerns/FakeableForStreamedResponse.phpnu „[µü¤        PK       S%W]6C£  £  M            ý¹  client/src/Testing/Responses/Fixtures/Assistants/AssistantResponseFixture.phpnu „[µü¤        PK       S%W]Èï€ô  ô  Q            ½  client/src/Testing/Responses/Fixtures/Assistants/AssistantListResponseFixture.phpnu „[µü¤        PK       S%W]9­Ä    S            ’Á  client/src/Testing/Responses/Fixtures/Assistants/AssistantDeleteResponseFixture.phpnu „[µü¤        PK       S%W]³Þ*P    K            &Ã  client/src/Testing/Responses/Fixtures/Moderations/CreateResponseFixture.phpnu „[µü¤        PK       S%W]:Y}r ×   ×  ?            ¤Ê  client/src/Testing/Responses/Fixtures/Audio/speech-streamed.mp3nu „[µü¤        PK       S%W]uHù+  +  J            ³¢ client/src/Testing/Responses/Fixtures/Audio/TranslationResponseFixture.phpnu „[µü¤        PK       S%W]×*¥·0  0  L            X§ client/src/Testing/Responses/Fixtures/Audio/TranscriptionResponseFixture.phpnu „[µü¤        PK       S%W]ºÚ¬
  
  M            ¬ client/src/Testing/Responses/Fixtures/Threads/ThreadDeleteResponseFixture.phpnu „[µü¤        PK       S%W]ðÀ*  *  G            ‹­ client/src/Testing/Responses/Fixtures/Threads/ThreadResponseFixture.phpnu „[µü¤        PK       S%W]’vµE  E  Y            ,¯ client/src/Testing/Responses/Fixtures/Threads/Runs/Steps/ThreadRunStepResponseFixture.phpnu „[µü¤        PK       S%W]‹ßî  î  ]            ú³ client/src/Testing/Responses/Fixtures/Threads/Runs/Steps/ThreadRunStepListResponseFixture.phpnu „[µü¤        PK       S%W]K>óçl%  l%  U            uº client/src/Testing/Responses/Fixtures/Threads/Runs/ThreadRunStreamResponseFixture.txtnu „[µü¤        PK       S%W]x”¬×  ×  O            fà client/src/Testing/Responses/Fixtures/Threads/Runs/ThreadRunResponseFixture.phpnu „[µü¤        PK       S%W]·ÛÎî-  -  S            ¼æ client/src/Testing/Responses/Fixtures/Threads/Runs/ThreadRunListResponseFixture.phpnu „[µü¤        PK       S%W]VOg(V  V  [            lî client/src/Testing/Responses/Fixtures/Threads/Messages/ThreadMessageListResponseFixture.phpnu „[µü¤        PK       S%W] ahY    ]            Mõ client/src/Testing/Responses/Fixtures/Threads/Messages/ThreadMessageDeleteResponseFixture.phpnu „[µü¤        PK       S%W]ÈÞ<ä    W            ùö client/src/Testing/Responses/Fixtures/Threads/Messages/ThreadMessageResponseFixture.phpnu „[µü¤        PK       S%W]Ò8éÉC  C  J            ü client/src/Testing/Responses/Fixtures/Batches/BatchListResponseFixture.phpnu „[µü¤        PK       S%W]Þk†r  r  F            Ì client/src/Testing/Responses/Fixtures/Batches/BatchResponseFixture.phpnu „[µü¤        PK       S%W]Õÿ§Æ    H            ´ client/src/Testing/Responses/Fixtures/Models/RetrieveResponseFixture.phpnu „[µü¤        PK       S%W]§åýþ   þ   F            E	 client/src/Testing/Responses/Fixtures/Models/DeleteResponseFixture.phpnu „[µü¤        PK       S%W]¶?Ëõ   õ   D            ¹
 client/src/Testing/Responses/Fixtures/Models/ListResponseFixture.phpnu „[µü¤        PK       S%W]äŸ£Ö  Ö  E            " client/src/Testing/Responses/Fixtures/Edits/CreateResponseFixture.phpnu „[µü¤        PK       S%W]ºš‘Û  Û  K            m client/src/Testing/Responses/Fixtures/Completions/CreateResponseFixture.phpnu „[µü¤        PK       S%W]!Z–<Æ  Æ  S            Ã client/src/Testing/Responses/Fixtures/Completions/CreateStreamedResponseFixture.txtnu „[µü¤        PK       S%W]´»Y+Ù  Ù  D             client/src/Testing/Responses/Fixtures/Chat/CreateResponseFixture.phpnu „[µü¤        PK       S%W]®œ-¤  ¤  L            Y client/src/Testing/Responses/Fixtures/Chat/CreateStreamedResponseFixture.txtnu „[µü¤        PK       S%W]ÕgÓ(  (  D            y( client/src/Testing/Responses/Fixtures/Images/EditResponseFixture.phpnu „[µü¤        PK       S%W]ÐÇR-  -  I            * client/src/Testing/Responses/Fixtures/Images/VariationResponseFixture.phpnu „[µü¤        PK       S%W]/:z*  *  F            »+ client/src/Testing/Responses/Fixtures/Images/CreateResponseFixture.phpnu „[µü¤        PK       S%W]ÿÏV>…  …  V            [- client/src/Testing/Responses/Fixtures/Realtime/TranscriptionSessionResponseFixture.phpnu „[µü¤        PK       S%W]™ýÂ¸ø  ø  I            f0 client/src/Testing/Responses/Fixtures/Realtime/SessionResponseFixture.phpnu „[µü¤        PK       S%W][f<Ýä  ä  b            ×4 client/src/Testing/Responses/Fixtures/VectorStores/Search/VectorStoreSearchResponseFileFixture.phpnu „[µü¤        PK       S%W]Èÿ|À  À  ^            M7 client/src/Testing/Responses/Fixtures/VectorStores/Search/VectorStoreSearchResponseFixture.phpnu „[µü¤        PK       S%W]û¯®ù    e            ›; client/src/Testing/Responses/Fixtures/VectorStores/Search/VectorStoreSearchResponseContentFixture.phpnu „[µü¤        PK       S%W]Í÷W…  …  U            2= client/src/Testing/Responses/Fixtures/VectorStores/VectorStoreListResponseFixture.phpnu „[µü¤        PK       S%W]<®pfé  é  Q            <E client/src/Testing/Responses/Fixtures/VectorStores/VectorStoreResponseFixture.phpnu „[µü¤        PK       S%W] îîÕ1  1  _            ¦H client/src/Testing/Responses/Fixtures/VectorStores/Files/VectorStoreFileListResponseFixture.phpnu „[µü¤        PK       S%W]HŒ,ð    [            fL client/src/Testing/Responses/Fixtures/VectorStores/Files/VectorStoreFileResponseFixture.phpnu „[µü¤        PK       S%W]ß,„&'  '  a            ùN client/src/Testing/Responses/Fixtures/VectorStores/Files/VectorStoreFileDeleteResponseFixture.phpnu „[µü¤        PK       S%W]%_†    W            ±P client/src/Testing/Responses/Fixtures/VectorStores/VectorStoreDeleteResponseFixture.phpnu „[µü¤        PK       S%W]¢rÀ½    L            NR client/src/Testing/Responses/Fixtures/FineTuning/ListJobsResponseFixture.phpnu „[µü¤        PK       S%W]ËÏÖ	×  ×  O            çS client/src/Testing/Responses/Fixtures/FineTuning/RetrieveJobResponseFixture.phpnu „[µü¤        PK       S%W]Ï¥·{  {  Q            =X client/src/Testing/Responses/Fixtures/FineTuning/ListJobEventsResponseFixture.phpnu „[µü¤        PK       S%W]ZÞ°Û?  ?  J            9[ client/src/Testing/Responses/Fixtures/Embeddings/CreateResponseFixture.phpnu „[µü¤        PK       S%W];k‡\  \  K            ò] client/src/Testing/Responses/Fixtures/Responses/RetrieveResponseFixture.phpnu „[µü¤        PK       S%W]j>bF    I            Ém client/src/Testing/Responses/Fixtures/Responses/ListInputItemsFixture.phpnu „[µü¤        PK       S%W]pÁ‹EZ  Z  I            Ãq client/src/Testing/Responses/Fixtures/Responses/CancelResponseFixture.phpnu „[µü¤        PK       S%W]ßÕÌ    I            – client/src/Testing/Responses/Fixtures/Responses/DeleteResponseFixture.phpnu „[µü¤        PK       S%W]$® Z  Z  I            %ƒ client/src/Testing/Responses/Fixtures/Responses/ResponseObjectFixture.phpnu „[µü¤        PK       S%W]-Å«Z  Z  I            ø’ client/src/Testing/Responses/Fixtures/Responses/CreateResponseFixture.phpnu „[µü¤        PK       S%W]ÝP›3  3  Q            Ë¢ client/src/Testing/Responses/Fixtures/Responses/CreateStreamedResponseFixture.txtnu „[µü¤        PK       S%W]KißÃÚ  Ú  G            ° client/src/Testing/Responses/Fixtures/Files/RetrieveResponseFixture.phpnu „[µü¤        PK       S%W]J÷¹ö   ö   E            Ð² client/src/Testing/Responses/Fixtures/Files/DeleteResponseFixture.phpnu „[µü¤        PK       S%W]fMp  p  C            ;´ client/src/Testing/Responses/Fixtures/Files/ListResponseFixture.phpnu „[µü¤        PK       S%W]tFÐØ  Ø  E            · client/src/Testing/Responses/Fixtures/Files/CreateResponseFixture.phpnu „[µü¤        PK       S%W]â&™tf  f  K            k¹ client/src/Testing/Responses/Fixtures/FineTunes/RetrieveResponseFixture.phpnu „[µü¤        PK       S%W]Z­`ÝV  V  X            L¿ client/src/Testing/Responses/Fixtures/FineTunes/RetrieveStreamedResponseEventFixture.txtnu „[µü¤        PK       S%W]n,éFø   ø   G            *Å client/src/Testing/Responses/Fixtures/FineTunes/ListResponseFixture.phpnu „[µü¤        PK       S%W]ì½¸Ý  Ý  M            ™Æ client/src/Testing/Responses/Fixtures/FineTunes/ListEventsResponseFixture.phpnu „[µü¤        PK       S%W]WbÎÈ  È  9            óÈ client/src/Testing/Resources/VectorStoresTestResource.phpnu „[µü¤        PK       S%W]¶¨)@Â  Â  4            $Ñ client/src/Testing/Resources/BatchesTestResource.phpnu „[µü¤        PK       S%W]É»â#    D            JÕ client/src/Testing/Resources/VectorStoresFileBatchesTestResource.phpnu „[µü¤        PK       S%W]å 7?  ?  7            ÄÚ client/src/Testing/Resources/ContainersTestResource.phpnu „[µü¤        PK       S%W]¨T[<  <  6            jß client/src/Testing/Resources/FineTunesTestResource.phpnu „[µü¤        PK       S%W]¿ÌŒ  Œ  2            å client/src/Testing/Resources/FilesTestResource.phpnu „[µü¤        PK       S%W]±ˆA—l  l  3            úé client/src/Testing/Resources/ImagesTestResource.phpnu „[µü¤        PK       S%W]—¤ÇgÅ  Å  7            Éí client/src/Testing/Resources/AssistantsTestResource.phpnu „[µü¤        PK       S%W]BÄ5ïð  ð  5            õò client/src/Testing/Resources/RealtimeTestResource.phpnu „[µü¤        PK       S%W]TÒßü÷  ÷  >            Jö client/src/Testing/Resources/VectorStoresFilesTestResource.phpnu „[µü¤        PK       S%W]Æsn¿™  ™  2            ¯û client/src/Testing/Resources/Concerns/Testable.phpnu „[µü¤        PK       S%W]§b…ä  ä  7            ªÿ client/src/Testing/Resources/FineTuningTestResource.phpnu „[µü¤        PK       S%W]ãž}t  t  6            õ client/src/Testing/Resources/ResponsesTestResource.phpnu „[µü¤        PK       S%W]9©M¾Ô  Ô  8            Ï
 client/src/Testing/Resources/CompletionsTestResource.phpnu „[µü¤        PK       S%W]ÚV  V  4             client/src/Testing/Resources/ThreadsTestResource.phpnu „[µü¤        PK       S%W] z¢±  ±  8            Å client/src/Testing/Resources/ThreadsRunsTestResource.phpnu „[µü¤        PK       S%W]x`,ö    <            Þ client/src/Testing/Resources/ThreadsMessagesTestResource.phpnu „[µü¤        PK       S%W]rv±õ    7            É" client/src/Testing/Resources/EmbeddingsTestResource.phpnu „[µü¤        PK       S%W]ÅˆYÞ?  ?  3            I% client/src/Testing/Resources/ModelsTestResource.phpnu „[µü¤        PK       S%W]•û  û  2            ë( client/src/Testing/Resources/EditsTestResource.phpnu „[µü¤        PK       S%W]îˆÐéÍ  Í  2            H+ client/src/Testing/Resources/AudioTestResource.phpnu „[µü¤        PK       S%W]Éb¤Ô    8            w0 client/src/Testing/Resources/ModerationsTestResource.phpnu „[µü¤        PK       S%W]~dÏZ^  ^  =            þ2 client/src/Testing/Resources/ThreadsRunsStepsTestResource.phpnu „[µü¤        PK       S%W]yypª  ª  1            É6 client/src/Testing/Resources/ChatTestResource.phpnu „[µü¤        PK       S%W]f)Þ'†   †   /            Ô9 client/src/Exceptions/UnknownEventException.phpnu „[µü¤        PK       S%W]^˜ä„  „  .            ¹: client/src/Exceptions/TransporterException.phpnu „[µü¤        PK       S%W]€-¥x`  `  0            ›< client/src/Exceptions/UnserializableResponse.phpnu „[µü¤        PK       S%W]	¢"  "  (            [> client/src/Exceptions/ErrorException.phpnu „[µü¤        PK       S%W]’é.‰   ‰   2            ÕC client/src/Exceptions/InvalidArgumentException.phpnu „[µü¤        PK       S%W]tè9Z¼   ¼   9            ÀD client/src/Enums/Moderations/CategoryAppliedInputType.phpnu „[µü¤        PK       S%W]TN+n  n  )            åE client/src/Enums/Moderations/Category.phpnu „[µü¤        PK       S%W]cû'"ì   ì   ,            ¬H client/src/Enums/Transporter/ContentType.phpnu „[µü¤        PK       S%W]©Ó   Ó   '            ôI client/src/Enums/Transporter/Method.phpnu „[µü¤        PK       S%W]™::ž   ž   4            K client/src/Enums/FineTuning/FineTuningEventLevel.phpnu „[µü¤        PK       S%W]Kô‰wM  M  +             L client/src/Transporters/HttpTransporter.phpnu „[µü¤        PK       S%W]Ö¡ØÛ  Û  ,            È] client/src/Contracts/TransporterContract.phpnu „[µü¤        PK       S%W]1ˆÈ   È   ;            ÿa client/src/Contracts/ResponseHasMetaInformationContract.phpnu „[µü¤        PK       S%W].
b(    )            2c client/src/Contracts/ResponseContract.phpnu „[µü¤        PK       S%W]&S®F&  &  0            ¢g client/src/Contracts/MetaInformationContract.phpnu „[µü¤        PK       S%W]ž¸D  D  :            (l client/src/Contracts/Resources/ThreadsMessagesContract.phpnu „[µü¤        PK       S%W]Êudˆ2	  2	  7            Ör client/src/Contracts/Resources/VectorStoresContract.phpnu „[µü¤        PK       S%W]ÊýO  O  3            o| client/src/Contracts/Resources/RealtimeContract.phpnu „[µü¤        PK       S%W]Û°$ðÂ  Â  B            !€ client/src/Contracts/Resources/VectorStoresFileBatchesContract.phpnu „[µü¤        PK       S%W]_šÖux  x  4            U† client/src/Contracts/Resources/FineTunesContract.phpnu „[µü¤        PK       S%W]ÿß/ïe  e  0            1Ž client/src/Contracts/Resources/EditsContract.phpnu „[µü¤        PK       S%W]lÕ¸™ÿ  ÿ  ;            ö client/src/Contracts/Resources/ThreadsRunsStepsContract.phpnu „[µü¤        PK       S%W]ÖËãŸ  Ÿ  5            `” client/src/Contracts/Resources/FineTuningContract.phpnu „[µü¤        PK       S%W]½mí
&  &  /            d› client/src/Contracts/Resources/ChatContract.phpnu „[µü¤        PK       S%W]Ë¨°–    1            éž client/src/Contracts/Resources/ImagesContract.phpnu „[µü¤        PK       S%W]š.d›  ›  5            Y£ client/src/Contracts/Resources/EmbeddingsContract.phpnu „[µü¤        PK       S%W]Ì‚fÁ  Á  2            Y¥ client/src/Contracts/Resources/ThreadsContract.phpnu „[µü¤        PK       S%W]l~2ƒ  ƒ  6            |® client/src/Contracts/Resources/CompletionsContract.phpnu „[µü¤        PK       S%W]aÒùSš  š  6            e² client/src/Contracts/Resources/ModerationsContract.phpnu „[µü¤        PK       S%W]>…Ñòš  š  0            e´ client/src/Contracts/Resources/FilesContract.phpnu „[µü¤        PK       S%W]Z3#¯…  …  <            _º client/src/Contracts/Resources/VectorStoresFilesContract.phpnu „[µü¤        PK       S%W]7Ÿˆh  h  6            PÀ client/src/Contracts/Resources/ThreadsRunsContract.phpnu „[µü¤        PK       S%W]ƒ#XOè  è  1            Ì client/src/Contracts/Resources/ModelsContract.phpnu „[µü¤        PK       S%W]óQë    0            gÐ client/src/Contracts/Resources/AudioContract.phpnu „[µü¤        PK       S%W]¦îËB    5            Ú× client/src/Contracts/Resources/ContainersContract.phpnu „[µü¤        PK       S%W]`Äá®~  ~  4            FÝ client/src/Contracts/Resources/ResponsesContract.phpnu „[µü¤        PK       S%W]Oç„=  =  2            (æ client/src/Contracts/Resources/BatchesContract.phpnu „[µü¤        PK       S%W]'úx+Ë  Ë  5            Çê client/src/Contracts/Resources/AssistantsContract.phpnu „[µü¤        PK       S%W]G¡Uä   ä   /            ÷ð client/src/Contracts/ResponseStreamContract.phpnu „[µü¤        PK       S%W]Kêä   ä   +            :ò client/src/Contracts/StringableContract.phpnu „[µü¤        PK       S%W]i4‰  ‰  '            yó client/src/Contracts/ClientContract.phpnu „[µü¤        PK       S%W]EžÌ®¼  ¼              Y client/src/Client.phpnu „[µü¤        PK       S%W]kàˆhm  m  5            Z! client/src/Responses/Assistants/AssistantResponse.phpnu „[µü¤        PK       S%W]Z1š¸Ž  Ž  A            ,9 client/src/Responses/Assistants/AssistantResponseToolFunction.phpnu „[µü¤        PK       S%W]{#By>  >  P            +? client/src/Responses/Assistants/AssistantResponseToolResourceCodeInterpreter.phpnu „[µü¤        PK       S%W]-:Gì¨  ¨  I            éC client/src/Responses/Assistants/AssistantResponseToolFunctionFunction.phpnu „[µü¤        PK       S%W]…o½lÂ  Â  C            
J client/src/Responses/Assistants/AssistantResponseToolFileSearch.phpnu „[µü¤        PK       S%W]AË:¬ƒ  ƒ  9            ?N client/src/Responses/Assistants/AssistantListResponse.phpnu „[µü¤        PK       S%W]vÂè,'  '  ;            +^ client/src/Responses/Assistants/AssistantDeleteResponse.phpnu „[µü¤        PK       S%W]›©É  É  C            ½d client/src/Responses/Assistants/AssistantResponseResponseFormat.phpnu „[µü¤        PK       S%W]ÊJÚ3v  v  K            ùh client/src/Responses/Assistants/AssistantResponseToolResourceFileSearch.phpnu „[µü¤        PK       S%W]‚™Ì  Ì  H            êm client/src/Responses/Assistants/AssistantResponseToolCodeInterpreter.phpnu „[µü¤        PK       S%W]ÒR¾  ¾  B            .r client/src/Responses/Assistants/AssistantResponseToolResources.phpnu „[µü¤        PK       S%W], î¿  ¿  G            ^y client/src/Responses/Assistants/AssistantResponseResponseFormatText.phpnu „[µü¤        PK       S%W]$›Ù«g	  g	  3            ”} client/src/Responses/Moderations/CreateResponse.phpnu „[µü¤        PK       S%W]Ljý ]	  ]	  9            ^‡ client/src/Responses/Moderations/CreateResponseResult.phpnu „[µü¤        PK       S%W]öOÀ†  †  ;            $‘ client/src/Responses/Moderations/CreateResponseCategory.phpnu „[µü¤        PK       S%W]1gìKŽ  Ž  <            ” client/src/Responses/Audio/Streaming/TranscriptTextDelta.phpnu „[µü¤        PK       S%W]KKÑƒ  ƒ  ;            œ client/src/Responses/Audio/Streaming/TranscriptTextDone.phpnu „[µü¤        PK       S%W]†êª'  '  1            ý£ client/src/Responses/Audio/Streaming/Logprobs.phpnu „[µü¤        PK       S%W]ÂÕ«04  4  ;            …ª client/src/Responses/Audio/TranscriptionResponseSegment.phpnu „[µü¤        PK       S%W]šW)¹    3            $¶ client/src/Responses/Audio/SpeechStreamResponse.phpnu „[µü¤        PK       S%W] ¥”X¨  ¨  :            £¼ client/src/Responses/Audio/TranscriptionStreamResponse.phpnu „[µü¤        PK       S%W]— L)Ò  Ò  4            µÄ client/src/Responses/Audio/TranscriptionResponse.phpnu „[µü¤        PK       S%W]‘u5¤™  ™  8            ëÓ client/src/Responses/Audio/TranscriptionResponseWord.phpnu „[µü¤        PK       S%W]z·O    2            ìØ client/src/Responses/Audio/TranslationResponse.phpnu „[µü¤        PK       S%W]”ÝšÕ2  2  9            `å client/src/Responses/Audio/TranslationResponseSegment.phpnu „[µü¤        PK       S%W]¯Â
  
  /            ûð client/src/Responses/Threads/ThreadResponse.phpnu „[µü¤        PK       S%W]é¨¢ !  !  5            oû client/src/Responses/Threads/ThreadDeleteResponse.phpnu „[µü¤        PK       S%W]ƒùŒ§  §  A            õ client/src/Responses/Threads/Runs/ThreadRunResponseToolChoice.phpnu „[µü¤        PK       S%W]~B\[  [  @             client/src/Responses/Threads/Runs/ThreadRunResponseLastError.phpnu „[µü¤        PK       S%W]Žæ£“  “  E            Ø client/src/Responses/Threads/Runs/Steps/ThreadRunStepListResponse.phpnu „[µü¤        PK       S%W];ÅøI…  …  F            à  client/src/Responses/Threads/Runs/Steps/ThreadRunStepResponseUsage.phpnu „[µü¤        PK       S%W]¸­=JŠ  Š  Z            Û& client/src/Responses/Threads/Runs/Steps/ThreadRunStepResponseCodeInterpreterOutputLogs.phpnu „[µü¤        PK       S%W]d†º¤	  ¤	  P            ï+ client/src/Responses/Threads/Runs/Steps/ThreadRunStepResponseCodeInterpreter.phpnu „[µü¤        PK       S%W]Ì61ú  ú  J            6 client/src/Responses/Threads/Runs/Steps/Delta/ThreadRunStepDeltaObject.phpnu „[µü¤        PK       S%W]¬­"‹>  >  L            ‡B client/src/Responses/Threads/Runs/Steps/Delta/ThreadRunStepDeltaResponse.phpnu „[µü¤        PK       S%W]¶œ³ô¼  ¼  S            AN client/src/Responses/Threads/Runs/Steps/ThreadRunStepResponseFileSearchToolCall.phpnu „[µü¤        PK       S%W]EÉ|-§  §  [            €T client/src/Responses/Threads/Runs/Steps/ThreadRunStepResponseMessageCreationStepDetails.phpnu „[µü¤        PK       S%W]hÖà§k  k  M            ²Z client/src/Responses/Threads/Runs/Steps/ThreadRunStepResponseCodeToolCall.phpnu „[µü¤        PK       S%W]ï¡V¹Ê  Ê  U            šb client/src/Responses/Threads/Runs/Steps/ThreadRunStepResponseToolCallsStepDetails.phpnu „[µü¤        PK       S%W]tÛEÔ<  <  [            éo client/src/Responses/Threads/Runs/Steps/ThreadRunStepResponseCodeInterpreterOutputImage.phpnu „[µü¤        PK       S%W]#Srì    Q            °u client/src/Responses/Threads/Runs/Steps/ThreadRunStepResponseFunctionToolCall.phpnu „[µü¤        PK       S%W]]U³Àë  ë  `            O| client/src/Responses/Threads/Runs/Steps/ThreadRunStepResponseCodeInterpreterOutputImageImage.phpnu „[µü¤        PK       S%W]Äªÿýð  ð  P            Ê€ client/src/Responses/Threads/Runs/Steps/ThreadRunStepResponseMessageCreation.phpnu „[µü¤        PK       S%W]T	«-  -  A            :… client/src/Responses/Threads/Runs/Steps/ThreadRunStepResponse.phpnu „[µü¤        PK       S%W]þ6ò)  )  I            Øž client/src/Responses/Threads/Runs/Steps/ThreadRunStepResponseFunction.phpnu „[µü¤        PK       S%W]ö¯i  i  =            z¤ client/src/Responses/Threads/Runs/ThreadRunStreamResponse.phpnu „[µü¤        PK       S%W]SÚ´DÀ  À  A            P² client/src/Responses/Threads/Runs/ThreadRunResponseFileSearch.phpnu „[µü¤        PK       S%W]I},úÎ  Î  J            ¶ client/src/Responses/Threads/Runs/ThreadRunResponseToolCodeInterpreter.phpnu „[µü¤        PK       S%W]æÖº    C            Éº client/src/Responses/Threads/Runs/ThreadRunResponseToolFunction.phpnu „[µü¤        PK       S%W]ý%*ÄŠ  Š  I            ÉÀ client/src/Responses/Threads/Runs/ThreadRunResponseTruncationStrategy.phpnu „[µü¤        PK       S%W]sƒòƒ  ƒ  V            ÌÅ client/src/Responses/Threads/Runs/ThreadRunResponseRequiredActionSubmitToolOutputs.phpnu „[µü¤        PK       S%W]ÞÖ  Ö  U            ÕÌ client/src/Responses/Threads/Runs/ThreadRunResponseRequiredActionFunctionToolCall.phpnu „[µü¤        PK       S%W]ÁÝŒug  g  E            0Ó client/src/Responses/Threads/Runs/ThreadRunResponseRequiredAction.phpnu „[µü¤        PK       S%W]ƒìg¦  ¦  K            Ú client/src/Responses/Threads/Runs/ThreadRunResponseToolFunctionFunction.phpnu „[µü¤        PK       S%W]02tÁ  Á  I            -à client/src/Responses/Threads/Runs/ThreadRunResponseToolChoiceFunction.phpnu „[µü¤        PK       S%W] ©¤í  í  <            gä client/src/Responses/Threads/Runs/ThreadRunResponseUsage.phpnu „[µü¤        PK       S%W]
z¹‚Î  Î  H            Àè client/src/Responses/Threads/Runs/ThreadRunResponseIncompleteDetails.phpnu „[µü¤        PK       S%W]^®„åh'  h'  7            í client/src/Responses/Threads/Runs/ThreadRunResponse.phpnu „[µü¤        PK       S%W]}Tˆ  ˆ  ]            Õ client/src/Responses/Threads/Runs/ThreadRunResponseRequiredActionFunctionToolCallFunction.phpnu „[µü¤        PK       S%W]ôãëâ  â  ;            ê client/src/Responses/Threads/Runs/ThreadRunListResponse.phpnu „[µü¤        PK       S%W]ë&ãè  è  \            70 client/src/Responses/Threads/Messages/ThreadMessageResponseContentTextAnnotationFilePath.phpnu „[µü¤        PK       S%W]‰3,Ç  Ç  `            «4 client/src/Responses/Threads/Messages/ThreadMessageResponseContentTextAnnotationFileCitation.phpnu „[µü¤        PK       S%W]±ÿí;  ;  H            : client/src/Responses/Threads/Messages/Delta/ThreadMessageDeltaObject.phpnu „[µü¤        PK       S%W]2Äœh  h  `            µG client/src/Responses/Threads/Messages/Delta/ThreadMessageDeltaResponseContentImageFileObject.phpnu „[µü¤        PK       S%W]õÂQUµ  µ  [            ­N client/src/Responses/Threads/Messages/Delta/ThreadMessageDeltaResponseContentTextObject.phpnu „[µü¤        PK       S%W]èºl·    U            íW client/src/Responses/Threads/Messages/Delta/ThreadMessageDeltaResponseContentText.phpnu „[µü¤        PK       S%W]øóäÆ¬
  ¬
  J            ƒd client/src/Responses/Threads/Messages/Delta/ThreadMessageDeltaResponse.phpnu „[µü¤        PK       S%W]ß‚îÁ  Á  f            ©o client/src/Responses/Threads/Messages/ThreadMessageResponseContentTextAnnotationFileCitationObject.phpnu „[µü¤        PK       S%W]xå¹l  l  T             x client/src/Responses/Threads/Messages/ThreadMessageResponseContentImageUrlObject.phpnu „[µü¤        PK       S%W]üzÆ*ò
  ò
  J            ð} client/src/Responses/Threads/Messages/ThreadMessageResponseContentText.phpnu „[µü¤        PK       S%W]aŠ<­  ­  I            \‰ client/src/Responses/Threads/Messages/ThreadMessageResponseAttachment.phpnu „[µü¤        PK       S%W]4Í‰Í    P            ‚‘ client/src/Responses/Threads/Messages/ThreadMessageResponseContentTextObject.phpnu „[µü¤        PK       S%W]3¡¾ÄÖ  Ö  P            š client/src/Responses/Threads/Messages/ThreadMessageResponseIncompleteDetails.phpnu „[µü¤        PK       S%W]EÅn¡¼  ¼  O            mž client/src/Responses/Threads/Messages/ThreadMessageResponseContentImageFile.phpnu „[µü¤        PK       S%W]jšùB    W            ¨£ client/src/Responses/Threads/Messages/ThreadMessageResponseAttachmentFileSearchTool.phpnu „[µü¤        PK       S%W]ž3e1  1  \            G¨ client/src/Responses/Threads/Messages/ThreadMessageResponseAttachmentCodeInterpreterTool.phpnu „[µü¤        PK       S%W]wD‹¬  ¬  C            ­ client/src/Responses/Threads/Messages/ThreadMessageListResponse.phpnu „[µü¤        PK       S%W]`iú1  1  E            #¿ client/src/Responses/Threads/Messages/ThreadMessageDeleteResponse.phpnu „[µü¤        PK       S%W]û×ì  ì  ?            ÉÅ client/src/Responses/Threads/Messages/ThreadMessageResponse.phpnu „[µü¤        PK       S%W]?,‹¡£  £  N            $Ý client/src/Responses/Threads/Messages/ThreadMessageResponseContentImageUrl.phpnu „[µü¤        PK       S%W]á#b„@  @  U            Eâ client/src/Responses/Threads/Messages/ThreadMessageResponseContentImageFileObject.phpnu „[µü¤        PK       S%W]‹-»!S  S  b            
è client/src/Responses/Threads/Messages/ThreadMessageResponseContentTextAnnotationFilePathObject.phpnu „[µü¤        PK       S%W]Þþs·/  /  8            ïï client/src/Responses/Batches/BatchResponseErrorsData.phpnu „[µü¤        PK       S%W]"˜«}  }  2            †õ client/src/Responses/Batches/BatchListResponse.phpnu „[µü¤        PK       S%W]3§AÑÈ  È  .            e client/src/Responses/Batches/BatchResponse.phpnu „[µü¤        PK       S%W]ECh&  &  4            ‹ client/src/Responses/Batches/BatchResponseErrors.phpnu „[µü¤        PK       S%W]Nø 9¢  ¢  ;            " client/src/Responses/Batches/BatchResponseRequestCounts.phpnu „[µü¤        PK       S%W]Æ'ÝŽ£  £  ,            "' client/src/Responses/Models/ListResponse.phpnu „[µü¤        PK       S%W]´;‘•    .            !/ client/src/Responses/Models/DeleteResponse.phpnu „[µü¤        PK       S%W]\eGîý  ý  0            ™5 client/src/Responses/Models/RetrieveResponse.phpnu „[µü¤        PK       S%W]l@ä   ä   4            ö< client/src/Responses/Concerns/HasMetaInformation.phpnu „[µü¤        PK       S%W]ºÒ?5„  „  1            >> client/src/Responses/Concerns/ArrayAccessible.phpnu „[µü¤        PK       S%W]¡æi:Ê	  Ê	  -            #B client/src/Responses/Edits/CreateResponse.phpnu „[µü¤        PK       S%W]0(Ö­  ­  3            JL client/src/Responses/Edits/CreateResponseChoice.phpnu „[µü¤        PK       S%W]j8@Ð  Ð  2            ZO client/src/Responses/Edits/CreateResponseUsage.phpnu „[µü¤        PK       S%W]t}=ž  ž  A            ŒS client/src/Responses/Completions/CreateResponseChoiceLogprobs.phpnu „[µü¤        PK       S%W]×;˜
  ˜
  ;            ›Y client/src/Responses/Completions/CreateStreamedResponse.phpnu „[µü¤        PK       S%W]ÊVÝ6Þ  Þ  3            žd client/src/Responses/Completions/CreateResponse.phpnu „[µü¤        PK       S%W]˜–S
  
  9            ßq client/src/Responses/Completions/CreateResponseChoice.phpnu „[µü¤        PK       S%W]íù½¡é  é  8            Rx client/src/Responses/Completions/CreateResponseUsage.phpnu „[µü¤        PK       S%W]u—“~  ~  8            £| client/src/Responses/Containers/Objects/ExpiresAfter.phpnu „[µü¤        PK       S%W]A˜lJp	  p	  5            ‰ client/src/Responses/Containers/RetrieveContainer.phpnu „[µü¤        PK       S%W]¢†8°ò  ò  2            ^‹ client/src/Responses/Containers/ListContainers.phpnu „[µü¤        PK       S%W]È’f	  f	  3            ²” client/src/Responses/Containers/CreateContainer.phpnu „[µü¤        PK       S%W]kîñ  ñ  3            {ž client/src/Responses/Containers/DeleteContainer.phpnu „[µü¤        PK       S%W]±u‹²Ö  Ö  :            Ï¤ client/src/Responses/Chat/CreateResponseChoiceLogprobs.phpnu „[µü¤        PK       S%W]Li¡¸Õ  Õ  4            ª client/src/Responses/Chat/CreateResponseToolCall.phpnu „[µü¤        PK       S%W]–B#4ˆ  ˆ  H            H® client/src/Responses/Chat/CreateResponseUsageCompletionTokensDetails.phpnu „[µü¤        PK       S%W]In’3      A            Hµ client/src/Responses/Chat/CreateResponseChoiceLogprobsContent.phpnu „[µü¤        PK       S%W]ë:Eø  ø  I            ¹¹ client/src/Responses/Chat/CreateResponseChoiceAnnotationsUrlCitations.phpnu „[µü¤        PK       S%W]²*\º  º  4            *¾ client/src/Responses/Chat/CreateStreamedResponse.phpnu „[µü¤        PK       S%W]ä1Ù	Û  Û  <            HÊ client/src/Responses/Chat/CreateResponseToolCallFunction.phpnu „[µü¤        PK       S%W]lÐ‰î  î  8            Í client/src/Responses/Chat/CreateResponseFunctionCall.phpnu „[µü¤        PK       S%W]ŒŠ:¬‹  ‹  @            åÐ client/src/Responses/Chat/CreateStreamedResponseFunctionCall.phpnu „[µü¤        PK       S%W]µT…j†  †  ,            àÔ client/src/Responses/Chat/CreateResponse.phpnu „[µü¤        PK       S%W];Ï·ä  ä  9            Âç client/src/Responses/Chat/CreateStreamedResponseDelta.phpnu „[µü¤        PK       S%W]so~  ~  D            ð client/src/Responses/Chat/CreateResponseUsagePromptTokensDetails.phpnu „[µü¤        PK       S%W]ŒÙV}  }  :            ô client/src/Responses/Chat/CreateStreamedResponseChoice.phpnu „[µü¤        PK       S%W]ž¨83  3  D            èø client/src/Responses/Chat/CreateStreamedResponseToolCallFunction.phpnu „[µü¤        PK       S%W]}Qu*    2            ü client/src/Responses/Chat/CreateResponseChoice.phpnu „[µü¤        PK       S%W]¯¬úõ  õ  1             client/src/Responses/Chat/CreateResponseUsage.phpnu „[µü¤        PK       S%W]E1Y}±  ±  =            a client/src/Responses/Chat/CreateResponseChoiceAnnotations.phpnu „[µü¤        PK       S%W]v¨ºQ’  ’  7             client/src/Responses/Chat/CreateResponseChoiceAudio.phpnu „[µü¤        PK       S%W]˜YÃÓ  Ó  <            x client/src/Responses/Chat/CreateStreamedResponseToolCall.phpnu „[µü¤        PK       S%W]ÚMt  t  3            · client/src/Responses/Chat/CreateResponseMessage.phpnu „[µü¤        PK       S%W]	õÂ„°
  °
  '            Ž) client/src/Responses/StreamResponse.phpnu „[µü¤        PK       S%W]¿£ì°w  w  -            •4 client/src/Responses/Meta/MetaInformation.phpnu „[µü¤        PK       S%W]÷$¦¨  ¨  3            iF client/src/Responses/Meta/MetaInformationOpenAI.phpnu „[µü¤        PK       S%W]õ®Y|%  %  6            tI client/src/Responses/Meta/MetaInformationRateLimit.phpnu „[µü¤        PK       S%W]Ü Ê"
  "
  1            ÿK client/src/Responses/Images/VariationResponse.phpnu „[µü¤        PK       S%W]_'ã	
  	
  ,            ‚V client/src/Responses/Images/EditResponse.phpnu „[µü¤        PK       S%W]r©    D            ç` client/src/Responses/Images/ImageResponseUsageInputTokensDetails.phpnu „[µü¤        PK       S%W]–JÁ  Á  2            `d client/src/Responses/Images/CreateResponseData.phpnu „[µü¤        PK       S%W]3@è?  ?  2            ƒj client/src/Responses/Images/ImageResponseUsage.phpnu „[µü¤        PK       S%W]ÞYæò^
  ^
  .            $p client/src/Responses/Images/CreateResponse.phpnu „[µü¤        PK       S%W]µ÷±X  X  5            àz client/src/Responses/Images/VariationResponseData.phpnu „[µü¤        PK       S%W]%Î^WS  S  0             client/src/Responses/Images/EditResponseData.phpnu „[µü¤        PK       S%W]J2Œu£  £  N            P„ client/src/Responses/Realtime/TranscriptionSession/InputAudioTranscription.phpnu „[µü¤        PK       S%W]‰ÕÌF  F  6            qŠ client/src/Responses/Realtime/Session/ClientSecret.phpnu „[µü¤        PK       S%W]øzÝè    A             client/src/Responses/Realtime/Session/InputAudioTranscription.phpnu „[µü¤        PK       S%W]j L!  !  7            ¤“ client/src/Responses/Realtime/Session/TurnDetection.phpnu „[µü¤        PK       S%W]`t±±G  G  >            ,š client/src/Responses/Realtime/TranscriptionSessionResponse.phpnu „[µü¤        PK       S%W]8òÉê  ê  4            á¥ client/src/Responses/Realtime/Tools/FunctionTool.phpnu „[µü¤        PK       S%W]mgÇá  á  1            /¬ client/src/Responses/Realtime/SessionResponse.phpnu „[µü¤        PK       S%W]œ)#b  b  M            q¿ client/src/Responses/VectorStores/Search/VectorStoreSearchResponseContent.phpnu „[µü¤        PK       S%W]ìê™‹  ‹  F            PÄ client/src/Responses/VectorStores/Search/VectorStoreSearchResponse.phpnu „[µü¤        PK       S%W]Œ)u-
	  
	  J            QÑ client/src/Responses/VectorStores/Search/VectorStoreSearchResponseFile.phpnu „[µü¤        PK       S%W]‡<(~+  +  ?            ÕÚ client/src/Responses/VectorStores/VectorStoreDeleteResponse.phpnu „[µü¤        PK       S%W]‰7!þÒ  Ò  9            oá client/src/Responses/VectorStores/VectorStoreResponse.phpnu „[µü¤        PK       S%W]p÷3q  q  C            ªñ client/src/Responses/VectorStores/VectorStoreResponseFileCounts.phpnu „[µü¤        PK       S%W]NüZH  H  =            Žø client/src/Responses/VectorStores/VectorStoreListResponse.phpnu „[µü¤        PK       S%W]o-£î^  ^  E            C	 client/src/Responses/VectorStores/VectorStoreResponseExpiresAfter.phpnu „[µü¤        PK       S%W]êiXJ9  9  G            	 client/src/Responses/VectorStores/Files/VectorStoreFileListResponse.phpnu „[µü¤        PK       S%W]—tN·q  q  Y            Æ	 client/src/Responses/VectorStores/Files/VectorStoreFileResponseChunkingStrategyStatic.phpnu „[µü¤        PK       S%W]ý˜®    C            À	 client/src/Responses/VectorStores/Files/VectorStoreFileResponse.phpnu „[µü¤        PK       S%W]¢}I 
  
  X            ;/	 client/src/Responses/VectorStores/Files/VectorStoreFileResponseChunkingStrategyOther.phpnu „[µü¤        PK       S%W]2ý{]y  y  L            Í3	 client/src/Responses/VectorStores/Files/VectorStoreFileResponseLastError.phpnu „[µü¤        PK       S%W]W=…«5  5  I            Â8	 client/src/Responses/VectorStores/Files/VectorStoreFileDeleteResponse.phpnu „[µü¤        PK       S%W]è= ^
  
  N            p?	 client/src/Responses/VectorStores/FileBatches/VectorStoreFileBatchResponse.phpnu „[µü¤        PK       S%W]ÂçÉ	  É	  9            J	 client/src/Responses/FineTuning/ListJobEventsResponse.phpnu „[µü¤        PK       S%W]ù¦Qù’  ’  7            3T	 client/src/Responses/FineTuning/RetrieveJobResponse.phpnu „[µü¤        PK       S%W]dq¦ã  ã  >            ,g	 client/src/Responses/FineTuning/ListJobEventsResponseEvent.phpnu „[µü¤        PK       S%W]Ýè˜Ë  Ë  4            }p	 client/src/Responses/FineTuning/ListJobsResponse.phpnu „[µü¤        PK       S%W]NsNô  ô  F            ¬}	 client/src/Responses/FineTuning/RetrieveJobResponseHyperparameters.phpnu „[µü¤        PK       S%W]WÀáÈ  È  <            „	 client/src/Responses/FineTuning/RetrieveJobResponseError.phpnu „[µü¤        PK       S%W]ˆÐS†m  m  B            J‰	 client/src/Responses/FineTuning/ListJobEventsResponseEventData.phpnu „[µü¤        PK       S%W]ŽËÊÅ    ;            )	 client/src/Responses/Embeddings/CreateResponseEmbedding.phpnu „[µü¤        PK       S%W]¨|-9
  9
  2            ˜“	 client/src/Responses/Embeddings/CreateResponse.phpnu „[µü¤        PK       S%W]ÝAEƒ    7            3ž	 client/src/Responses/Embeddings/CreateResponseUsage.phpnu „[µü¤        PK       S%W]³#¹zw  w  @            ž¡	 client/src/Responses/Responses/ToolChoice/FunctionToolChoice.phpnu „[µü¤        PK       S%W]A@ì M  M  >            …¦	 client/src/Responses/Responses/ToolChoice/HostedToolChoice.phpnu „[µü¤        PK       S%W]Ûç­þ}  }  I            @«	 client/src/Responses/Responses/Input/ComputerToolCallOutputScreenshot.phpnu „[µü¤        PK       S%W]ÏØŽE½
  ½
  5            6±	 client/src/Responses/Responses/Input/InputMessage.phpnu „[µü¤        PK       S%W]—œXRâ  â  @            X¼	 client/src/Responses/Responses/Input/AcknowledgedSafetyCheck.phpnu „[µü¤        PK       S%W]n—ßEw  w  E            ªÁ	 client/src/Responses/Responses/Input/InputMessageContentInputText.phpnu „[µü¤        PK       S%W]³À>ž  ž  ?            –Æ	 client/src/Responses/Responses/Input/FunctionToolCallOutput.phpnu „[µü¤        PK       S%W]ƒ¸¹MÙ
  Ù
  ?            £Í	 client/src/Responses/Responses/Input/ComputerToolCallOutput.phpnu „[µü¤        PK       S%W]ÖzÇ  Ç  F            ëØ	 client/src/Responses/Responses/Input/InputMessageContentInputImage.phpnu „[µü¤        PK       S%W]tª}Õ¾  ¾  E            (ß	 client/src/Responses/Responses/Input/InputMessageContentInputFile.phpnu „[µü¤        PK       S%W]/"–”t  t  @            [å	 client/src/Responses/Responses/Streaming/ImageGenerationPart.phpnu „[µü¤        PK       S%W]…–çÉ    E            ?ì	 client/src/Responses/Responses/Streaming/ReasoningSummaryTextDone.phpnu „[µü¤        PK       S%W]ZÕîQ  Q  D            ¸ó	 client/src/Responses/Responses/Streaming/CodeInterpreterCodeDone.phpnu „[µü¤        PK       S%W]¦OkÒ  Ò  ;            }ú	 client/src/Responses/Responses/Streaming/OutputTextDone.phpnu „[µü¤        PK       S%W]Ä[  [  E            º
 client/src/Responses/Responses/Streaming/CodeInterpreterCodeDelta.phpnu „[µü¤        PK       S%W]m|‰  ‰  7            Š
 client/src/Responses/Responses/Streaming/OutputItem.phpnu „[µü¤        PK       S%W]ðøŽ_û  û  4            z
 client/src/Responses/Responses/Streaming/McpCall.phpnu „[µü¤        PK       S%W]øÏÝ>e  e  G            Ù
 client/src/Responses/Responses/Streaming/FunctionCallArgumentsDelta.phpnu „[µü¤        PK       S%W]?·k“Ò  Ò  8            µ&
 client/src/Responses/Responses/Streaming/RefusalDone.phpnu „[µü¤        PK       S%W]…ýqúž  ž  ;            ï-
 client/src/Responses/Responses/Streaming/FileSearchCall.phpnu „[µü¤        PK       S%W]©¸T[  [  C            ø3
 client/src/Responses/Responses/Streaming/McpListToolsInProgress.phpnu „[µü¤        PK       S%W]†ú     F            Æ:
 client/src/Responses/Responses/Streaming/ReasoningSummaryTextDelta.phpnu „[µü¤        PK       S%W]`Y_Ý  Ý  2            JB
 client/src/Responses/Responses/Streaming/Error.phpnu „[µü¤        PK       S%W]Š‚xØÍ  Í  9            ‰H
 client/src/Responses/Responses/Streaming/RefusalDelta.phpnu „[µü¤        PK       S%W]ûŸ…_t  t  F            ¿O
 client/src/Responses/Responses/Streaming/FunctionCallArgumentsDone.phpnu „[µü¤        PK       S%W]wkÐa<  <  F            ©V
 client/src/Responses/Responses/Streaming/OutputTextAnnotationAdded.phpnu „[µü¤        PK       S%W]$©üâ!	  !	  8            [e
 client/src/Responses/Responses/Streaming/ContentPart.phpnu „[µü¤        PK       S%W]‡ûg¶È  È  <            än
 client/src/Responses/Responses/Streaming/OutputTextDelta.phpnu „[µü¤        PK       S%W]?!Ð<  <  H            v
 client/src/Responses/Responses/Streaming/ImageGenerationPartialImage.phpnu „[µü¤        PK       S%W]SØQh    B            Ì~
 client/src/Responses/Responses/Streaming/McpCallArgumentsDelta.phpnu „[µü¤        PK       S%W]ÇÛdÁ  Á  A            F†
 client/src/Responses/Responses/Streaming/ReasoningSummaryPart.phpnu „[µü¤        PK       S%W]WÙ·  ·  @            xŽ
 client/src/Responses/Responses/Streaming/CodeInterpreterCall.phpnu „[µü¤        PK       S%W]™…Í#    A            Ÿ”
 client/src/Responses/Responses/Streaming/McpCallArgumentsDone.phpnu „[µü¤        PK       S%W]ÙÛF™  ™  :            +œ
 client/src/Responses/Responses/Streaming/WebSearchCall.phpnu „[µü¤        PK       S%W]«X    9            .¢
 client/src/Responses/Responses/Streaming/McpListTools.phpnu „[µü¤        PK       S%W]ÇLÔô  ô  G            «§
 client/src/Responses/Responses/CreateResponseUsageInputTokenDetails.phpnu „[µü¤        PK       S%W]ø©)qš  š  1            ¬
 client/src/Responses/Responses/ListInputItems.phpnu „[µü¤        PK       S%W]T‹%Xq  q  8            ¾
 client/src/Responses/Responses/ReferencePromptObject.phpnu „[µü¤        PK       S%W]Œ¥Î²ë  ë  1            êÃ
 client/src/Responses/Responses/DeleteResponse.phpnu „[µü¤        PK       S%W]N²Ä¤    H            6Ê
 client/src/Responses/Responses/CreateResponseUsageOutputTokenDetails.phpnu „[µü¤        PK       S%W]yµ…æ,5  ,5  3            ¹Î
 client/src/Responses/Responses/RetrieveResponse.phpnu „[µü¤        PK       S%W]›ž%Ñ’  ’  9            H client/src/Responses/Responses/CreateStreamedResponse.phpnu „[µü¤        PK       S%W]g©ª    7            C# client/src/Responses/Responses/Tool/ComputerUseTool.phpnu „[µü¤        PK       S%W] mŸ;Y  Y  @            ¸) client/src/Responses/Responses/Tool/FileSearchCompoundFilter.phpnu „[µü¤        PK       S%W]EB´>  >  ;            0 client/src/Responses/Responses/Tool/CodeInterpreterTool.phpnu „[µü¤        PK       S%W]^‹þ//  /  =            *7 client/src/Responses/Responses/Tool/WebSearchUserLocation.phpnu „[µü¤        PK       S%W]p3ªî      5            Æ= client/src/Responses/Responses/Tool/RemoteMcpTool.phpnu „[µü¤        PK       S%W]éuMÍæ  æ  5            KK client/src/Responses/Responses/Tool/WebSearchTool.phpnu „[µü¤        PK       S%W]„iŸÿ  ÿ  D            –R client/src/Responses/Responses/Tool/CodeInterpreterContainerAuto.phpnu „[µü¤        PK       S%W]ˆž
•é	  é	  6            	X client/src/Responses/Responses/Tool/FileSearchTool.phpnu „[µü¤        PK       S%W]a<xc    ?            Xb client/src/Responses/Responses/Tool/FileSearchRankingOption.phpnu „[µü¤        PK       S%W]¤‰óZi  i  ;            Fg client/src/Responses/Responses/Tool/ImageGenerationTool.phpnu „[µü¤        PK       S%W]U/†  †  4            t client/src/Responses/Responses/Tool/FunctionTool.phpnu „[µü¤        PK       S%W]ƒª€z    E            { client/src/Responses/Responses/Tool/ImageGenerationInputImageMask.phpnu „[µü¤        PK       S%W]këiw.  .  B            ø client/src/Responses/Responses/Tool/FileSearchComparisonFilter.phpnu „[µü¤        PK       S%W]m9%(  (  :            ˜… client/src/Responses/Responses/Tool/McpToolNamesFilter.phpnu „[µü¤        PK       S%W]Rˆ‚    6            *Š client/src/Responses/Responses/CreateResponseError.phpnu „[µü¤        PK       S%W]ùŠ¼    7            ¨Ž client/src/Responses/Responses/CreateResponseFormat.phpnu „[µü¤        PK       S%W]XŠ  Š  :            Ÿ• client/src/Responses/Responses/CreateResponseReasoning.phpnu „[µü¤        PK       S%W]S«‚7  ‚7  1            “š client/src/Responses/Responses/CreateResponse.phpnu „[µü¤        PK       S%W]àÎ  Î  B            vÒ client/src/Responses/Responses/CreateResponseIncompleteDetails.phpnu „[µü¤        PK       S%W]']1ZN  N  6            ¶Ö client/src/Responses/Responses/CreateResponseUsage.phpnu „[µü¤        PK       S%W]L=Šw  w  @            jß client/src/Responses/Responses/Output/OutputReasoningSummary.phpnu „[µü¤        PK       S%W]¡€&Â@  @  @            Qä client/src/Responses/Responses/Output/OutputComputerToolCall.phpnu „[µü¤        PK       S%W]žm˜Š	  Š	  7            ÷ client/src/Responses/Responses/Output/OutputMessage.phpnu „[µü¤        PK       S%W]–¥R\+  +  @            ò  client/src/Responses/Responses/Output/OutputFunctionToolCall.phpnu „[µü¤        PK       S%W]Ð¾ïü£  £  H             client/src/Responses/Responses/Output/OutputFileSearchToolCallResult.phpnu „[µü¤        PK       S%W]²ô²OL  L  `            ¨ client/src/Responses/Responses/Output/OutputMessageContentOutputTextAnnotationsContainerFile.phpnu „[µü¤        PK       S%W]Uq«  «  9            „ client/src/Responses/Responses/Output/OutputReasoning.phpnu „[µü¤        PK       S%W]Ÿäûœ  œ  Q            ˜  client/src/Responses/Responses/Output/ComputerAction/OutputComputerActionMove.phpnu „[µü¤        PK       S%W]Ú2³ô  ô  W            µ% client/src/Responses/Responses/Output/ComputerAction/OutputComputerActionScreenshot.phpnu „[µü¤        PK       S%W]¦!î¥Ð  Ð  S            0* client/src/Responses/Responses/Output/ComputerAction/OutputComputerActionScroll.phpnu „[µü¤        PK       S%W]dN’ZH  H  Q            ƒ0 client/src/Responses/Responses/Output/ComputerAction/OutputComputerActionType.phpnu „[µü¤        PK       S%W]1#½hç  ç  Y            L5 client/src/Responses/Responses/Output/ComputerAction/OutputComputerPendingSafetyCheck.phpnu „[µü¤        PK       S%W]¡¥‚Ê  Ê  Q            ¼: client/src/Responses/Responses/Output/ComputerAction/OutputComputerActionWait.phpnu „[µü¤        PK       S%W]í+ìË×  ×  X            ? client/src/Responses/Responses/Output/ComputerAction/OutputComputerActionDoubleClick.phpnu „[µü¤        PK       S%W]¼37˜  ˜  U            fD client/src/Responses/Responses/Output/ComputerAction/OutputComputerActionKeyPress.phpnu „[µü¤        PK       S%W]?w”õ  õ  Q            ƒI client/src/Responses/Responses/Output/ComputerAction/OutputComputerActionDrag.phpnu „[µü¤        PK       S%W]Í=”  ”  R            ùO client/src/Responses/Responses/Output/ComputerAction/OutputComputerActionClick.phpnu „[µü¤        PK       S%W]c\ù  ù  O            V client/src/Responses/Responses/Output/ComputerAction/OutputComputerDragPath.phpnu „[µü¤        PK       S%W]w,ü„ä
  ä
  G            ‡Z client/src/Responses/Responses/Output/OutputCodeInterpreterToolCall.phpnu „[µü¤        PK       S%W]òî·¥E  E  H            âe client/src/Responses/Responses/Output/OutputMessageContentOutputText.phpnu „[µü¤        PK       S%W]Y‚i~    B            Ÿr client/src/Responses/Responses/Output/OutputMcpApprovalRequest.phpnu „[µü¤        PK       S%W]4mþçg  g  H            y client/src/Responses/Responses/Output/CodeInterpreter/CodeTextOutput.phpnu „[µü¤        PK       S%W]y'      H            o~ client/src/Responses/Responses/Output/CodeInterpreter/CodeFileOutput.phpnu „[µü¤        PK       S%W]»“äf  f  H            ç„ client/src/Responses/Responses/Output/CodeInterpreter/CodeFileObject.phpnu „[µü¤        PK       S%W]ªx£âl  l  _            Å‰ client/src/Responses/Responses/Output/OutputMessageContentOutputTextAnnotationsFileCitation.phpnu „[µü¤        PK       S%W]Øa¬Þþ  þ  [            À client/src/Responses/Responses/Output/OutputMessageContentOutputTextAnnotationsFilePath.phpnu „[µü¤        PK       S%W]õÀD>]	  ]	  B            I• client/src/Responses/Responses/Output/OutputFileSearchToolCall.phpnu „[µü¤        PK       S%W]Ü7Aáá  á  G            Ÿ client/src/Responses/Responses/Output/OutputImageGenerationToolCall.phpnu „[µü¤        PK       S%W]YBª    E            p¥ client/src/Responses/Responses/Output/OutputMessageContentRefusal.phpnu „[µü¤        PK       S%W]¹bLr  r  <            dª client/src/Responses/Responses/Output/OutputMcpListTools.phpnu „[µü¤        PK       S%W]°G"i  i  7            B² client/src/Responses/Responses/Output/OutputMcpCall.phpnu „[µü¤        PK       S%W]œœUë–  –  @            » client/src/Responses/Responses/Output/OutputMcpListToolsTool.phpnu „[µü¤        PK       S%W]{åº[H  H  ^            Â client/src/Responses/Responses/Output/OutputMessageContentOutputTextAnnotationsUrlCitation.phpnu „[µü¤        PK       S%W]Ã¥;ë    A            îÈ client/src/Responses/Responses/Output/OutputWebSearchToolCall.phpnu „[µü¤        PK       S%W]"€C”  ”  :            }Î client/src/Responses/Responses/Format/JsonSchemaFormat.phpnu „[µü¤        PK       S%W]TuÝÅ  Å  4            {Õ client/src/Responses/Responses/Format/TextFormat.phpnu „[µü¤        PK       S%W]º^c¨ñ  ñ  :            ¤Ù client/src/Responses/Responses/Format/JsonObjectFormat.phpnu „[µü¤        PK       S%W]ÃœNÓà  à  +            ÿÝ client/src/Responses/Files/ListResponse.phpnu „[µü¤        PK       S%W]Mòë    -            :ç client/src/Responses/Files/DeleteResponse.phpnu „[µü¤        PK       S%W]ì]±v
  v
  /            °í client/src/Responses/Files/RetrieveResponse.phpnu „[µü¤        PK       S%W]î‰Ëp
  p
  -            …ø client/src/Responses/Files/CreateResponse.phpnu „[µü¤        PK       S%W]ã£%dÿ  ÿ  /            R client/src/Responses/FineTunes/ListResponse.phpnu „[µü¤        PK       S%W]¬÷cõ  õ  @            ° client/src/Responses/FineTunes/RetrieveStreamedResponseEvent.phpnu „[µü¤        PK       S%W]rÞrO°  °  3             client/src/Responses/FineTunes/RetrieveResponse.phpnu „[µü¤        PK       S%W]ë~>l  l  >            (8 client/src/Responses/FineTunes/RetrieveResponseHyperparams.phpnu „[µü¤        PK       S%W]{6ök„  „  8            ? client/src/Responses/FineTunes/RetrieveResponseEvent.phpnu „[µü¤        PK       S%W]ØŠšt	  	  7            îD client/src/Responses/FineTunes/RetrieveResponseFile.phpnu „[µü¤        PK       S%W]tuwÇ  Ç  5            \N client/src/Responses/FineTunes/ListEventsResponse.phpnu „[µü¤        PK       S%W]äÃº*½  ½  #            ˆV client/src/Resources/FineTuning.phpnu „[µü¤        PK       S%W]²/>›»  »  #            ˜k client/src/Resources/Assistants.phpnu „[µü¤        PK       S%W]äVúõ                 ¦ client/src/Resources/Batches.phpnu „[µü¤        PK       S%W]”z                ” client/src/Resources/Chat.phpnu „[µü¤        PK       S%W]s”ƒÄ7  7  $            ëœ client/src/Resources/Completions.phpnu „[µü¤        PK       S%W]ÛÄWƒ0  ƒ0  $            v¥ client/src/Resources/ThreadsRuns.phpnu „[µü¤        PK       S%W]”¬“É    #            MÖ client/src/Resources/Containers.phpnu „[µü¤        PK       S%W]Õ¡^    #            ¸á client/src/Resources/Embeddings.phpnu „[µü¤        PK       S%W]òS¢â¯  ¯  "            *æ client/src/Resources/FineTunes.phpnu „[µü¤        PK       S%W];¯Ö  Ö               + client/src/Resources/Threads.phpnu „[µü¤        PK       S%W]QÎ™    %            Q client/src/Resources/VectorStores.phpnu „[µü¤        PK       S%W]6è²Û÷   ÷   /            ³4 client/src/Resources/Concerns/Transportable.phpnu „[µü¤        PK       S%W]\hØw  w  ,            	6 client/src/Resources/Concerns/Streamable.phpnu „[µü¤        PK       S%W]ú7Š@Æ  Æ  !            Ü9 client/src/Resources/Realtime.phpnu „[µü¤        PK       S%W]„BÅr  r              ó@ client/src/Resources/Models.phpnu „[µü¤        PK       S%W]-ˆ}š  š  )            ´I client/src/Resources/ThreadsRunsSteps.phpnu „[µü¤        PK       S%W]õ£Ò¤  ¤              §W client/src/Resources/Audio.phpnu „[µü¤        PK       S%W]ÅÍ?S  S  (            ™g client/src/Resources/ThreadsMessages.phpnu „[µü¤        PK       S%W]Í-³Q  Q  "            D client/src/Resources/Responses.phpnu „[µü¤        PK       S%W]Å¯óq”
  ”
              ç’ client/src/Resources/Images.phpnu „[µü¤        PK       S%W]˜†sœ'  '  *            Ê client/src/Resources/VectorStoresFiles.phpnu „[µü¤        PK       S%W]ˆˆ²æ  æ              K± client/src/Resources/Files.phpnu „[µü¤        PK       S%W]ý:–Ô  Ô              ¾ client/src/Resources/Edits.phpnu „[µü¤        PK       S%W]h£n•I  I  $            ¡Ã client/src/Resources/Moderations.phpnu „[µü¤        PK       S%W]Øf£S  S  0            >È client/src/Resources/VectorStoresFileBatches.phpnu „[µü¤        PK       S%W]N§&‘  ‘              ñ× client/composer.jsonnu „[µü¤        PK       S%W]E_>	I  I              Æà client/LICENSE.mdnu „[µü¤        PK    ÉÉ¿ß  På   